Merge commit '50d3e596bbe89c95615f96eb71f6bc5be737a1db' into Basilisk-releasev2018.07.18

# Conflicts:
#	browser/app/profile/firefox.js
#	browser/components/preferences/jar.mn

273 files changed, 75969 insertions, 0 deletions

diff --git a/application/basilisk/extensions/pdfjs/LICENSE b/application/basilisk/extensions/pdfjs/LICENSE
new file mode 100644
index 000000000..f433b1a53
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/LICENSE
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/application/basilisk/extensions/pdfjs/README.mozilla b/application/basilisk/extensions/pdfjs/README.mozilla
new file mode 100644
index 000000000..884f85eb3
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/README.mozilla
@@ -0,0 +1,3 @@
+This is the pdf.js project output, https://github.com/mozilla/pdf.js
+
+Current extension version is: 1.6.315
diff --git a/application/basilisk/extensions/pdfjs/chrome.manifest b/application/basilisk/extensions/pdfjs/chrome.manifest
new file mode 100644
index 000000000..1aef83abc
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/chrome.manifest
@@ -0,0 +1 @@
+resource pdf.js content/
diff --git a/application/basilisk/extensions/pdfjs/content/PdfJs.jsm b/application/basilisk/extensions/pdfjs/content/PdfJs.jsm
new file mode 100644
index 000000000..b3d85436e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/PdfJs.jsm
@@ -0,0 +1,348 @@
+/* Copyright 2012 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.
+ */
+/* jshint esnext:true */
+/* globals Components, Services, XPCOMUtils, PdfjsChromeUtils,
+           PdfjsContentUtils, PdfStreamConverter */
+
+'use strict';
+
+var EXPORTED_SYMBOLS = ['PdfJs'];
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cm = Components.manager;
+const Cu = Components.utils;
+
+const PREF_PREFIX = 'pdfjs';
+const PREF_DISABLED = PREF_PREFIX + '.disabled';
+const PREF_MIGRATION_VERSION = PREF_PREFIX + '.migrationVersion';
+const PREF_PREVIOUS_ACTION = PREF_PREFIX + '.previousHandler.preferredAction';
+const PREF_PREVIOUS_ASK = PREF_PREFIX +
+                          '.previousHandler.alwaysAskBeforeHandling';
+const PREF_DISABLED_PLUGIN_TYPES = 'plugin.disable_full_page_plugin_for_types';
+const TOPIC_PDFJS_HANDLER_CHANGED = 'pdfjs:handlerChanged';
+const TOPIC_PLUGINS_LIST_UPDATED = 'plugins-list-updated';
+const TOPIC_PLUGIN_INFO_UPDATED = 'plugin-info-updated';
+const PDF_CONTENT_TYPE = 'application/pdf';
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import('resource://gre/modules/Services.jsm');
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(Svc, 'mime',
+                                   '@mozilla.org/mime;1',
+                                   'nsIMIMEService');
+XPCOMUtils.defineLazyServiceGetter(Svc, 'pluginHost',
+                                   '@mozilla.org/plugin/host;1',
+                                   'nsIPluginHost');
+XPCOMUtils.defineLazyModuleGetter(this, 'PdfjsChromeUtils',
+                                  'resource://pdf.js/PdfjsChromeUtils.jsm');
+XPCOMUtils.defineLazyModuleGetter(this, 'PdfjsContentUtils',
+                                  'resource://pdf.js/PdfjsContentUtils.jsm');
+
+function getBoolPref(aPref, aDefaultValue) {
+  try {
+    return Services.prefs.getBoolPref(aPref);
+  } catch (ex) {
+    return aDefaultValue;
+  }
+}
+
+function getIntPref(aPref, aDefaultValue) {
+  try {
+    return Services.prefs.getIntPref(aPref);
+  } catch (ex) {
+    return aDefaultValue;
+  }
+}
+
+function isDefaultHandler() {
+ if (Services.appinfo.processType === Services.appinfo.PROCESS_TYPE_CONTENT) {
+   return PdfjsContentUtils.isDefaultHandlerApp();
+ }
+ return PdfjsChromeUtils.isDefaultHandlerApp();
+}
+
+function initializeDefaultPreferences() {
+  var DEFAULT_PREFERENCES =
+{
+  "showPreviousViewOnLoad": true,
+  "defaultZoomValue": "",
+  "sidebarViewOnLoad": 0,
+  "enableHandToolOnLoad": false,
+  "enableWebGL": false,
+  "pdfBugEnabled": false,
+  "disableRange": false,
+  "disableStream": false,
+  "disableAutoFetch": false,
+  "disableFontFace": false,
+  "disableTextLayer": false,
+  "useOnlyCssZoom": false,
+  "externalLinkTarget": 0,
+  "enhanceTextSelection": false,
+  "renderInteractiveForms": false,
+  "disablePageLabels": false
+}
+
+
+  var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + '.');
+  var defaultValue;
+  for (var key in DEFAULT_PREFERENCES) {
+    defaultValue = DEFAULT_PREFERENCES[key];
+    switch (typeof defaultValue) {
+      case 'boolean':
+        defaultBranch.setBoolPref(key, defaultValue);
+        break;
+      case 'number':
+        defaultBranch.setIntPref(key, defaultValue);
+        break;
+      case 'string':
+        defaultBranch.setCharPref(key, defaultValue);
+        break;
+    }
+  }
+}
+
+// Register/unregister a constructor as a factory.
+function Factory() {}
+Factory.prototype = {
+  register: function register(targetConstructor) {
+    var proto = targetConstructor.prototype;
+    this._classID = proto.classID;
+
+    var factory = XPCOMUtils._getFactory(targetConstructor);
+    this._factory = factory;
+
+    var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+    registrar.registerFactory(proto.classID, proto.classDescription,
+                              proto.contractID, factory);
+
+    if (proto.classID2) {
+      this._classID2 = proto.classID2;
+      registrar.registerFactory(proto.classID2, proto.classDescription,
+                                proto.contractID2, factory);
+    }
+  },
+
+  unregister: function unregister() {
+    var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+    registrar.unregisterFactory(this._classID, this._factory);
+    if (this._classID2) {
+      registrar.unregisterFactory(this._classID2, this._factory);
+    }
+    this._factory = null;
+  }
+};
+
+var PdfJs = {
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]),
+  _registered: false,
+  _initialized: false,
+
+  init: function init(remote) {
+    if (Services.appinfo.processType !==
+        Services.appinfo.PROCESS_TYPE_DEFAULT) {
+      throw new Error('PdfJs.init should only get called ' +
+                      'in the parent process.');
+    }
+    PdfjsChromeUtils.init();
+    if (!remote) {
+      PdfjsContentUtils.init();
+    }
+    this.initPrefs();
+    this.updateRegistration();
+  },
+
+  initPrefs: function initPrefs() {
+    if (this._initialized) {
+      return;
+    }
+    this._initialized = true;
+
+    if (!getBoolPref(PREF_DISABLED, true)) {
+      this._migrate();
+    }
+
+    // Listen for when pdf.js is completely disabled or a different pdf handler
+    // is chosen.
+    Services.prefs.addObserver(PREF_DISABLED, this, false);
+    Services.prefs.addObserver(PREF_DISABLED_PLUGIN_TYPES, this, false);
+    Services.obs.addObserver(this, TOPIC_PDFJS_HANDLER_CHANGED, false);
+    Services.obs.addObserver(this, TOPIC_PLUGINS_LIST_UPDATED, false);
+    Services.obs.addObserver(this, TOPIC_PLUGIN_INFO_UPDATED, false);
+
+    initializeDefaultPreferences();
+  },
+
+  updateRegistration: function updateRegistration() {
+    if (this.enabled) {
+      this._ensureRegistered();
+    } else {
+      this._ensureUnregistered();
+    }
+  },
+
+  uninit: function uninit() {
+    if (this._initialized) {
+      Services.prefs.removeObserver(PREF_DISABLED, this, false);
+      Services.prefs.removeObserver(PREF_DISABLED_PLUGIN_TYPES, this, false);
+      Services.obs.removeObserver(this, TOPIC_PDFJS_HANDLER_CHANGED, false);
+      Services.obs.removeObserver(this, TOPIC_PLUGINS_LIST_UPDATED, false);
+      Services.obs.removeObserver(this, TOPIC_PLUGIN_INFO_UPDATED, false);
+      this._initialized = false;
+    }
+    this._ensureUnregistered();
+  },
+
+  _migrate: function migrate() {
+    const VERSION = 2;
+    var currentVersion = getIntPref(PREF_MIGRATION_VERSION, 0);
+    if (currentVersion >= VERSION) {
+      return;
+    }
+    // Make pdf.js the default pdf viewer on the first migration.
+    if (currentVersion < 1) {
+      this._becomeHandler();
+    }
+    if (currentVersion < 2) {
+      // cleaning up of unused database preference (see #3994)
+      Services.prefs.clearUserPref(PREF_PREFIX + '.database');
+    }
+    Services.prefs.setIntPref(PREF_MIGRATION_VERSION, VERSION);
+  },
+
+  _becomeHandler: function _becomeHandler() {
+    let handlerInfo = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, 'pdf');
+    let prefs = Services.prefs;
+    if (handlerInfo.preferredAction !== Ci.nsIHandlerInfo.handleInternally &&
+        handlerInfo.preferredAction !== false) {
+      // Store the previous settings of preferredAction and
+      // alwaysAskBeforeHandling in case we need to revert them in a hotfix that
+      // would turn pdf.js off.
+      prefs.setIntPref(PREF_PREVIOUS_ACTION, handlerInfo.preferredAction);
+      prefs.setBoolPref(PREF_PREVIOUS_ASK, handlerInfo.alwaysAskBeforeHandling);
+    }
+
+    let handlerService = Cc['@mozilla.org/uriloader/handler-service;1'].
+                         getService(Ci.nsIHandlerService);
+
+    // Change and save mime handler settings.
+    handlerInfo.alwaysAskBeforeHandling = false;
+    handlerInfo.preferredAction = Ci.nsIHandlerInfo.handleInternally;
+    handlerService.store(handlerInfo);
+
+    // Also disable any plugins for pdfs.
+    var stringTypes = '';
+    var types = [];
+    if (prefs.prefHasUserValue(PREF_DISABLED_PLUGIN_TYPES)) {
+      stringTypes = prefs.getCharPref(PREF_DISABLED_PLUGIN_TYPES);
+    }
+    if (stringTypes !== '') {
+      types = stringTypes.split(',');
+    }
+
+    if (types.indexOf(PDF_CONTENT_TYPE) === -1) {
+      types.push(PDF_CONTENT_TYPE);
+    }
+    prefs.setCharPref(PREF_DISABLED_PLUGIN_TYPES, types.join(','));
+
+    // Update the category manager in case the plugins are already loaded.
+    let categoryManager = Cc['@mozilla.org/categorymanager;1'];
+    categoryManager.getService(Ci.nsICategoryManager).
+                    deleteCategoryEntry('Gecko-Content-Viewers',
+                                        PDF_CONTENT_TYPE,
+                                        false);
+  },
+
+  // nsIObserver
+  observe: function observe(aSubject, aTopic, aData) {
+    this.updateRegistration();
+    if (Services.appinfo.processType ===
+        Services.appinfo.PROCESS_TYPE_DEFAULT) {
+      let jsm = 'resource://pdf.js/PdfjsChromeUtils.jsm';
+      let PdfjsChromeUtils = Components.utils.import(jsm, {}).PdfjsChromeUtils;
+      PdfjsChromeUtils.notifyChildOfSettingsChange();
+    }
+  },
+
+  /**
+   * pdf.js is only enabled if it is both selected as the pdf viewer and if the
+   * global switch enabling it is true.
+   * @return {boolean} Whether or not it's enabled.
+   */
+  get enabled() {
+    var disabled = getBoolPref(PREF_DISABLED, true);
+    if (disabled) {
+      return false;
+    }
+
+    // Check if the 'application/pdf' preview handler is configured properly.
+    if (!isDefaultHandler()) {
+      return false;
+    }
+
+    // Check if we have disabled plugin handling of 'application/pdf' in prefs
+    if (Services.prefs.prefHasUserValue(PREF_DISABLED_PLUGIN_TYPES)) {
+      let disabledPluginTypes =
+        Services.prefs.getCharPref(PREF_DISABLED_PLUGIN_TYPES).split(',');
+      if (disabledPluginTypes.indexOf(PDF_CONTENT_TYPE) >= 0) {
+        return true;
+      }
+    }
+
+    // Check if there is an enabled pdf plugin.
+    // Note: this check is performed last because getPluginTags() triggers
+    // costly plugin list initialization (bug 881575)
+    let tags = Cc['@mozilla.org/plugin/host;1'].
+                  getService(Ci.nsIPluginHost).
+                  getPluginTags();
+    let enabledPluginFound = tags.some(function(tag) {
+      if (tag.disabled) {
+        return false;
+      }
+      let mimeTypes = tag.getMimeTypes();
+      return mimeTypes.some(function(mimeType) {
+        return mimeType === PDF_CONTENT_TYPE;
+      });
+    });
+
+    // Use pdf.js if pdf plugin is not present or disabled
+    return !enabledPluginFound;
+  },
+
+  _ensureRegistered: function _ensureRegistered() {
+    if (this._registered) {
+      return;
+    }
+    this._pdfStreamConverterFactory = new Factory();
+    Cu.import('resource://pdf.js/PdfStreamConverter.jsm');
+    this._pdfStreamConverterFactory.register(PdfStreamConverter);
+
+    this._registered = true;
+  },
+
+  _ensureUnregistered: function _ensureUnregistered() {
+    if (!this._registered) {
+      return;
+    }
+    this._pdfStreamConverterFactory.unregister();
+    Cu.unload('resource://pdf.js/PdfStreamConverter.jsm');
+    delete this._pdfStreamConverterFactory;
+
+    this._registered = false;
+  }
+};
+
diff --git a/application/basilisk/extensions/pdfjs/content/PdfJsNetwork.jsm b/application/basilisk/extensions/pdfjs/content/PdfJsNetwork.jsm
new file mode 100644
index 000000000..c3aefecb2
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/PdfJsNetwork.jsm
@@ -0,0 +1,257 @@
+/* Copyright 2012 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.
+ */
+/* globals Components, Services */
+
+'use strict';
+
+Components.utils.import('resource://gre/modules/Services.jsm');
+
+var EXPORTED_SYMBOLS = ['NetworkManager'];
+
+function log(aMsg) {
+  var msg = 'network.js: ' + (aMsg.join ? aMsg.join('') : aMsg);
+  Services.console.logStringMessage(msg);
+}
+
+var NetworkManager = (function NetworkManagerClosure() {
+
+  var OK_RESPONSE = 200;
+  var PARTIAL_CONTENT_RESPONSE = 206;
+
+  function NetworkManager(url, args) {
+    this.url = url;
+    args = args || {};
+    this.isHttp = /^https?:/i.test(url);
+    this.httpHeaders = (this.isHttp && args.httpHeaders) || {};
+    this.withCredentials = args.withCredentials || false;
+    this.getXhr = args.getXhr ||
+      function NetworkManager_getXhr() {
+        return new XMLHttpRequest();
+      };
+
+    this.currXhrId = 0;
+    this.pendingRequests = Object.create(null);
+    this.loadedRequests = Object.create(null);
+  }
+
+  function getArrayBuffer(xhr) {
+    var data = xhr.response;
+    if (typeof data !== 'string') {
+      return data;
+    }
+    var length = data.length;
+    var array = new Uint8Array(length);
+    for (var i = 0; i < length; i++) {
+      array[i] = data.charCodeAt(i) & 0xFF;
+    }
+    return array.buffer;
+  }
+
+  NetworkManager.prototype = {
+    requestRange: function NetworkManager_requestRange(begin, end, listeners) {
+      var args = {
+        begin: begin,
+        end: end
+      };
+      for (var prop in listeners) {
+        args[prop] = listeners[prop];
+      }
+      return this.request(args);
+    },
+
+    requestFull: function NetworkManager_requestFull(listeners) {
+      return this.request(listeners);
+    },
+
+    request: function NetworkManager_request(args) {
+      var xhr = this.getXhr();
+      var xhrId = this.currXhrId++;
+      var pendingRequest = this.pendingRequests[xhrId] = {
+        xhr: xhr
+      };
+
+      xhr.open('GET', this.url);
+      xhr.withCredentials = this.withCredentials;
+      for (var property in this.httpHeaders) {
+        var value = this.httpHeaders[property];
+        if (typeof value === 'undefined') {
+          continue;
+        }
+        xhr.setRequestHeader(property, value);
+      }
+      if (this.isHttp && 'begin' in args && 'end' in args) {
+        var rangeStr = args.begin + '-' + (args.end - 1);
+        xhr.setRequestHeader('Range', 'bytes=' + rangeStr);
+        pendingRequest.expectedStatus = 206;
+      } else {
+        pendingRequest.expectedStatus = 200;
+      }
+
+      var useMozChunkedLoading = !!args.onProgressiveData;
+      if (useMozChunkedLoading) {
+        xhr.responseType = 'moz-chunked-arraybuffer';
+        pendingRequest.onProgressiveData = args.onProgressiveData;
+        pendingRequest.mozChunked = true;
+      } else {
+        xhr.responseType = 'arraybuffer';
+      }
+
+      if (args.onError) {
+        xhr.onerror = function(evt) {
+          args.onError(xhr.status);
+        };
+      }
+      xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
+      xhr.onprogress = this.onProgress.bind(this, xhrId);
+
+      pendingRequest.onHeadersReceived = args.onHeadersReceived;
+      pendingRequest.onDone = args.onDone;
+      pendingRequest.onError = args.onError;
+      pendingRequest.onProgress = args.onProgress;
+
+      xhr.send(null);
+
+      return xhrId;
+    },
+
+    onProgress: function NetworkManager_onProgress(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        // Maybe abortRequest was called...
+        return;
+      }
+
+      if (pendingRequest.mozChunked) {
+        var chunk = getArrayBuffer(pendingRequest.xhr);
+        pendingRequest.onProgressiveData(chunk);
+      }
+
+      var onProgress = pendingRequest.onProgress;
+      if (onProgress) {
+        onProgress(evt);
+      }
+    },
+
+    onStateChange: function NetworkManager_onStateChange(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        // Maybe abortRequest was called...
+        return;
+      }
+
+      var xhr = pendingRequest.xhr;
+      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
+        pendingRequest.onHeadersReceived();
+        delete pendingRequest.onHeadersReceived;
+      }
+
+      if (xhr.readyState !== 4) {
+        return;
+      }
+
+      if (!(xhrId in this.pendingRequests)) {
+        // The XHR request might have been aborted in onHeadersReceived()
+        // callback, in which case we should abort request
+        return;
+      }
+
+      delete this.pendingRequests[xhrId];
+
+      // success status == 0 can be on ftp, file and other protocols
+      if (xhr.status === 0 && this.isHttp) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
+        return;
+      }
+      var xhrStatus = xhr.status || OK_RESPONSE;
+
+      // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.2:
+      // "A server MAY ignore the Range header". This means it's possible to
+      // get a 200 rather than a 206 response from a range request.
+      var ok_response_on_range_request =
+          xhrStatus === OK_RESPONSE &&
+          pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
+
+      if (!ok_response_on_range_request &&
+          xhrStatus !== pendingRequest.expectedStatus) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
+        return;
+      }
+
+      this.loadedRequests[xhrId] = true;
+
+      var chunk = getArrayBuffer(xhr);
+      if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
+        var rangeHeader = xhr.getResponseHeader('Content-Range');
+        var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
+        var begin = parseInt(matches[1], 10);
+        pendingRequest.onDone({
+          begin: begin,
+          chunk: chunk
+        });
+      } else if (pendingRequest.onProgressiveData) {
+        pendingRequest.onDone(null);
+      } else if (chunk) {
+        pendingRequest.onDone({
+          begin: 0,
+          chunk: chunk
+        });
+      } else if (pendingRequest.onError) {
+        pendingRequest.onError(xhr.status);
+      }
+    },
+
+    hasPendingRequests: function NetworkManager_hasPendingRequests() {
+      for (var xhrId in this.pendingRequests) {
+        return true;
+      }
+      return false;
+    },
+
+    getRequestXhr: function NetworkManager_getXhr(xhrId) {
+      return this.pendingRequests[xhrId].xhr;
+    },
+
+    isStreamingRequest: function NetworkManager_isStreamingRequest(xhrId) {
+      return !!(this.pendingRequests[xhrId].onProgressiveData);
+    },
+
+    isPendingRequest: function NetworkManager_isPendingRequest(xhrId) {
+      return xhrId in this.pendingRequests;
+    },
+
+    isLoadedRequest: function NetworkManager_isLoadedRequest(xhrId) {
+      return xhrId in this.loadedRequests;
+    },
+
+    abortAllRequests: function NetworkManager_abortAllRequests() {
+      for (var xhrId in this.pendingRequests) {
+        this.abortRequest(xhrId | 0);
+      }
+    },
+
+    abortRequest: function NetworkManager_abortRequest(xhrId) {
+      var xhr = this.pendingRequests[xhrId].xhr;
+      delete this.pendingRequests[xhrId];
+      xhr.abort();
+    }
+  };
+
+  return NetworkManager;
+})();
+
diff --git a/application/basilisk/extensions/pdfjs/content/PdfJsTelemetry.jsm b/application/basilisk/extensions/pdfjs/content/PdfJsTelemetry.jsm
new file mode 100644
index 000000000..275da9d87
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/PdfJsTelemetry.jsm
@@ -0,0 +1,70 @@
+/* Copyright 2013 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.
+ */
+/* jshint esnext:true, maxlen: 100 */
+/* globals Components, Services */
+
+'use strict';
+
+this.EXPORTED_SYMBOLS = ['PdfJsTelemetry'];
+
+const Cu = Components.utils;
+Cu.import('resource://gre/modules/Services.jsm');
+
+this.PdfJsTelemetry = {
+  onViewerIsUsed: function () {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_USED');
+    histogram.add(true);
+  },
+  onFallback: function () {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_FALLBACK_SHOWN');
+    histogram.add(true);
+  },
+  onDocumentSize: function (size) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_DOCUMENT_SIZE_KB');
+    histogram.add(size / 1024);
+  },
+  onDocumentVersion: function (versionId) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_DOCUMENT_VERSION');
+    histogram.add(versionId);
+  },
+  onDocumentGenerator: function (generatorId) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_DOCUMENT_GENERATOR');
+    histogram.add(generatorId);
+  },
+  onEmbed: function (isObject) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_EMBED');
+    histogram.add(isObject);
+  },
+  onFontType: function (fontTypeId) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_FONT_TYPES');
+    histogram.add(fontTypeId);
+  },
+  onForm: function (isAcroform) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_FORM');
+    histogram.add(isAcroform);
+  },
+  onPrint: function () {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_PRINT');
+    histogram.add(true);
+  },
+  onStreamType: function (streamTypeId) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_STREAM_TYPES');
+    histogram.add(streamTypeId);
+  },
+  onTimeToView: function (ms) {
+    let histogram = Services.telemetry.getHistogramById('PDF_VIEWER_TIME_TO_VIEW_MS');
+    histogram.add(ms);
+  }
+};
diff --git a/application/basilisk/extensions/pdfjs/content/PdfStreamConverter.jsm b/application/basilisk/extensions/pdfjs/content/PdfStreamConverter.jsm
new file mode 100644
index 000000000..5e337bbc5
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/PdfStreamConverter.jsm
@@ -0,0 +1,1054 @@
+/* Copyright 2012 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.
+ */
+/* jshint esnext:true */
+/* globals Components, Services, XPCOMUtils, NetUtil, PrivateBrowsingUtils,
+           dump, NetworkManager, PdfJsTelemetry, PdfjsContentUtils */
+
+'use strict';
+
+var EXPORTED_SYMBOLS = ['PdfStreamConverter'];
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+// True only if this is the version of pdf.js that is included with firefox.
+const MOZ_CENTRAL = JSON.parse('true');
+const PDFJS_EVENT_ID = 'pdf.js.message';
+const PDF_CONTENT_TYPE = 'application/pdf';
+const PREF_PREFIX = 'pdfjs';
+const PDF_VIEWER_ORIGIN = "resource://pdf.js";
+const PDF_VIEWER_WEB_PAGE = "resource://pdf.js/web/viewer.html";
+const MAX_NUMBER_OF_PREFS = 50;
+const MAX_STRING_PREF_LENGTH = 128;
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import('resource://gre/modules/Services.jsm');
+Cu.import('resource://gre/modules/NetUtil.jsm');
+
+XPCOMUtils.defineLazyModuleGetter(this, 'NetworkManager',
+  'resource://pdf.js/PdfJsNetwork.jsm');
+
+XPCOMUtils.defineLazyModuleGetter(this, 'PrivateBrowsingUtils',
+  'resource://gre/modules/PrivateBrowsingUtils.jsm');
+
+XPCOMUtils.defineLazyModuleGetter(this, 'PdfJsTelemetry',
+  'resource://pdf.js/PdfJsTelemetry.jsm');
+
+XPCOMUtils.defineLazyModuleGetter(this, 'PdfjsContentUtils',
+  'resource://pdf.js/PdfjsContentUtils.jsm');
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(Svc, 'mime',
+                                   '@mozilla.org/mime;1',
+                                   'nsIMIMEService');
+
+function getContainingBrowser(domWindow) {
+  return domWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+                  .getInterface(Ci.nsIWebNavigation)
+                  .QueryInterface(Ci.nsIDocShell)
+                  .chromeEventHandler;
+}
+
+function getFindBar(domWindow) {
+  if (PdfjsContentUtils.isRemote) {
+    throw new Error('FindBar is not accessible from the content process.');
+  }
+  try {
+    var browser = getContainingBrowser(domWindow);
+    var tabbrowser = browser.getTabBrowser();
+    var tab = tabbrowser.getTabForBrowser(browser);
+    return tabbrowser.getFindBar(tab);
+  } catch (e) {
+    // Suppress errors for PDF files opened in the bookmark sidebar, see
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1248959.
+    return null;
+  }
+}
+
+function getBoolPref(pref, def) {
+  try {
+    return Services.prefs.getBoolPref(pref);
+  } catch (ex) {
+    return def;
+  }
+}
+
+function getIntPref(pref, def) {
+  try {
+    return Services.prefs.getIntPref(pref);
+  } catch (ex) {
+    return def;
+  }
+}
+
+function getStringPref(pref, def) {
+  try {
+    return Services.prefs.getComplexValue(pref, Ci.nsISupportsString).data;
+  } catch (ex) {
+    return def;
+  }
+}
+
+function log(aMsg) {
+  if (!getBoolPref(PREF_PREFIX + '.pdfBugEnabled', false)) {
+    return;
+  }
+  var msg = 'PdfStreamConverter.js: ' + (aMsg.join ? aMsg.join('') : aMsg);
+  Services.console.logStringMessage(msg);
+  dump(msg + '\n');
+}
+
+function getDOMWindow(aChannel, aPrincipal) {
+  var requestor = aChannel.notificationCallbacks ?
+                  aChannel.notificationCallbacks :
+                  aChannel.loadGroup.notificationCallbacks;
+  var win = requestor.getInterface(Components.interfaces.nsIDOMWindow);
+  // Ensure the window wasn't navigated to something that is not PDF.js.
+  if (!win.document.nodePrincipal.equals(aPrincipal)) {
+    return null;
+  }
+  return win;
+}
+
+function getLocalizedStrings(path) {
+  var stringBundle = Cc['@mozilla.org/intl/stringbundle;1'].
+      getService(Ci.nsIStringBundleService).
+      createBundle('chrome://pdf.js/locale/' + path);
+
+  var map = {};
+  var enumerator = stringBundle.getSimpleEnumeration();
+  while (enumerator.hasMoreElements()) {
+    var string = enumerator.getNext().QueryInterface(Ci.nsIPropertyElement);
+    var key = string.key, property = 'textContent';
+    var i = key.lastIndexOf('.');
+    if (i >= 0) {
+      property = key.substring(i + 1);
+      key = key.substring(0, i);
+    }
+    if (!(key in map)) {
+      map[key] = {};
+    }
+    map[key][property] = string.value;
+  }
+  return map;
+}
+function getLocalizedString(strings, id, property) {
+  property = property || 'textContent';
+  if (id in strings) {
+    return strings[id][property];
+  }
+  return id;
+}
+
+function createNewChannel(uri, node) {
+  return NetUtil.newChannel({
+    uri: uri,
+    loadUsingSystemPrincipal: true,
+  });
+}
+
+function asyncOpenChannel(channel, listener, context) {
+  return channel.asyncOpen2(listener);
+}
+
+function asyncFetchChannel(channel, callback) {
+  return NetUtil.asyncFetch(channel, callback);
+}
+
+// PDF data storage
+function PdfDataListener(length) {
+  this.length = length; // less than 0, if length is unknown
+  this.buffer = null;
+  this.loaded = 0;
+}
+
+PdfDataListener.prototype = {
+  append: function PdfDataListener_append(chunk) {
+    // In most of the cases we will pass data as we receive it, but at the
+    // beginning of the loading we may accumulate some data.
+    if (!this.buffer) {
+      this.buffer = new Uint8Array(chunk);
+    } else {
+      var buffer = this.buffer;
+      var newBuffer = new Uint8Array(buffer.length + chunk.length);
+      newBuffer.set(buffer);
+      newBuffer.set(chunk, buffer.length);
+      this.buffer = newBuffer;
+    }
+    this.loaded += chunk.length;
+    if (this.length >= 0 && this.length < this.loaded) {
+      this.length = -1; // reset the length, server is giving incorrect one
+    }
+    this.onprogress(this.loaded, this.length >= 0 ? this.length : void(0));
+  },
+  readData: function PdfDataListener_readData() {
+    var result = this.buffer;
+    this.buffer = null;
+    return result;
+  },
+  finish: function PdfDataListener_finish() {
+    this.isDataReady = true;
+    if (this.oncompleteCallback) {
+      this.oncompleteCallback(this.readData());
+    }
+  },
+  error: function PdfDataListener_error(errorCode) {
+    this.errorCode = errorCode;
+    if (this.oncompleteCallback) {
+      this.oncompleteCallback(null, errorCode);
+    }
+  },
+  onprogress: function() {},
+  get oncomplete() {
+    return this.oncompleteCallback;
+  },
+  set oncomplete(value) {
+    this.oncompleteCallback = value;
+    if (this.isDataReady) {
+      value(this.readData());
+    }
+    if (this.errorCode) {
+      value(null, this.errorCode);
+    }
+  }
+};
+
+// All the priviledged actions.
+function ChromeActions(domWindow, contentDispositionFilename) {
+  this.domWindow = domWindow;
+  this.contentDispositionFilename = contentDispositionFilename;
+  this.telemetryState = {
+    documentInfo: false,
+    firstPageInfo: false,
+    streamTypesUsed: [],
+    fontTypesUsed: [],
+    startAt: Date.now()
+  };
+}
+
+ChromeActions.prototype = {
+  isInPrivateBrowsing: function() {
+    return PrivateBrowsingUtils.isContentWindowPrivate(this.domWindow);
+  },
+  download: function(data, sendResponse) {
+    var self = this;
+    var originalUrl = data.originalUrl;
+    var blobUrl = data.blobUrl || originalUrl;
+    // The data may not be downloaded so we need just retry getting the pdf with
+    // the original url.
+    var originalUri = NetUtil.newURI(originalUrl);
+    var filename = data.filename;
+    if (typeof filename !== 'string' ||
+        (!/\.pdf$/i.test(filename) && !data.isAttachment)) {
+      filename = 'document.pdf';
+    }
+    var blobUri = NetUtil.newURI(blobUrl);
+    var extHelperAppSvc =
+          Cc['@mozilla.org/uriloader/external-helper-app-service;1'].
+             getService(Ci.nsIExternalHelperAppService);
+
+    var docIsPrivate = this.isInPrivateBrowsing();
+    var netChannel = createNewChannel(blobUri, this.domWindow.document);
+    if ('nsIPrivateBrowsingChannel' in Ci &&
+        netChannel instanceof Ci.nsIPrivateBrowsingChannel) {
+      netChannel.setPrivate(docIsPrivate);
+    }
+    asyncFetchChannel(netChannel, function(aInputStream, aResult) {
+      if (!Components.isSuccessCode(aResult)) {
+        if (sendResponse) {
+          sendResponse(true);
+        }
+        return;
+      }
+      // Create a nsIInputStreamChannel so we can set the url on the channel
+      // so the filename will be correct.
+      var channel = Cc['@mozilla.org/network/input-stream-channel;1'].
+                       createInstance(Ci.nsIInputStreamChannel);
+      channel.QueryInterface(Ci.nsIChannel);
+      try {
+        // contentDisposition/contentDispositionFilename is readonly before FF18
+        channel.contentDisposition = Ci.nsIChannel.DISPOSITION_ATTACHMENT;
+        if (self.contentDispositionFilename && !data.isAttachment) {
+          channel.contentDispositionFilename = self.contentDispositionFilename;
+        } else {
+          channel.contentDispositionFilename = filename;
+        }
+      } catch (e) {}
+      channel.setURI(originalUri);
+      channel.loadInfo = netChannel.loadInfo;
+      channel.contentStream = aInputStream;
+      if ('nsIPrivateBrowsingChannel' in Ci &&
+          channel instanceof Ci.nsIPrivateBrowsingChannel) {
+        channel.setPrivate(docIsPrivate);
+      }
+
+      var listener = {
+        extListener: null,
+        onStartRequest: function(aRequest, aContext) {
+          var loadContext = self.domWindow
+                                .QueryInterface(Ci.nsIInterfaceRequestor)
+                                .getInterface(Ci.nsIWebNavigation)
+                                .QueryInterface(Ci.nsILoadContext);
+          this.extListener = extHelperAppSvc.doContent(
+            (data.isAttachment ? 'application/octet-stream' :
+                                 'application/pdf'),
+            aRequest, loadContext, false);
+          this.extListener.onStartRequest(aRequest, aContext);
+        },
+        onStopRequest: function(aRequest, aContext, aStatusCode) {
+          if (this.extListener) {
+            this.extListener.onStopRequest(aRequest, aContext, aStatusCode);
+          }
+          // Notify the content code we're done downloading.
+          if (sendResponse) {
+            sendResponse(false);
+          }
+        },
+        onDataAvailable: function(aRequest, aContext, aInputStream, aOffset,
+                                  aCount) {
+          this.extListener.onDataAvailable(aRequest, aContext, aInputStream,
+                                           aOffset, aCount);
+        }
+      };
+
+      asyncOpenChannel(channel, listener, null);
+    });
+  },
+  getLocale: function() {
+    return getStringPref('general.useragent.locale', 'en-US');
+  },
+  getStrings: function(data) {
+    try {
+      // Lazy initialization of localizedStrings
+      if (!('localizedStrings' in this)) {
+        this.localizedStrings = getLocalizedStrings('viewer.properties');
+      }
+      var result = this.localizedStrings[data];
+      return JSON.stringify(result || null);
+    } catch (e) {
+      log('Unable to retrieve localized strings: ' + e);
+      return 'null';
+    }
+  },
+  supportsIntegratedFind: function() {
+    // Integrated find is only supported when we're not in a frame
+    if (this.domWindow.frameElement !== null) {
+      return false;
+    }
+
+    // ... and we are in a child process
+    if (PdfjsContentUtils.isRemote) {
+      return true;
+    }
+
+    // ... or when the new find events code exists.
+    var findBar = getFindBar(this.domWindow);
+    return !!findBar && ('updateControlState' in findBar);
+  },
+  supportsDocumentFonts: function() {
+    var prefBrowser = getIntPref('browser.display.use_document_fonts', 1);
+    var prefGfx = getBoolPref('gfx.downloadable_fonts.enabled', true);
+    return (!!prefBrowser && prefGfx);
+  },
+  supportsDocumentColors: function() {
+    return getIntPref('browser.display.document_color_use', 0) !== 2;
+  },
+  supportedMouseWheelZoomModifierKeys: function() {
+    return {
+      ctrlKey: getIntPref('mousewheel.with_control.action', 3) === 3,
+      metaKey: getIntPref('mousewheel.with_meta.action', 1) === 3,
+    };
+  },
+  reportTelemetry: function (data) {
+    var probeInfo = JSON.parse(data);
+    switch (probeInfo.type) {
+      case 'documentInfo':
+        if (!this.telemetryState.documentInfo) {
+          PdfJsTelemetry.onDocumentVersion(probeInfo.version | 0);
+          PdfJsTelemetry.onDocumentGenerator(probeInfo.generator | 0);
+          if (probeInfo.formType) {
+            PdfJsTelemetry.onForm(probeInfo.formType === 'acroform');
+          }
+          this.telemetryState.documentInfo = true;
+        }
+        break;
+      case 'pageInfo':
+        if (!this.telemetryState.firstPageInfo) {
+          var duration = Date.now() - this.telemetryState.startAt;
+          PdfJsTelemetry.onTimeToView(duration);
+          this.telemetryState.firstPageInfo = true;
+        }
+        break;
+      case 'documentStats':
+        // documentStats can be called several times for one documents.
+        // if stream/font types are reported, trying not to submit the same
+        // enumeration value multiple times.
+        var documentStats = probeInfo.stats;
+        if (!documentStats || typeof documentStats !== 'object') {
+          break;
+        }
+        var i, streamTypes = documentStats.streamTypes;
+        if (Array.isArray(streamTypes)) {
+          var STREAM_TYPE_ID_LIMIT = 20;
+          for (i = 0; i < STREAM_TYPE_ID_LIMIT; i++) {
+            if (streamTypes[i] &&
+                !this.telemetryState.streamTypesUsed[i]) {
+              PdfJsTelemetry.onStreamType(i);
+              this.telemetryState.streamTypesUsed[i] = true;
+            }
+          }
+        }
+        var fontTypes = documentStats.fontTypes;
+        if (Array.isArray(fontTypes)) {
+          var FONT_TYPE_ID_LIMIT = 20;
+          for (i = 0; i < FONT_TYPE_ID_LIMIT; i++) {
+            if (fontTypes[i] &&
+                !this.telemetryState.fontTypesUsed[i]) {
+              PdfJsTelemetry.onFontType(i);
+              this.telemetryState.fontTypesUsed[i] = true;
+            }
+          }
+        }
+        break;
+      case 'print':
+        PdfJsTelemetry.onPrint();
+        break;
+    }
+  },
+  fallback: function(args, sendResponse) {
+    var featureId = args.featureId;
+    var url = args.url;
+
+    var self = this;
+    var domWindow = this.domWindow;
+    var strings = getLocalizedStrings('chrome.properties');
+    var message;
+    if (featureId === 'forms') {
+      message = getLocalizedString(strings, 'unsupported_feature_forms');
+    } else {
+      message = getLocalizedString(strings, 'unsupported_feature');
+    }
+    PdfJsTelemetry.onFallback();
+    PdfjsContentUtils.displayWarning(domWindow, message,
+      getLocalizedString(strings, 'open_with_different_viewer'),
+      getLocalizedString(strings, 'open_with_different_viewer', 'accessKey'));
+
+    let winmm = domWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+                         .getInterface(Ci.nsIDocShell)
+                         .QueryInterface(Ci.nsIInterfaceRequestor)
+                         .getInterface(Ci.nsIContentFrameMessageManager);
+
+    winmm.addMessageListener('PDFJS:Child:fallbackDownload',
+      function fallbackDownload(msg) {
+        let data = msg.data;
+        sendResponse(data.download);
+
+        winmm.removeMessageListener('PDFJS:Child:fallbackDownload',
+                                    fallbackDownload);
+      });
+  },
+  updateFindControlState: function(data) {
+    if (!this.supportsIntegratedFind()) {
+      return;
+    }
+    // Verify what we're sending to the findbar.
+    var result = data.result;
+    var findPrevious = data.findPrevious;
+    var findPreviousType = typeof findPrevious;
+    if ((typeof result !== 'number' || result < 0 || result > 3) ||
+        (findPreviousType !== 'undefined' && findPreviousType !== 'boolean')) {
+      return;
+    }
+
+    var winmm = this.domWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+                              .getInterface(Ci.nsIDocShell)
+                              .QueryInterface(Ci.nsIInterfaceRequestor)
+                              .getInterface(Ci.nsIContentFrameMessageManager);
+
+    winmm.sendAsyncMessage('PDFJS:Parent:updateControlState', data);
+  },
+  setPreferences: function(prefs, sendResponse) {
+    var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + '.');
+    var numberOfPrefs = 0;
+    var prefValue, prefName;
+    for (var key in prefs) {
+      if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) {
+        log('setPreferences - Exceeded the maximum number of preferences ' +
+            'that is allowed to be set at once.');
+        break;
+      } else if (!defaultBranch.getPrefType(key)) {
+        continue;
+      }
+      prefValue = prefs[key];
+      prefName = (PREF_PREFIX + '.' + key);
+      switch (typeof prefValue) {
+        case 'boolean':
+          PdfjsContentUtils.setBoolPref(prefName, prefValue);
+          break;
+        case 'number':
+          PdfjsContentUtils.setIntPref(prefName, prefValue);
+          break;
+        case 'string':
+          if (prefValue.length > MAX_STRING_PREF_LENGTH) {
+            log('setPreferences - Exceeded the maximum allowed length ' +
+                'for a string preference.');
+          } else {
+            PdfjsContentUtils.setStringPref(prefName, prefValue);
+          }
+          break;
+      }
+    }
+    if (sendResponse) {
+      sendResponse(true);
+    }
+  },
+  getPreferences: function(prefs, sendResponse) {
+    var defaultBranch = Services.prefs.getDefaultBranch(PREF_PREFIX + '.');
+    var currentPrefs = {}, numberOfPrefs = 0;
+    var prefValue, prefName;
+    for (var key in prefs) {
+      if (++numberOfPrefs > MAX_NUMBER_OF_PREFS) {
+        log('getPreferences - Exceeded the maximum number of preferences ' +
+            'that is allowed to be fetched at once.');
+        break;
+      } else if (!defaultBranch.getPrefType(key)) {
+        continue;
+      }
+      prefValue = prefs[key];
+      prefName = (PREF_PREFIX + '.' + key);
+      switch (typeof prefValue) {
+        case 'boolean':
+          currentPrefs[key] = getBoolPref(prefName, prefValue);
+          break;
+        case 'number':
+          currentPrefs[key] = getIntPref(prefName, prefValue);
+          break;
+        case 'string':
+          currentPrefs[key] = getStringPref(prefName, prefValue);
+          break;
+      }
+    }
+    if (sendResponse) {
+      sendResponse(JSON.stringify(currentPrefs));
+    } else {
+      return JSON.stringify(currentPrefs);
+    }
+  }
+};
+
+var RangedChromeActions = (function RangedChromeActionsClosure() {
+  /**
+   * This is for range requests
+   */
+  function RangedChromeActions(
+              domWindow, contentDispositionFilename, originalRequest,
+              rangeEnabled, streamingEnabled, dataListener) {
+
+    ChromeActions.call(this, domWindow, contentDispositionFilename);
+    this.dataListener = dataListener;
+    this.originalRequest = originalRequest;
+    this.rangeEnabled = rangeEnabled;
+    this.streamingEnabled = streamingEnabled;
+
+    this.pdfUrl = originalRequest.URI.spec;
+    this.contentLength = originalRequest.contentLength;
+
+    // Pass all the headers from the original request through
+    var httpHeaderVisitor = {
+      headers: {},
+      visitHeader: function(aHeader, aValue) {
+        if (aHeader === 'Range') {
+          // When loading the PDF from cache, firefox seems to set the Range
+          // request header to fetch only the unfetched portions of the file
+          // (e.g. 'Range: bytes=1024-'). However, we want to set this header
+          // manually to fetch the PDF in chunks.
+          return;
+        }
+        this.headers[aHeader] = aValue;
+      }
+    };
+    if (originalRequest.visitRequestHeaders) {
+      originalRequest.visitRequestHeaders(httpHeaderVisitor);
+    }
+
+    var self = this;
+    var xhr_onreadystatechange = function xhr_onreadystatechange() {
+      if (this.readyState === 1) { // LOADING
+        var netChannel = this.channel;
+        if ('nsIPrivateBrowsingChannel' in Ci &&
+            netChannel instanceof Ci.nsIPrivateBrowsingChannel) {
+          var docIsPrivate = self.isInPrivateBrowsing();
+          netChannel.setPrivate(docIsPrivate);
+        }
+      }
+    };
+    var getXhr = function getXhr() {
+      const XMLHttpRequest = Components.Constructor(
+          '@mozilla.org/xmlextras/xmlhttprequest;1');
+      var xhr = new XMLHttpRequest();
+      xhr.addEventListener('readystatechange', xhr_onreadystatechange);
+      return xhr;
+    };
+
+    this.networkManager = new NetworkManager(this.pdfUrl, {
+      httpHeaders: httpHeaderVisitor.headers,
+      getXhr: getXhr
+    });
+
+    // If we are in range request mode, this means we manually issued xhr
+    // requests, which we need to abort when we leave the page
+    domWindow.addEventListener('unload', function unload(e) {
+      domWindow.removeEventListener(e.type, unload);
+      self.abortLoading();
+    });
+  }
+
+  RangedChromeActions.prototype = Object.create(ChromeActions.prototype);
+  var proto = RangedChromeActions.prototype;
+  proto.constructor = RangedChromeActions;
+
+  proto.initPassiveLoading = function RangedChromeActions_initPassiveLoading() {
+    var self = this;
+    var data;
+    if (!this.streamingEnabled) {
+      this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+      this.originalRequest = null;
+      data = this.dataListener.readData();
+      this.dataListener = null;
+    } else {
+      data = this.dataListener.readData();
+
+      this.dataListener.onprogress = function (loaded, total) {
+        self.domWindow.postMessage({
+          pdfjsLoadAction: 'progressiveRead',
+          loaded: loaded,
+          total: total,
+          chunk: self.dataListener.readData()
+        }, PDF_VIEWER_ORIGIN);
+      };
+      this.dataListener.oncomplete = function () {
+        self.dataListener = null;
+      };
+    }
+
+    this.domWindow.postMessage({
+      pdfjsLoadAction: 'supportsRangedLoading',
+      rangeEnabled: this.rangeEnabled,
+      streamingEnabled: this.streamingEnabled,
+      pdfUrl: this.pdfUrl,
+      length: this.contentLength,
+      data: data
+    }, PDF_VIEWER_ORIGIN);
+
+    return true;
+  };
+
+  proto.requestDataRange = function RangedChromeActions_requestDataRange(args) {
+    if (!this.rangeEnabled) {
+      return;
+    }
+
+    var begin = args.begin;
+    var end = args.end;
+    var domWindow = this.domWindow;
+    // TODO(mack): Support error handler. We're not currently not handling
+    // errors from chrome code for non-range requests, so this doesn't
+    // seem high-pri
+    this.networkManager.requestRange(begin, end, {
+      onDone: function RangedChromeActions_onDone(args) {
+        domWindow.postMessage({
+          pdfjsLoadAction: 'range',
+          begin: args.begin,
+          chunk: args.chunk
+        }, PDF_VIEWER_ORIGIN);
+      },
+      onProgress: function RangedChromeActions_onProgress(evt) {
+        domWindow.postMessage({
+          pdfjsLoadAction: 'rangeProgress',
+          loaded: evt.loaded,
+        }, PDF_VIEWER_ORIGIN);
+      }
+    });
+  };
+
+  proto.abortLoading = function RangedChromeActions_abortLoading() {
+    this.networkManager.abortAllRequests();
+    if (this.originalRequest) {
+      this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+      this.originalRequest = null;
+    }
+    this.dataListener = null;
+  };
+
+  return RangedChromeActions;
+})();
+
+var StandardChromeActions = (function StandardChromeActionsClosure() {
+
+  /**
+   * This is for a single network stream
+   */
+  function StandardChromeActions(domWindow, contentDispositionFilename,
+                                 originalRequest, dataListener) {
+
+    ChromeActions.call(this, domWindow, contentDispositionFilename);
+    this.originalRequest = originalRequest;
+    this.dataListener = dataListener;
+  }
+
+  StandardChromeActions.prototype = Object.create(ChromeActions.prototype);
+  var proto = StandardChromeActions.prototype;
+  proto.constructor = StandardChromeActions;
+
+  proto.initPassiveLoading =
+      function StandardChromeActions_initPassiveLoading() {
+
+    if (!this.dataListener) {
+      return false;
+    }
+
+    var self = this;
+
+    this.dataListener.onprogress = function ChromeActions_dataListenerProgress(
+                                      loaded, total) {
+      self.domWindow.postMessage({
+        pdfjsLoadAction: 'progress',
+        loaded: loaded,
+        total: total
+      }, PDF_VIEWER_ORIGIN);
+    };
+
+    this.dataListener.oncomplete =
+        function StandardChromeActions_dataListenerComplete(data, errorCode) {
+      self.domWindow.postMessage({
+        pdfjsLoadAction: 'complete',
+        data: data,
+        errorCode: errorCode
+      }, PDF_VIEWER_ORIGIN);
+
+      self.dataListener = null;
+      self.originalRequest = null;
+    };
+
+    return true;
+  };
+
+  proto.abortLoading = function StandardChromeActions_abortLoading() {
+    if (this.originalRequest) {
+      this.originalRequest.cancel(Cr.NS_BINDING_ABORTED);
+      this.originalRequest = null;
+    }
+    this.dataListener = null;
+  };
+
+  return StandardChromeActions;
+})();
+
+// Event listener to trigger chrome privileged code.
+function RequestListener(actions) {
+  this.actions = actions;
+}
+// Receive an event and synchronously or asynchronously responds.
+RequestListener.prototype.receive = function(event) {
+  var message = event.target;
+  var doc = message.ownerDocument;
+  var action = event.detail.action;
+  var data = event.detail.data;
+  var sync = event.detail.sync;
+  var actions = this.actions;
+  if (!(action in actions)) {
+    log('Unknown action: ' + action);
+    return;
+  }
+  var response;
+  if (sync) {
+    response = actions[action].call(this.actions, data);
+    event.detail.response = Cu.cloneInto(response, doc.defaultView);
+  } else {
+    if (!event.detail.responseExpected) {
+      doc.documentElement.removeChild(message);
+      response = null;
+    } else {
+      response = function sendResponse(response) {
+        try {
+          var listener = doc.createEvent('CustomEvent');
+          let detail = Cu.cloneInto({ response: response }, doc.defaultView);
+          listener.initCustomEvent('pdf.js.response', true, false, detail);
+          return message.dispatchEvent(listener);
+        } catch (e) {
+          // doc is no longer accessible because the requestor is already
+          // gone. unloaded content cannot receive the response anyway.
+          return false;
+        }
+      };
+    }
+    actions[action].call(this.actions, data, response);
+  }
+};
+
+// Forwards events from the eventElement to the contentWindow only if the
+// content window matches the currently selected browser window.
+function FindEventManager(contentWindow) {
+  this.contentWindow = contentWindow;
+  this.winmm = contentWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+                            .getInterface(Ci.nsIDocShell)
+                            .QueryInterface(Ci.nsIInterfaceRequestor)
+                            .getInterface(Ci.nsIContentFrameMessageManager);
+}
+
+FindEventManager.prototype.bind = function() {
+  var unload = function(e) {
+    this.unbind();
+    this.contentWindow.removeEventListener(e.type, unload);
+  }.bind(this);
+  this.contentWindow.addEventListener('unload', unload);
+
+  // We cannot directly attach listeners to for the find events
+  // since the FindBar is in the parent process. Instead we're
+  // asking the PdfjsChromeUtils to do it for us and forward
+  // all the find events to us.
+  this.winmm.sendAsyncMessage('PDFJS:Parent:addEventListener');
+  this.winmm.addMessageListener('PDFJS:Child:handleEvent', this);
+};
+
+FindEventManager.prototype.receiveMessage = function(msg) {
+  var detail = msg.data.detail;
+  var type = msg.data.type;
+  var contentWindow = this.contentWindow;
+
+  detail = Cu.cloneInto(detail, contentWindow);
+  var forward = contentWindow.document.createEvent('CustomEvent');
+  forward.initCustomEvent(type, true, true, detail);
+  contentWindow.dispatchEvent(forward);
+};
+
+FindEventManager.prototype.unbind = function() {
+  this.winmm.sendAsyncMessage('PDFJS:Parent:removeEventListener');
+};
+
+function PdfStreamConverter() {
+}
+
+PdfStreamConverter.prototype = {
+
+  // properties required for XPCOM registration:
+  classID: Components.ID('{d0c5195d-e798-49d4-b1d3-9324328b2291}'),
+  classDescription: 'pdf.js Component',
+  contractID: '@mozilla.org/streamconv;1?from=application/pdf&to=*/*',
+
+  classID2: Components.ID('{d0c5195d-e798-49d4-b1d3-9324328b2292}'),
+  contractID2: '@mozilla.org/streamconv;1?from=application/pdf&to=text/html',
+
+  QueryInterface: XPCOMUtils.generateQI([
+      Ci.nsISupports,
+      Ci.nsIStreamConverter,
+      Ci.nsIStreamListener,
+      Ci.nsIRequestObserver
+  ]),
+
+  /*
+   * This component works as such:
+   * 1. asyncConvertData stores the listener
+   * 2. onStartRequest creates a new channel, streams the viewer
+   * 3. If range requests are supported:
+   *      3.1. Leave the request open until the viewer is ready to switch to
+   *           range requests.
+   *
+   *    If range rquests are not supported:
+   *      3.1. Read the stream as it's loaded in onDataAvailable to send
+   *           to the viewer
+   *
+   * The convert function just returns the stream, it's just the synchronous
+   * version of asyncConvertData.
+   */
+
+  // nsIStreamConverter::convert
+  convert: function(aFromStream, aFromType, aToType, aCtxt) {
+    throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+  },
+
+  // nsIStreamConverter::asyncConvertData
+  asyncConvertData: function(aFromType, aToType, aListener, aCtxt) {
+    // Store the listener passed to us
+    this.listener = aListener;
+  },
+
+  // nsIStreamListener::onDataAvailable
+  onDataAvailable: function(aRequest, aContext, aInputStream, aOffset, aCount) {
+    if (!this.dataListener) {
+      return;
+    }
+
+    var binaryStream = this.binaryStream;
+    binaryStream.setInputStream(aInputStream);
+    var chunk = binaryStream.readByteArray(aCount);
+    this.dataListener.append(chunk);
+  },
+
+  // nsIRequestObserver::onStartRequest
+  onStartRequest: function(aRequest, aContext) {
+    // Setup the request so we can use it below.
+    var isHttpRequest = false;
+    try {
+      aRequest.QueryInterface(Ci.nsIHttpChannel);
+      isHttpRequest = true;
+    } catch (e) {}
+
+    var rangeRequest = false;
+    var streamRequest = false;
+    if (isHttpRequest) {
+      var contentEncoding = 'identity';
+      try {
+        contentEncoding = aRequest.getResponseHeader('Content-Encoding');
+      } catch (e) {}
+
+      var acceptRanges;
+      try {
+        acceptRanges = aRequest.getResponseHeader('Accept-Ranges');
+      } catch (e) {}
+
+      var hash = aRequest.URI.ref;
+      var isPDFBugEnabled = getBoolPref(PREF_PREFIX + '.pdfBugEnabled', false);
+      rangeRequest = contentEncoding === 'identity' &&
+                     acceptRanges === 'bytes' &&
+                     aRequest.contentLength >= 0 &&
+                     !getBoolPref(PREF_PREFIX + '.disableRange', false) &&
+                     (!isPDFBugEnabled ||
+                      hash.toLowerCase().indexOf('disablerange=true') < 0);
+      streamRequest = contentEncoding === 'identity' &&
+                      aRequest.contentLength >= 0 &&
+                      !getBoolPref(PREF_PREFIX + '.disableStream', false) &&
+                      (!isPDFBugEnabled ||
+                       hash.toLowerCase().indexOf('disablestream=true') < 0);
+    }
+
+    aRequest.QueryInterface(Ci.nsIChannel);
+
+    aRequest.QueryInterface(Ci.nsIWritablePropertyBag);
+
+    var contentDispositionFilename;
+    try {
+      contentDispositionFilename = aRequest.contentDispositionFilename;
+    } catch (e) {}
+
+    // Change the content type so we don't get stuck in a loop.
+    aRequest.setProperty('contentType', aRequest.contentType);
+    aRequest.contentType = 'text/html';
+    if (isHttpRequest) {
+      // We trust PDF viewer, using no CSP
+      aRequest.setResponseHeader('Content-Security-Policy', '', false);
+      aRequest.setResponseHeader('Content-Security-Policy-Report-Only', '',
+                                 false);
+      // The viewer does not need to handle HTTP Refresh header.
+      aRequest.setResponseHeader('Refresh', '', false);
+    }
+
+    PdfJsTelemetry.onViewerIsUsed();
+    PdfJsTelemetry.onDocumentSize(aRequest.contentLength);
+
+    // Creating storage for PDF data
+    var contentLength = aRequest.contentLength;
+    this.dataListener = new PdfDataListener(contentLength);
+    this.binaryStream = Cc['@mozilla.org/binaryinputstream;1']
+                        .createInstance(Ci.nsIBinaryInputStream);
+
+    // Create a new channel that is viewer loaded as a resource.
+    var channel = createNewChannel(PDF_VIEWER_WEB_PAGE, null);
+
+    var listener = this.listener;
+    var dataListener = this.dataListener;
+    // Proxy all the request observer calls, when it gets to onStopRequest
+    // we can get the dom window.  We also intentionally pass on the original
+    // request(aRequest) below so we don't overwrite the original channel and
+    // trigger an assertion.
+    var proxy = {
+      onStartRequest: function(request, context) {
+        listener.onStartRequest(aRequest, aContext);
+      },
+      onDataAvailable: function(request, context, inputStream, offset, count) {
+        listener.onDataAvailable(aRequest, aContext, inputStream,
+                                 offset, count);
+      },
+      onStopRequest(request, context, statusCode) {
+        var domWindow = getDOMWindow(channel, resourcePrincipal);
+        if (!Components.isSuccessCode(statusCode) || !domWindow) {
+          // The request may have been aborted and the document may have been
+          // replaced with something that is not PDF.js, abort attaching.
+          listener.onStopRequest(aRequest, context, statusCode);
+          return;
+        }
+        var actions;
+        if (rangeRequest || streamRequest) {
+          actions = new RangedChromeActions(
+            domWindow, contentDispositionFilename, aRequest,
+            rangeRequest, streamRequest, dataListener);
+        } else {
+          actions = new StandardChromeActions(
+            domWindow, contentDispositionFilename, aRequest, dataListener);
+        }
+        var requestListener = new RequestListener(actions);
+        domWindow.document.addEventListener(PDFJS_EVENT_ID, function(event) {
+          requestListener.receive(event);
+        }, false, true);
+        if (actions.supportsIntegratedFind()) {
+          var findEventManager = new FindEventManager(domWindow);
+          findEventManager.bind();
+        }
+        listener.onStopRequest(aRequest, aContext, statusCode);
+
+        if (domWindow.frameElement) {
+          var isObjectEmbed = domWindow.frameElement.tagName !== 'IFRAME' ||
+            domWindow.frameElement.className === 'previewPluginContentFrame';
+          PdfJsTelemetry.onEmbed(isObjectEmbed);
+        }
+      }
+    };
+
+    // Keep the URL the same so the browser sees it as the same.
+    channel.originalURI = aRequest.URI;
+    channel.loadGroup = aRequest.loadGroup;
+    channel.loadInfo.originAttributes = aRequest.loadInfo.originAttributes;
+
+    // We can use the resource principal when data is fetched by the chrome,
+    // e.g. useful for NoScript. Make make sure we reuse the origin attributes
+    // from the request channel to keep isolation consistent.
+    var ssm = Cc['@mozilla.org/scriptsecuritymanager;1']
+                .getService(Ci.nsIScriptSecurityManager);
+    var uri = NetUtil.newURI(PDF_VIEWER_WEB_PAGE, null, null);
+    var resourcePrincipal;
+    resourcePrincipal =
+      ssm.createCodebasePrincipal(uri, aRequest.loadInfo.originAttributes);
+    aRequest.owner = resourcePrincipal;
+    asyncOpenChannel(channel, proxy, aContext);
+  },
+
+  // nsIRequestObserver::onStopRequest
+  onStopRequest: function(aRequest, aContext, aStatusCode) {
+    if (!this.dataListener) {
+      // Do nothing
+      return;
+    }
+
+    if (Components.isSuccessCode(aStatusCode)) {
+      this.dataListener.finish();
+    } else {
+      this.dataListener.error(aStatusCode);
+    }
+    delete this.dataListener;
+    delete this.binaryStream;
+  }
+};
+
diff --git a/application/basilisk/extensions/pdfjs/content/PdfjsChromeUtils.jsm b/application/basilisk/extensions/pdfjs/content/PdfjsChromeUtils.jsm
new file mode 100644
index 000000000..7a082b6af
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/PdfjsChromeUtils.jsm
@@ -0,0 +1,357 @@
+/* Copyright 2012 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.
+ */
+/* jshint esnext:true */
+/* globals Components, Services, XPCOMUtils */
+
+'use strict';
+
+var EXPORTED_SYMBOLS = ['PdfjsChromeUtils'];
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+
+const PREF_PREFIX = 'pdfjs';
+const PDF_CONTENT_TYPE = 'application/pdf';
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import('resource://gre/modules/Services.jsm');
+
+var Svc = {};
+XPCOMUtils.defineLazyServiceGetter(Svc, 'mime',
+                                   '@mozilla.org/mime;1',
+                                   'nsIMIMEService');
+
+var DEFAULT_PREFERENCES =
+{
+  "showPreviousViewOnLoad": true,
+  "defaultZoomValue": "",
+  "sidebarViewOnLoad": 0,
+  "enableHandToolOnLoad": false,
+  "enableWebGL": false,
+  "pdfBugEnabled": false,
+  "disableRange": false,
+  "disableStream": false,
+  "disableAutoFetch": false,
+  "disableFontFace": false,
+  "disableTextLayer": false,
+  "useOnlyCssZoom": false,
+  "externalLinkTarget": 0,
+  "enhanceTextSelection": false,
+  "renderInteractiveForms": false,
+  "disablePageLabels": false
+}
+
+
+var PdfjsChromeUtils = {
+  // For security purposes when running remote, we restrict preferences
+  // content can access.
+  _allowedPrefNames: Object.keys(DEFAULT_PREFERENCES),
+  _ppmm: null,
+  _mmg: null,
+
+  /*
+   * Public API
+   */
+
+  init: function () {
+    this._browsers = new WeakSet();
+    if (!this._ppmm) {
+      // global parent process message manager (PPMM)
+      this._ppmm = Cc['@mozilla.org/parentprocessmessagemanager;1'].
+        getService(Ci.nsIMessageBroadcaster);
+      this._ppmm.addMessageListener('PDFJS:Parent:clearUserPref', this);
+      this._ppmm.addMessageListener('PDFJS:Parent:setIntPref', this);
+      this._ppmm.addMessageListener('PDFJS:Parent:setBoolPref', this);
+      this._ppmm.addMessageListener('PDFJS:Parent:setCharPref', this);
+      this._ppmm.addMessageListener('PDFJS:Parent:setStringPref', this);
+      this._ppmm.addMessageListener('PDFJS:Parent:isDefaultHandlerApp', this);
+
+      // global dom message manager (MMg)
+      this._mmg = Cc['@mozilla.org/globalmessagemanager;1'].
+        getService(Ci.nsIMessageListenerManager);
+      this._mmg.addMessageListener('PDFJS:Parent:displayWarning', this);
+
+      this._mmg.addMessageListener('PDFJS:Parent:addEventListener', this);
+      this._mmg.addMessageListener('PDFJS:Parent:removeEventListener', this);
+      this._mmg.addMessageListener('PDFJS:Parent:updateControlState', this);
+
+      // observer to handle shutdown
+      Services.obs.addObserver(this, 'quit-application', false);
+    }
+  },
+
+  uninit: function () {
+    if (this._ppmm) {
+      this._ppmm.removeMessageListener('PDFJS:Parent:clearUserPref', this);
+      this._ppmm.removeMessageListener('PDFJS:Parent:setIntPref', this);
+      this._ppmm.removeMessageListener('PDFJS:Parent:setBoolPref', this);
+      this._ppmm.removeMessageListener('PDFJS:Parent:setCharPref', this);
+      this._ppmm.removeMessageListener('PDFJS:Parent:setStringPref', this);
+      this._ppmm.removeMessageListener('PDFJS:Parent:isDefaultHandlerApp',
+                                       this);
+
+      this._mmg.removeMessageListener('PDFJS:Parent:displayWarning', this);
+
+      this._mmg.removeMessageListener('PDFJS:Parent:addEventListener', this);
+      this._mmg.removeMessageListener('PDFJS:Parent:removeEventListener', this);
+      this._mmg.removeMessageListener('PDFJS:Parent:updateControlState', this);
+
+      Services.obs.removeObserver(this, 'quit-application', false);
+
+      this._mmg = null;
+      this._ppmm = null;
+    }
+  },
+
+  /*
+   * Called by the main module when preference changes are picked up
+   * in the parent process. Observers don't propagate so we need to
+   * instruct the child to refresh its configuration and (possibly)
+   * the module's registration.
+   */
+  notifyChildOfSettingsChange: function () {
+    if (Services.appinfo.processType ===
+        Services.appinfo.PROCESS_TYPE_DEFAULT && this._ppmm) {
+      // XXX kinda bad, we want to get the parent process mm associated
+      // with the content process. _ppmm is currently the global process
+      // manager, which means this is going to fire to every child process
+      // we have open. Unfortunately I can't find a way to get at that
+      // process specific mm from js.
+      this._ppmm.broadcastAsyncMessage('PDFJS:Child:refreshSettings', {});
+    }
+  },
+
+  /*
+   * Events
+   */
+
+  observe: function(aSubject, aTopic, aData) {
+    if (aTopic === 'quit-application') {
+      this.uninit();
+    }
+  },
+
+  receiveMessage: function (aMsg) {
+    switch (aMsg.name) {
+      case 'PDFJS:Parent:clearUserPref':
+        this._clearUserPref(aMsg.data.name);
+        break;
+      case 'PDFJS:Parent:setIntPref':
+        this._setIntPref(aMsg.data.name, aMsg.data.value);
+        break;
+      case 'PDFJS:Parent:setBoolPref':
+        this._setBoolPref(aMsg.data.name, aMsg.data.value);
+        break;
+      case 'PDFJS:Parent:setCharPref':
+        this._setCharPref(aMsg.data.name, aMsg.data.value);
+        break;
+      case 'PDFJS:Parent:setStringPref':
+        this._setStringPref(aMsg.data.name, aMsg.data.value);
+        break;
+      case 'PDFJS:Parent:isDefaultHandlerApp':
+        return this.isDefaultHandlerApp();
+      case 'PDFJS:Parent:displayWarning':
+        this._displayWarning(aMsg);
+        break;
+
+
+      case 'PDFJS:Parent:updateControlState':
+        return this._updateControlState(aMsg);
+      case 'PDFJS:Parent:addEventListener':
+        return this._addEventListener(aMsg);
+      case 'PDFJS:Parent:removeEventListener':
+        return this._removeEventListener(aMsg);
+    }
+  },
+
+  /*
+   * Internal
+   */
+
+  _findbarFromMessage: function(aMsg) {
+    let browser = aMsg.target;
+    let tabbrowser = browser.getTabBrowser();
+    let tab = tabbrowser.getTabForBrowser(browser);
+    return tabbrowser.getFindBar(tab);
+  },
+
+  _updateControlState: function (aMsg) {
+    let data = aMsg.data;
+    this._findbarFromMessage(aMsg)
+        .updateControlState(data.result, data.findPrevious);
+  },
+
+  handleEvent: function(aEvent) {
+    // To avoid forwarding the message as a CPOW, create a structured cloneable
+    // version of the event for both performance, and ease of usage, reasons.
+    let type = aEvent.type;
+    let detail = {
+      query: aEvent.detail.query,
+      caseSensitive: aEvent.detail.caseSensitive,
+      highlightAll: aEvent.detail.highlightAll,
+      findPrevious: aEvent.detail.findPrevious
+    };
+
+    let browser = aEvent.currentTarget.browser;
+    if (!this._browsers.has(browser)) {
+      throw new Error('FindEventManager was not bound ' +
+                      'for the current browser.');
+    }
+    // Only forward the events if the current browser is a registered browser.
+    let mm = browser.messageManager;
+    mm.sendAsyncMessage('PDFJS:Child:handleEvent',
+                        { type: type, detail: detail });
+    aEvent.preventDefault();
+  },
+
+  _types: ['find',
+           'findagain',
+           'findhighlightallchange',
+           'findcasesensitivitychange'],
+
+  _addEventListener: function (aMsg) {
+    let browser = aMsg.target;
+    if (this._browsers.has(browser)) {
+      throw new Error('FindEventManager was bound 2nd time ' +
+                      'without unbinding it first.');
+    }
+
+    // Since this jsm is global, we need to store all the browsers
+    // we have to forward the messages for.
+    this._browsers.add(browser);
+
+    // And we need to start listening to find events.
+    for (var i = 0; i < this._types.length; i++) {
+      var type = this._types[i];
+      this._findbarFromMessage(aMsg)
+          .addEventListener(type, this, true);
+    }
+  },
+
+  _removeEventListener: function (aMsg) {
+    let browser = aMsg.target;
+    if (!this._browsers.has(browser)) {
+      throw new Error('FindEventManager was unbound without binding it first.');
+    }
+
+    this._browsers.delete(browser);
+
+    // No reason to listen to find events any longer.
+    for (var i = 0; i < this._types.length; i++) {
+      var type = this._types[i];
+      this._findbarFromMessage(aMsg)
+          .removeEventListener(type, this, true);
+    }
+  },
+
+  _ensurePreferenceAllowed: function (aPrefName) {
+    let unPrefixedName = aPrefName.split(PREF_PREFIX + '.');
+    if (unPrefixedName[0] !== '' ||
+        this._allowedPrefNames.indexOf(unPrefixedName[1]) === -1) {
+      let msg = '"' + aPrefName + '" ' +
+                'can\'t be accessed from content. See PdfjsChromeUtils.';
+      throw new Error(msg);
+    }
+  },
+
+  _clearUserPref: function (aPrefName) {
+    this._ensurePreferenceAllowed(aPrefName);
+    Services.prefs.clearUserPref(aPrefName);
+  },
+
+  _setIntPref: function (aPrefName, aPrefValue) {
+    this._ensurePreferenceAllowed(aPrefName);
+    Services.prefs.setIntPref(aPrefName, aPrefValue);
+  },
+
+  _setBoolPref: function (aPrefName, aPrefValue) {
+    this._ensurePreferenceAllowed(aPrefName);
+    Services.prefs.setBoolPref(aPrefName, aPrefValue);
+  },
+
+  _setCharPref: function (aPrefName, aPrefValue) {
+    this._ensurePreferenceAllowed(aPrefName);
+    Services.prefs.setCharPref(aPrefName, aPrefValue);
+  },
+
+  _setStringPref: function (aPrefName, aPrefValue) {
+    this._ensurePreferenceAllowed(aPrefName);
+    let str = Cc['@mozilla.org/supports-string;1']
+                .createInstance(Ci.nsISupportsString);
+    str.data = aPrefValue;
+    Services.prefs.setComplexValue(aPrefName, Ci.nsISupportsString, str);
+  },
+
+  /*
+   * Svc.mime doesn't have profile information in the child, so
+   * we bounce this pdfjs enabled configuration check over to the
+   * parent.
+   */
+  isDefaultHandlerApp: function () {
+    var handlerInfo = Svc.mime.getFromTypeAndExtension(PDF_CONTENT_TYPE, 'pdf');
+    return (!handlerInfo.alwaysAskBeforeHandling &&
+            handlerInfo.preferredAction === Ci.nsIHandlerInfo.handleInternally);
+  },
+
+  /*
+   * Display a notification warning when the renderer isn't sure
+   * a pdf displayed correctly.
+   */
+  _displayWarning: function (aMsg) {
+    let data = aMsg.data;
+    let browser = aMsg.target;
+
+    let tabbrowser = browser.getTabBrowser();
+    let notificationBox = tabbrowser.getNotificationBox(browser);
+
+    // Flag so we don't send the message twice, since if the user clicks
+    // "open with different viewer" both the button callback and
+    // eventCallback will be called.
+    let messageSent = false;
+    function sendMessage(download) {
+      let mm = browser.messageManager;
+      mm.sendAsyncMessage('PDFJS:Child:fallbackDownload',
+                          { download: download });
+    }
+    let buttons = [{
+      label: data.label,
+      accessKey: data.accessKey,
+      callback: function() {
+        messageSent = true;
+        sendMessage(true);
+      }
+    }];
+    notificationBox.appendNotification(data.message, 'pdfjs-fallback', null,
+                                       notificationBox.PRIORITY_INFO_LOW,
+                                       buttons,
+                                       function eventsCallback(eventType) {
+      // Currently there is only one event "removed" but if there are any other
+      // added in the future we still only care about removed at the moment.
+      if (eventType !== 'removed') {
+        return;
+      }
+      // Don't send a response again if we already responded when the button was
+      // clicked.
+      if (messageSent) {
+        return;
+      }
+      sendMessage(false);
+    });
+  }
+};
+
+
diff --git a/application/basilisk/extensions/pdfjs/content/PdfjsContentUtils.jsm b/application/basilisk/extensions/pdfjs/content/PdfjsContentUtils.jsm
new file mode 100644
index 000000000..3dec5f389
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/PdfjsContentUtils.jsm
@@ -0,0 +1,150 @@
+/* Copyright 2012 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.
+ */
+/* jshint esnext:true */
+/* globals Components, Services, XPCOMUtils */
+
+'use strict';
+
+var EXPORTED_SYMBOLS = ['PdfjsContentUtils'];
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+
+Cu.import('resource://gre/modules/XPCOMUtils.jsm');
+Cu.import('resource://gre/modules/Services.jsm');
+
+var PdfjsContentUtils = {
+  _mm: null,
+
+  /*
+   * Public API
+   */
+
+  get isRemote() {
+    return (Services.appinfo.processType ===
+            Services.appinfo.PROCESS_TYPE_CONTENT);
+  },
+
+  init: function () {
+    // child *process* mm, or when loaded into the parent for in-content
+    // support the psuedo child process mm 'child PPMM'.
+    if (!this._mm) {
+      this._mm = Cc['@mozilla.org/childprocessmessagemanager;1'].
+        getService(Ci.nsISyncMessageSender);
+      this._mm.addMessageListener('PDFJS:Child:refreshSettings', this);
+      Services.obs.addObserver(this, 'quit-application', false);
+    }
+  },
+
+  uninit: function () {
+    if (this._mm) {
+      this._mm.removeMessageListener('PDFJS:Child:refreshSettings', this);
+      Services.obs.removeObserver(this, 'quit-application');
+    }
+    this._mm = null;
+  },
+
+  /*
+   * prefs utilities - the child does not have write access to prefs.
+   * note, the pref names here are cross-checked against a list of
+   * approved pdfjs prefs in chrome utils.
+   */
+
+  clearUserPref: function (aPrefName) {
+    this._mm.sendSyncMessage('PDFJS:Parent:clearUserPref', {
+      name: aPrefName
+    });
+  },
+
+  setIntPref: function (aPrefName, aPrefValue) {
+    this._mm.sendSyncMessage('PDFJS:Parent:setIntPref', {
+      name: aPrefName,
+      value: aPrefValue
+    });
+  },
+
+  setBoolPref: function (aPrefName, aPrefValue) {
+    this._mm.sendSyncMessage('PDFJS:Parent:setBoolPref', {
+      name: aPrefName,
+      value: aPrefValue
+    });
+  },
+
+  setCharPref: function (aPrefName, aPrefValue) {
+    this._mm.sendSyncMessage('PDFJS:Parent:setCharPref', {
+      name: aPrefName,
+      value: aPrefValue
+    });
+  },
+
+  setStringPref: function (aPrefName, aPrefValue) {
+    this._mm.sendSyncMessage('PDFJS:Parent:setStringPref', {
+      name: aPrefName,
+      value: aPrefValue
+    });
+  },
+
+  /*
+   * Forwards default app query to the parent where we check various
+   * handler app settings only available in the parent process.
+   */
+  isDefaultHandlerApp: function () {
+    return this._mm.sendSyncMessage('PDFJS:Parent:isDefaultHandlerApp')[0];
+  },
+
+  /*
+   * Request the display of a notification warning in the associated window
+   * when the renderer isn't sure a pdf displayed correctly.
+   */
+  displayWarning: function (aWindow, aMessage, aLabel, accessKey) {
+    // the child's dom frame mm associated with the window.
+    let winmm = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+                       .getInterface(Ci.nsIDocShell)
+                       .QueryInterface(Ci.nsIInterfaceRequestor)
+                       .getInterface(Ci.nsIContentFrameMessageManager);
+    winmm.sendAsyncMessage('PDFJS:Parent:displayWarning', {
+      message: aMessage,
+      label: aLabel,
+      accessKey: accessKey
+    });
+  },
+
+  /*
+   * Events
+   */
+
+  observe: function(aSubject, aTopic, aData) {
+    if (aTopic === 'quit-application') {
+      this.uninit();
+    }
+  },
+
+  receiveMessage: function (aMsg) {
+    switch (aMsg.name) {
+      case 'PDFJS:Child:refreshSettings':
+        // Only react to this if we are remote.
+        if (Services.appinfo.processType ===
+            Services.appinfo.PROCESS_TYPE_CONTENT) {
+          let jsm = 'resource://pdf.js/PdfJs.jsm';
+          let pdfjs = Components.utils.import(jsm, {}).PdfJs;
+          pdfjs.updateRegistration();
+        }
+        break;
+    }
+  }
+};
+
diff --git a/application/basilisk/extensions/pdfjs/content/build/pdf.js b/application/basilisk/extensions/pdfjs/content/build/pdf.js
new file mode 100644
index 000000000..98a3bd392
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/build/pdf.js
@@ -0,0 +1,8387 @@
+/* Copyright 2012 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 (root, factory) {
+  'use strict';
+  if (typeof define === 'function' && define.amd) {
+    define('pdfjs-dist/build/pdf', ['exports'], factory);
+  } else if (typeof exports !== 'undefined') {
+    factory(exports);
+  } else {
+    factory(root['pdfjsDistBuildPdf'] = {});
+  }
+}(this, function (exports) {
+  // Use strict in our context only - users might not want it
+  'use strict';
+  var pdfjsVersion = '1.6.315';
+  var pdfjsBuild = 'a139c75';
+  var pdfjsFilePath = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : null;
+  var pdfjsLibs = {};
+  (function pdfjsWrapper() {
+    (function (root, factory) {
+      factory(root.pdfjsSharedUtil = {});
+    }(this, function (exports) {
+      var globalScope = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this;
+      var FONT_IDENTITY_MATRIX = [
+        0.001,
+        0,
+        0,
+        0.001,
+        0,
+        0
+      ];
+      var TextRenderingMode = {
+        FILL: 0,
+        STROKE: 1,
+        FILL_STROKE: 2,
+        INVISIBLE: 3,
+        FILL_ADD_TO_PATH: 4,
+        STROKE_ADD_TO_PATH: 5,
+        FILL_STROKE_ADD_TO_PATH: 6,
+        ADD_TO_PATH: 7,
+        FILL_STROKE_MASK: 3,
+        ADD_TO_PATH_FLAG: 4
+      };
+      var ImageKind = {
+        GRAYSCALE_1BPP: 1,
+        RGB_24BPP: 2,
+        RGBA_32BPP: 3
+      };
+      var AnnotationType = {
+        TEXT: 1,
+        LINK: 2,
+        FREETEXT: 3,
+        LINE: 4,
+        SQUARE: 5,
+        CIRCLE: 6,
+        POLYGON: 7,
+        POLYLINE: 8,
+        HIGHLIGHT: 9,
+        UNDERLINE: 10,
+        SQUIGGLY: 11,
+        STRIKEOUT: 12,
+        STAMP: 13,
+        CARET: 14,
+        INK: 15,
+        POPUP: 16,
+        FILEATTACHMENT: 17,
+        SOUND: 18,
+        MOVIE: 19,
+        WIDGET: 20,
+        SCREEN: 21,
+        PRINTERMARK: 22,
+        TRAPNET: 23,
+        WATERMARK: 24,
+        THREED: 25,
+        REDACT: 26
+      };
+      var AnnotationFlag = {
+        INVISIBLE: 0x01,
+        HIDDEN: 0x02,
+        PRINT: 0x04,
+        NOZOOM: 0x08,
+        NOROTATE: 0x10,
+        NOVIEW: 0x20,
+        READONLY: 0x40,
+        LOCKED: 0x80,
+        TOGGLENOVIEW: 0x100,
+        LOCKEDCONTENTS: 0x200
+      };
+      var AnnotationFieldFlag = {
+        READONLY: 0x0000001,
+        REQUIRED: 0x0000002,
+        NOEXPORT: 0x0000004,
+        MULTILINE: 0x0001000,
+        PASSWORD: 0x0002000,
+        NOTOGGLETOOFF: 0x0004000,
+        RADIO: 0x0008000,
+        PUSHBUTTON: 0x0010000,
+        COMBO: 0x0020000,
+        EDIT: 0x0040000,
+        SORT: 0x0080000,
+        FILESELECT: 0x0100000,
+        MULTISELECT: 0x0200000,
+        DONOTSPELLCHECK: 0x0400000,
+        DONOTSCROLL: 0x0800000,
+        COMB: 0x1000000,
+        RICHTEXT: 0x2000000,
+        RADIOSINUNISON: 0x2000000,
+        COMMITONSELCHANGE: 0x4000000
+      };
+      var AnnotationBorderStyleType = {
+        SOLID: 1,
+        DASHED: 2,
+        BEVELED: 3,
+        INSET: 4,
+        UNDERLINE: 5
+      };
+      var StreamType = {
+        UNKNOWN: 0,
+        FLATE: 1,
+        LZW: 2,
+        DCT: 3,
+        JPX: 4,
+        JBIG: 5,
+        A85: 6,
+        AHX: 7,
+        CCF: 8,
+        RL: 9
+      };
+      var FontType = {
+        UNKNOWN: 0,
+        TYPE1: 1,
+        TYPE1C: 2,
+        CIDFONTTYPE0: 3,
+        CIDFONTTYPE0C: 4,
+        TRUETYPE: 5,
+        CIDFONTTYPE2: 6,
+        TYPE3: 7,
+        OPENTYPE: 8,
+        TYPE0: 9,
+        MMTYPE1: 10
+      };
+      var VERBOSITY_LEVELS = {
+        errors: 0,
+        warnings: 1,
+        infos: 5
+      };
+      // All the possible operations for an operator list.
+      var OPS = {
+        // Intentionally start from 1 so it is easy to spot bad operators that will be
+        // 0's.
+        dependency: 1,
+        setLineWidth: 2,
+        setLineCap: 3,
+        setLineJoin: 4,
+        setMiterLimit: 5,
+        setDash: 6,
+        setRenderingIntent: 7,
+        setFlatness: 8,
+        setGState: 9,
+        save: 10,
+        restore: 11,
+        transform: 12,
+        moveTo: 13,
+        lineTo: 14,
+        curveTo: 15,
+        curveTo2: 16,
+        curveTo3: 17,
+        closePath: 18,
+        rectangle: 19,
+        stroke: 20,
+        closeStroke: 21,
+        fill: 22,
+        eoFill: 23,
+        fillStroke: 24,
+        eoFillStroke: 25,
+        closeFillStroke: 26,
+        closeEOFillStroke: 27,
+        endPath: 28,
+        clip: 29,
+        eoClip: 30,
+        beginText: 31,
+        endText: 32,
+        setCharSpacing: 33,
+        setWordSpacing: 34,
+        setHScale: 35,
+        setLeading: 36,
+        setFont: 37,
+        setTextRenderingMode: 38,
+        setTextRise: 39,
+        moveText: 40,
+        setLeadingMoveText: 41,
+        setTextMatrix: 42,
+        nextLine: 43,
+        showText: 44,
+        showSpacedText: 45,
+        nextLineShowText: 46,
+        nextLineSetSpacingShowText: 47,
+        setCharWidth: 48,
+        setCharWidthAndBounds: 49,
+        setStrokeColorSpace: 50,
+        setFillColorSpace: 51,
+        setStrokeColor: 52,
+        setStrokeColorN: 53,
+        setFillColor: 54,
+        setFillColorN: 55,
+        setStrokeGray: 56,
+        setFillGray: 57,
+        setStrokeRGBColor: 58,
+        setFillRGBColor: 59,
+        setStrokeCMYKColor: 60,
+        setFillCMYKColor: 61,
+        shadingFill: 62,
+        beginInlineImage: 63,
+        beginImageData: 64,
+        endInlineImage: 65,
+        paintXObject: 66,
+        markPoint: 67,
+        markPointProps: 68,
+        beginMarkedContent: 69,
+        beginMarkedContentProps: 70,
+        endMarkedContent: 71,
+        beginCompat: 72,
+        endCompat: 73,
+        paintFormXObjectBegin: 74,
+        paintFormXObjectEnd: 75,
+        beginGroup: 76,
+        endGroup: 77,
+        beginAnnotations: 78,
+        endAnnotations: 79,
+        beginAnnotation: 80,
+        endAnnotation: 81,
+        paintJpegXObject: 82,
+        paintImageMaskXObject: 83,
+        paintImageMaskXObjectGroup: 84,
+        paintImageXObject: 85,
+        paintInlineImageXObject: 86,
+        paintInlineImageXObjectGroup: 87,
+        paintImageXObjectRepeat: 88,
+        paintImageMaskXObjectRepeat: 89,
+        paintSolidColorImageMask: 90,
+        constructPath: 91
+      };
+      var verbosity = VERBOSITY_LEVELS.warnings;
+      function setVerbosityLevel(level) {
+        verbosity = level;
+      }
+      function getVerbosityLevel() {
+        return verbosity;
+      }
+      // A notice for devs. These are good for things that are helpful to devs, such
+      // as warning that Workers were disabled, which is important to devs but not
+      // end users.
+      function info(msg) {
+        if (verbosity >= VERBOSITY_LEVELS.infos) {
+          console.log('Info: ' + msg);
+        }
+      }
+      // Non-fatal warnings.
+      function warn(msg) {
+        if (verbosity >= VERBOSITY_LEVELS.warnings) {
+          console.log('Warning: ' + msg);
+        }
+      }
+      // Deprecated API function -- display regardless of the PDFJS.verbosity setting.
+      function deprecated(details) {
+        console.log('Deprecated API usage: ' + details);
+      }
+      // Fatal errors that should trigger the fallback UI and halt execution by
+      // throwing an exception.
+      function error(msg) {
+        if (verbosity >= VERBOSITY_LEVELS.errors) {
+          console.log('Error: ' + msg);
+          console.log(backtrace());
+        }
+        throw new Error(msg);
+      }
+      function backtrace() {
+        try {
+          throw new Error();
+        } catch (e) {
+          return e.stack ? e.stack.split('\n').slice(2).join('\n') : '';
+        }
+      }
+      function assert(cond, msg) {
+        if (!cond) {
+          error(msg);
+        }
+      }
+      var UNSUPPORTED_FEATURES = {
+        unknown: 'unknown',
+        forms: 'forms',
+        javaScript: 'javaScript',
+        smask: 'smask',
+        shadingPattern: 'shadingPattern',
+        font: 'font'
+      };
+      // Checks if URLs have the same origin. For non-HTTP based URLs, returns false.
+      function isSameOrigin(baseUrl, otherUrl) {
+        try {
+          var base = new URL(baseUrl);
+          if (!base.origin || base.origin === 'null') {
+            return false;
+          }
+        } // non-HTTP url
+        catch (e) {
+          return false;
+        }
+        var other = new URL(otherUrl, base);
+        return base.origin === other.origin;
+      }
+      // Checks if URLs use one of the whitelisted protocols, e.g. to avoid XSS.
+      function isValidProtocol(url) {
+        if (!url) {
+          return false;
+        }
+        switch (url.protocol) {
+        case 'http:':
+        case 'https:':
+        case 'ftp:':
+        case 'mailto:':
+        case 'tel:':
+          return true;
+        default:
+          return false;
+        }
+      }
+      /**
+       * Attempts to create a valid absolute URL (utilizing `isValidProtocol`).
+       * @param {URL|string} url - An absolute, or relative, URL.
+       * @param {URL|string} baseUrl - An absolute URL.
+       * @returns Either a valid {URL}, or `null` otherwise.
+       */
+      function createValidAbsoluteUrl(url, baseUrl) {
+        if (!url) {
+          return null;
+        }
+        try {
+          var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
+          if (isValidProtocol(absoluteUrl)) {
+            return absoluteUrl;
+          }
+        } catch (ex) {
+        }
+        return null;
+      }
+      function shadow(obj, prop, value) {
+        Object.defineProperty(obj, prop, {
+          value: value,
+          enumerable: true,
+          configurable: true,
+          writable: false
+        });
+        return value;
+      }
+      function getLookupTableFactory(initializer) {
+        var lookup;
+        return function () {
+          if (initializer) {
+            lookup = Object.create(null);
+            initializer(lookup);
+            initializer = null;
+          }
+          return lookup;
+        };
+      }
+      var PasswordResponses = {
+        NEED_PASSWORD: 1,
+        INCORRECT_PASSWORD: 2
+      };
+      var PasswordException = function PasswordExceptionClosure() {
+        function PasswordException(msg, code) {
+          this.name = 'PasswordException';
+          this.message = msg;
+          this.code = code;
+        }
+        PasswordException.prototype = new Error();
+        PasswordException.constructor = PasswordException;
+        return PasswordException;
+      }();
+      var UnknownErrorException = function UnknownErrorExceptionClosure() {
+        function UnknownErrorException(msg, details) {
+          this.name = 'UnknownErrorException';
+          this.message = msg;
+          this.details = details;
+        }
+        UnknownErrorException.prototype = new Error();
+        UnknownErrorException.constructor = UnknownErrorException;
+        return UnknownErrorException;
+      }();
+      var InvalidPDFException = function InvalidPDFExceptionClosure() {
+        function InvalidPDFException(msg) {
+          this.name = 'InvalidPDFException';
+          this.message = msg;
+        }
+        InvalidPDFException.prototype = new Error();
+        InvalidPDFException.constructor = InvalidPDFException;
+        return InvalidPDFException;
+      }();
+      var MissingPDFException = function MissingPDFExceptionClosure() {
+        function MissingPDFException(msg) {
+          this.name = 'MissingPDFException';
+          this.message = msg;
+        }
+        MissingPDFException.prototype = new Error();
+        MissingPDFException.constructor = MissingPDFException;
+        return MissingPDFException;
+      }();
+      var UnexpectedResponseException = function UnexpectedResponseExceptionClosure() {
+        function UnexpectedResponseException(msg, status) {
+          this.name = 'UnexpectedResponseException';
+          this.message = msg;
+          this.status = status;
+        }
+        UnexpectedResponseException.prototype = new Error();
+        UnexpectedResponseException.constructor = UnexpectedResponseException;
+        return UnexpectedResponseException;
+      }();
+      var NotImplementedException = function NotImplementedExceptionClosure() {
+        function NotImplementedException(msg) {
+          this.message = msg;
+        }
+        NotImplementedException.prototype = new Error();
+        NotImplementedException.prototype.name = 'NotImplementedException';
+        NotImplementedException.constructor = NotImplementedException;
+        return NotImplementedException;
+      }();
+      var MissingDataException = function MissingDataExceptionClosure() {
+        function MissingDataException(begin, end) {
+          this.begin = begin;
+          this.end = end;
+          this.message = 'Missing data [' + begin + ', ' + end + ')';
+        }
+        MissingDataException.prototype = new Error();
+        MissingDataException.prototype.name = 'MissingDataException';
+        MissingDataException.constructor = MissingDataException;
+        return MissingDataException;
+      }();
+      var XRefParseException = function XRefParseExceptionClosure() {
+        function XRefParseException(msg) {
+          this.message = msg;
+        }
+        XRefParseException.prototype = new Error();
+        XRefParseException.prototype.name = 'XRefParseException';
+        XRefParseException.constructor = XRefParseException;
+        return XRefParseException;
+      }();
+      var NullCharactersRegExp = /\x00/g;
+      function removeNullCharacters(str) {
+        if (typeof str !== 'string') {
+          warn('The argument for removeNullCharacters must be a string.');
+          return str;
+        }
+        return str.replace(NullCharactersRegExp, '');
+      }
+      function bytesToString(bytes) {
+        assert(bytes !== null && typeof bytes === 'object' && bytes.length !== undefined, 'Invalid argument for bytesToString');
+        var length = bytes.length;
+        var MAX_ARGUMENT_COUNT = 8192;
+        if (length < MAX_ARGUMENT_COUNT) {
+          return String.fromCharCode.apply(null, bytes);
+        }
+        var strBuf = [];
+        for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
+          var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
+          var chunk = bytes.subarray(i, chunkEnd);
+          strBuf.push(String.fromCharCode.apply(null, chunk));
+        }
+        return strBuf.join('');
+      }
+      function stringToBytes(str) {
+        assert(typeof str === 'string', 'Invalid argument for stringToBytes');
+        var length = str.length;
+        var bytes = new Uint8Array(length);
+        for (var i = 0; i < length; ++i) {
+          bytes[i] = str.charCodeAt(i) & 0xFF;
+        }
+        return bytes;
+      }
+      /**
+       * Gets length of the array (Array, Uint8Array, or string) in bytes.
+       * @param {Array|Uint8Array|string} arr
+       * @returns {number}
+       */
+      function arrayByteLength(arr) {
+        if (arr.length !== undefined) {
+          return arr.length;
+        }
+        assert(arr.byteLength !== undefined);
+        return arr.byteLength;
+      }
+      /**
+       * Combines array items (arrays) into single Uint8Array object.
+       * @param {Array} arr - the array of the arrays (Array, Uint8Array, or string).
+       * @returns {Uint8Array}
+       */
+      function arraysToBytes(arr) {
+        // Shortcut: if first and only item is Uint8Array, return it.
+        if (arr.length === 1 && arr[0] instanceof Uint8Array) {
+          return arr[0];
+        }
+        var resultLength = 0;
+        var i, ii = arr.length;
+        var item, itemLength;
+        for (i = 0; i < ii; i++) {
+          item = arr[i];
+          itemLength = arrayByteLength(item);
+          resultLength += itemLength;
+        }
+        var pos = 0;
+        var data = new Uint8Array(resultLength);
+        for (i = 0; i < ii; i++) {
+          item = arr[i];
+          if (!(item instanceof Uint8Array)) {
+            if (typeof item === 'string') {
+              item = stringToBytes(item);
+            } else {
+              item = new Uint8Array(item);
+            }
+          }
+          itemLength = item.byteLength;
+          data.set(item, pos);
+          pos += itemLength;
+        }
+        return data;
+      }
+      function string32(value) {
+        return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
+      }
+      function log2(x) {
+        var n = 1, i = 0;
+        while (x > n) {
+          n <<= 1;
+          i++;
+        }
+        return i;
+      }
+      function readInt8(data, start) {
+        return data[start] << 24 >> 24;
+      }
+      function readUint16(data, offset) {
+        return data[offset] << 8 | data[offset + 1];
+      }
+      function readUint32(data, offset) {
+        return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+      }
+      // Lazy test the endianness of the platform
+      // NOTE: This will be 'true' for simulated TypedArrays
+      function isLittleEndian() {
+        var buffer8 = new Uint8Array(2);
+        buffer8[0] = 1;
+        var buffer16 = new Uint16Array(buffer8.buffer);
+        return buffer16[0] === 1;
+      }
+      // Checks if it's possible to eval JS expressions.
+      function isEvalSupported() {
+        try {
+          new Function('');
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      var IDENTITY_MATRIX = [
+        1,
+        0,
+        0,
+        1,
+        0,
+        0
+      ];
+      var Util = function UtilClosure() {
+        function Util() {
+        }
+        var rgbBuf = [
+          'rgb(',
+          0,
+          ',',
+          0,
+          ',',
+          0,
+          ')'
+        ];
+        // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids
+        // creating many intermediate strings.
+        Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
+          rgbBuf[1] = r;
+          rgbBuf[3] = g;
+          rgbBuf[5] = b;
+          return rgbBuf.join('');
+        };
+        // Concatenates two transformation matrices together and returns the result.
+        Util.transform = function Util_transform(m1, m2) {
+          return [
+            m1[0] * m2[0] + m1[2] * m2[1],
+            m1[1] * m2[0] + m1[3] * m2[1],
+            m1[0] * m2[2] + m1[2] * m2[3],
+            m1[1] * m2[2] + m1[3] * m2[3],
+            m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+            m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+          ];
+        };
+        // For 2d affine transforms
+        Util.applyTransform = function Util_applyTransform(p, m) {
+          var xt = p[0] * m[0] + p[1] * m[2] + m[4];
+          var yt = p[0] * m[1] + p[1] * m[3] + m[5];
+          return [
+            xt,
+            yt
+          ];
+        };
+        Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
+          var d = m[0] * m[3] - m[1] * m[2];
+          var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+          var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
+          return [
+            xt,
+            yt
+          ];
+        };
+        // Applies the transform to the rectangle and finds the minimum axially
+        // aligned bounding box.
+        Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) {
+          var p1 = Util.applyTransform(r, m);
+          var p2 = Util.applyTransform(r.slice(2, 4), m);
+          var p3 = Util.applyTransform([
+            r[0],
+            r[3]
+          ], m);
+          var p4 = Util.applyTransform([
+            r[2],
+            r[1]
+          ], m);
+          return [
+            Math.min(p1[0], p2[0], p3[0], p4[0]),
+            Math.min(p1[1], p2[1], p3[1], p4[1]),
+            Math.max(p1[0], p2[0], p3[0], p4[0]),
+            Math.max(p1[1], p2[1], p3[1], p4[1])
+          ];
+        };
+        Util.inverseTransform = function Util_inverseTransform(m) {
+          var d = m[0] * m[3] - m[1] * m[2];
+          return [
+            m[3] / d,
+            -m[1] / d,
+            -m[2] / d,
+            m[0] / d,
+            (m[2] * m[5] - m[4] * m[3]) / d,
+            (m[4] * m[1] - m[5] * m[0]) / d
+          ];
+        };
+        // Apply a generic 3d matrix M on a 3-vector v:
+        //   | a b c |   | X |
+        //   | d e f | x | Y |
+        //   | g h i |   | Z |
+        // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],
+        // with v as [X,Y,Z]
+        Util.apply3dTransform = function Util_apply3dTransform(m, v) {
+          return [
+            m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+            m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
+            m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
+          ];
+        };
+        // This calculation uses Singular Value Decomposition.
+        // The SVD can be represented with formula A = USV. We are interested in the
+        // matrix S here because it represents the scale values.
+        Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) {
+          var transpose = [
+            m[0],
+            m[2],
+            m[1],
+            m[3]
+          ];
+          // Multiply matrix m with its transpose.
+          var a = m[0] * transpose[0] + m[1] * transpose[2];
+          var b = m[0] * transpose[1] + m[1] * transpose[3];
+          var c = m[2] * transpose[0] + m[3] * transpose[2];
+          var d = m[2] * transpose[1] + m[3] * transpose[3];
+          // Solve the second degree polynomial to get roots.
+          var first = (a + d) / 2;
+          var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
+          var sx = first + second || 1;
+          var sy = first - second || 1;
+          // Scale values are the square roots of the eigenvalues.
+          return [
+            Math.sqrt(sx),
+            Math.sqrt(sy)
+          ];
+        };
+        // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
+        // For coordinate systems whose origin lies in the bottom-left, this
+        // means normalization to (BL,TR) ordering. For systems with origin in the
+        // top-left, this means (TL,BR) ordering.
+        Util.normalizeRect = function Util_normalizeRect(rect) {
+          var r = rect.slice(0);
+          // clone rect
+          if (rect[0] > rect[2]) {
+            r[0] = rect[2];
+            r[2] = rect[0];
+          }
+          if (rect[1] > rect[3]) {
+            r[1] = rect[3];
+            r[3] = rect[1];
+          }
+          return r;
+        };
+        // Returns a rectangle [x1, y1, x2, y2] corresponding to the
+        // intersection of rect1 and rect2. If no intersection, returns 'false'
+        // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]
+        Util.intersect = function Util_intersect(rect1, rect2) {
+          function compare(a, b) {
+            return a - b;
+          }
+          // Order points along the axes
+          var orderedX = [
+              rect1[0],
+              rect1[2],
+              rect2[0],
+              rect2[2]
+            ].sort(compare), orderedY = [
+              rect1[1],
+              rect1[3],
+              rect2[1],
+              rect2[3]
+            ].sort(compare), result = [];
+          rect1 = Util.normalizeRect(rect1);
+          rect2 = Util.normalizeRect(rect2);
+          // X: first and second points belong to different rectangles?
+          if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
+            // Intersection must be between second and third points
+            result[0] = orderedX[1];
+            result[2] = orderedX[2];
+          } else {
+            return false;
+          }
+          // Y: first and second points belong to different rectangles?
+          if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
+            // Intersection must be between second and third points
+            result[1] = orderedY[1];
+            result[3] = orderedY[2];
+          } else {
+            return false;
+          }
+          return result;
+        };
+        Util.sign = function Util_sign(num) {
+          return num < 0 ? -1 : 1;
+        };
+        var ROMAN_NUMBER_MAP = [
+          '',
+          'C',
+          'CC',
+          'CCC',
+          'CD',
+          'D',
+          'DC',
+          'DCC',
+          'DCCC',
+          'CM',
+          '',
+          'X',
+          'XX',
+          'XXX',
+          'XL',
+          'L',
+          'LX',
+          'LXX',
+          'LXXX',
+          'XC',
+          '',
+          'I',
+          'II',
+          'III',
+          'IV',
+          'V',
+          'VI',
+          'VII',
+          'VIII',
+          'IX'
+        ];
+        /**
+         * Converts positive integers to (upper case) Roman numerals.
+         * @param {integer} number - The number that should be converted.
+         * @param {boolean} lowerCase - Indicates if the result should be converted
+         *   to lower case letters. The default is false.
+         * @return {string} The resulting Roman number.
+         */
+        Util.toRoman = function Util_toRoman(number, lowerCase) {
+          assert(isInt(number) && number > 0, 'The number should be a positive integer.');
+          var pos, romanBuf = [];
+          // Thousands
+          while (number >= 1000) {
+            number -= 1000;
+            romanBuf.push('M');
+          }
+          // Hundreds
+          pos = number / 100 | 0;
+          number %= 100;
+          romanBuf.push(ROMAN_NUMBER_MAP[pos]);
+          // Tens
+          pos = number / 10 | 0;
+          number %= 10;
+          romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
+          // Ones
+          romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
+          var romanStr = romanBuf.join('');
+          return lowerCase ? romanStr.toLowerCase() : romanStr;
+        };
+        Util.appendToArray = function Util_appendToArray(arr1, arr2) {
+          Array.prototype.push.apply(arr1, arr2);
+        };
+        Util.prependToArray = function Util_prependToArray(arr1, arr2) {
+          Array.prototype.unshift.apply(arr1, arr2);
+        };
+        Util.extendObj = function extendObj(obj1, obj2) {
+          for (var key in obj2) {
+            obj1[key] = obj2[key];
+          }
+        };
+        Util.getInheritableProperty = function Util_getInheritableProperty(dict, name, getArray) {
+          while (dict && !dict.has(name)) {
+            dict = dict.get('Parent');
+          }
+          if (!dict) {
+            return null;
+          }
+          return getArray ? dict.getArray(name) : dict.get(name);
+        };
+        Util.inherit = function Util_inherit(sub, base, prototype) {
+          sub.prototype = Object.create(base.prototype);
+          sub.prototype.constructor = sub;
+          for (var prop in prototype) {
+            sub.prototype[prop] = prototype[prop];
+          }
+        };
+        Util.loadScript = function Util_loadScript(src, callback) {
+          var script = document.createElement('script');
+          var loaded = false;
+          script.setAttribute('src', src);
+          if (callback) {
+            script.onload = function () {
+              if (!loaded) {
+                callback();
+              }
+              loaded = true;
+            };
+          }
+          document.getElementsByTagName('head')[0].appendChild(script);
+        };
+        return Util;
+      }();
+      /**
+       * PDF page viewport created based on scale, rotation and offset.
+       * @class
+       * @alias PageViewport
+       */
+      var PageViewport = function PageViewportClosure() {
+        /**
+         * @constructor
+         * @private
+         * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates.
+         * @param scale {number} scale of the viewport.
+         * @param rotation {number} rotations of the viewport in degrees.
+         * @param offsetX {number} offset X
+         * @param offsetY {number} offset Y
+         * @param dontFlip {boolean} if true, axis Y will not be flipped.
+         */
+        function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {
+          this.viewBox = viewBox;
+          this.scale = scale;
+          this.rotation = rotation;
+          this.offsetX = offsetX;
+          this.offsetY = offsetY;
+          // creating transform to convert pdf coordinate system to the normal
+          // canvas like coordinates taking in account scale and rotation
+          var centerX = (viewBox[2] + viewBox[0]) / 2;
+          var centerY = (viewBox[3] + viewBox[1]) / 2;
+          var rotateA, rotateB, rotateC, rotateD;
+          rotation = rotation % 360;
+          rotation = rotation < 0 ? rotation + 360 : rotation;
+          switch (rotation) {
+          case 180:
+            rotateA = -1;
+            rotateB = 0;
+            rotateC = 0;
+            rotateD = 1;
+            break;
+          case 90:
+            rotateA = 0;
+            rotateB = 1;
+            rotateC = 1;
+            rotateD = 0;
+            break;
+          case 270:
+            rotateA = 0;
+            rotateB = -1;
+            rotateC = -1;
+            rotateD = 0;
+            break;
+          //case 0:
+          default:
+            rotateA = 1;
+            rotateB = 0;
+            rotateC = 0;
+            rotateD = -1;
+            break;
+          }
+          if (dontFlip) {
+            rotateC = -rotateC;
+            rotateD = -rotateD;
+          }
+          var offsetCanvasX, offsetCanvasY;
+          var width, height;
+          if (rotateA === 0) {
+            offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
+            offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
+            width = Math.abs(viewBox[3] - viewBox[1]) * scale;
+            height = Math.abs(viewBox[2] - viewBox[0]) * scale;
+          } else {
+            offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
+            offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
+            width = Math.abs(viewBox[2] - viewBox[0]) * scale;
+            height = Math.abs(viewBox[3] - viewBox[1]) * scale;
+          }
+          // creating transform for the following operations:
+          // translate(-centerX, -centerY), rotate and flip vertically,
+          // scale, and translate(offsetCanvasX, offsetCanvasY)
+          this.transform = [
+            rotateA * scale,
+            rotateB * scale,
+            rotateC * scale,
+            rotateD * scale,
+            offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,
+            offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY
+          ];
+          this.width = width;
+          this.height = height;
+          this.fontScale = scale;
+        }
+        PageViewport.prototype = /** @lends PageViewport.prototype */
+        {
+          /**
+           * Clones viewport with additional properties.
+           * @param args {Object} (optional) If specified, may contain the 'scale' or
+           * 'rotation' properties to override the corresponding properties in
+           * the cloned viewport.
+           * @returns {PageViewport} Cloned viewport.
+           */
+          clone: function PageViewPort_clone(args) {
+            args = args || {};
+            var scale = 'scale' in args ? args.scale : this.scale;
+            var rotation = 'rotation' in args ? args.rotation : this.rotation;
+            return new PageViewport(this.viewBox.slice(), scale, rotation, this.offsetX, this.offsetY, args.dontFlip);
+          },
+          /**
+           * Converts PDF point to the viewport coordinates. For examples, useful for
+           * converting PDF location into canvas pixel coordinates.
+           * @param x {number} X coordinate.
+           * @param y {number} Y coordinate.
+           * @returns {Object} Object that contains 'x' and 'y' properties of the
+           * point in the viewport coordinate space.
+           * @see {@link convertToPdfPoint}
+           * @see {@link convertToViewportRectangle}
+           */
+          convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {
+            return Util.applyTransform([
+              x,
+              y
+            ], this.transform);
+          },
+          /**
+           * Converts PDF rectangle to the viewport coordinates.
+           * @param rect {Array} xMin, yMin, xMax and yMax coordinates.
+           * @returns {Array} Contains corresponding coordinates of the rectangle
+           * in the viewport coordinate space.
+           * @see {@link convertToViewportPoint}
+           */
+          convertToViewportRectangle: function PageViewport_convertToViewportRectangle(rect) {
+            var tl = Util.applyTransform([
+              rect[0],
+              rect[1]
+            ], this.transform);
+            var br = Util.applyTransform([
+              rect[2],
+              rect[3]
+            ], this.transform);
+            return [
+              tl[0],
+              tl[1],
+              br[0],
+              br[1]
+            ];
+          },
+          /**
+           * Converts viewport coordinates to the PDF location. For examples, useful
+           * for converting canvas pixel location into PDF one.
+           * @param x {number} X coordinate.
+           * @param y {number} Y coordinate.
+           * @returns {Object} Object that contains 'x' and 'y' properties of the
+           * point in the PDF coordinate space.
+           * @see {@link convertToViewportPoint}
+           */
+          convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {
+            return Util.applyInverseTransform([
+              x,
+              y
+            ], this.transform);
+          }
+        };
+        return PageViewport;
+      }();
+      var PDFStringTranslateTable = [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0x2D8,
+        0x2C7,
+        0x2C6,
+        0x2D9,
+        0x2DD,
+        0x2DB,
+        0x2DA,
+        0x2DC,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0x2022,
+        0x2020,
+        0x2021,
+        0x2026,
+        0x2014,
+        0x2013,
+        0x192,
+        0x2044,
+        0x2039,
+        0x203A,
+        0x2212,
+        0x2030,
+        0x201E,
+        0x201C,
+        0x201D,
+        0x2018,
+        0x2019,
+        0x201A,
+        0x2122,
+        0xFB01,
+        0xFB02,
+        0x141,
+        0x152,
+        0x160,
+        0x178,
+        0x17D,
+        0x131,
+        0x142,
+        0x153,
+        0x161,
+        0x17E,
+        0,
+        0x20AC
+      ];
+      function stringToPDFString(str) {
+        var i, n = str.length, strBuf = [];
+        if (str[0] === '\xFE' && str[1] === '\xFF') {
+          // UTF16BE BOM
+          for (i = 2; i < n; i += 2) {
+            strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
+          }
+        } else {
+          for (i = 0; i < n; ++i) {
+            var code = PDFStringTranslateTable[str.charCodeAt(i)];
+            strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
+          }
+        }
+        return strBuf.join('');
+      }
+      function stringToUTF8String(str) {
+        return decodeURIComponent(escape(str));
+      }
+      function utf8StringToString(str) {
+        return unescape(encodeURIComponent(str));
+      }
+      function isEmptyObj(obj) {
+        for (var key in obj) {
+          return false;
+        }
+        return true;
+      }
+      function isBool(v) {
+        return typeof v === 'boolean';
+      }
+      function isInt(v) {
+        return typeof v === 'number' && (v | 0) === v;
+      }
+      function isNum(v) {
+        return typeof v === 'number';
+      }
+      function isString(v) {
+        return typeof v === 'string';
+      }
+      function isArray(v) {
+        return v instanceof Array;
+      }
+      function isArrayBuffer(v) {
+        return typeof v === 'object' && v !== null && v.byteLength !== undefined;
+      }
+      // Checks if ch is one of the following characters: SPACE, TAB, CR or LF.
+      function isSpace(ch) {
+        return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
+      }
+      /**
+       * Promise Capability object.
+       *
+       * @typedef {Object} PromiseCapability
+       * @property {Promise} promise - A promise object.
+       * @property {function} resolve - Fulfills the promise.
+       * @property {function} reject - Rejects the promise.
+       */
+      /**
+       * Creates a promise capability object.
+       * @alias createPromiseCapability
+       *
+       * @return {PromiseCapability} A capability object contains:
+       * - a Promise, resolve and reject methods.
+       */
+      function createPromiseCapability() {
+        var capability = {};
+        capability.promise = new Promise(function (resolve, reject) {
+          capability.resolve = resolve;
+          capability.reject = reject;
+        });
+        return capability;
+      }
+      /**
+       * Polyfill for Promises:
+       * The following promise implementation tries to generally implement the
+       * Promise/A+ spec. Some notable differences from other promise libraries are:
+       * - There currently isn't a separate deferred and promise object.
+       * - Unhandled rejections eventually show an error if they aren't handled.
+       *
+       * Based off of the work in:
+       * https://bugzilla.mozilla.org/show_bug.cgi?id=810490
+       */
+      (function PromiseClosure() {
+        if (globalScope.Promise) {
+          // Promises existing in the DOM/Worker, checking presence of all/resolve
+          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;
+        }
+        throw new Error('DOM Promise is not present');
+      }());
+      var StatTimer = function StatTimerClosure() {
+        function rpad(str, pad, length) {
+          while (str.length < length) {
+            str += pad;
+          }
+          return str;
+        }
+        function StatTimer() {
+          this.started = Object.create(null);
+          this.times = [];
+          this.enabled = true;
+        }
+        StatTimer.prototype = {
+          time: function StatTimer_time(name) {
+            if (!this.enabled) {
+              return;
+            }
+            if (name in this.started) {
+              warn('Timer is already running for ' + name);
+            }
+            this.started[name] = Date.now();
+          },
+          timeEnd: function StatTimer_timeEnd(name) {
+            if (!this.enabled) {
+              return;
+            }
+            if (!(name in this.started)) {
+              warn('Timer has not been started for ' + name);
+            }
+            this.times.push({
+              'name': name,
+              'start': this.started[name],
+              'end': Date.now()
+            });
+            // Remove timer from started so it can be called again.
+            delete this.started[name];
+          },
+          toString: function StatTimer_toString() {
+            var i, ii;
+            var times = this.times;
+            var out = '';
+            // Find the longest name for padding purposes.
+            var longest = 0;
+            for (i = 0, ii = times.length; i < ii; ++i) {
+              var name = times[i]['name'];
+              if (name.length > longest) {
+                longest = name.length;
+              }
+            }
+            for (i = 0, ii = times.length; i < ii; ++i) {
+              var span = times[i];
+              var duration = span.end - span.start;
+              out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n';
+            }
+            return out;
+          }
+        };
+        return StatTimer;
+      }();
+      var createBlob = function createBlob(data, contentType) {
+        if (typeof Blob !== 'undefined') {
+          return new Blob([data], { type: contentType });
+        }
+        warn('The "Blob" constructor is not supported.');
+      };
+      var createObjectURL = function createObjectURLClosure() {
+        // Blob/createObjectURL is not available, falling back to data schema.
+        var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        return function createObjectURL(data, contentType, forceDataSchema) {
+          if (!forceDataSchema && typeof URL !== 'undefined' && URL.createObjectURL) {
+            var blob = createBlob(data, contentType);
+            return URL.createObjectURL(blob);
+          }
+          var buffer = 'data:' + contentType + ';base64,';
+          for (var i = 0, ii = data.length; i < ii; i += 3) {
+            var b1 = data[i] & 0xFF;
+            var b2 = data[i + 1] & 0xFF;
+            var b3 = data[i + 2] & 0xFF;
+            var d1 = b1 >> 2, d2 = (b1 & 3) << 4 | b2 >> 4;
+            var d3 = i + 1 < ii ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
+            var d4 = i + 2 < ii ? b3 & 0x3F : 64;
+            buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
+          }
+          return buffer;
+        };
+      }();
+      function MessageHandler(sourceName, targetName, comObj) {
+        this.sourceName = sourceName;
+        this.targetName = targetName;
+        this.comObj = comObj;
+        this.callbackIndex = 1;
+        this.postMessageTransfers = true;
+        var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
+        var ah = this.actionHandler = Object.create(null);
+        this._onComObjOnMessage = function messageHandlerComObjOnMessage(event) {
+          var data = event.data;
+          if (data.targetName !== this.sourceName) {
+            return;
+          }
+          if (data.isReply) {
+            var callbackId = data.callbackId;
+            if (data.callbackId in callbacksCapabilities) {
+              var callback = callbacksCapabilities[callbackId];
+              delete callbacksCapabilities[callbackId];
+              if ('error' in data) {
+                callback.reject(data.error);
+              } else {
+                callback.resolve(data.data);
+              }
+            } else {
+              error('Cannot resolve callback ' + callbackId);
+            }
+          } else if (data.action in ah) {
+            var action = ah[data.action];
+            if (data.callbackId) {
+              var sourceName = this.sourceName;
+              var targetName = data.sourceName;
+              Promise.resolve().then(function () {
+                return action[0].call(action[1], data.data);
+              }).then(function (result) {
+                comObj.postMessage({
+                  sourceName: sourceName,
+                  targetName: targetName,
+                  isReply: true,
+                  callbackId: data.callbackId,
+                  data: result
+                });
+              }, function (reason) {
+                if (reason instanceof Error) {
+                  // Serialize error to avoid "DataCloneError"
+                  reason = reason + '';
+                }
+                comObj.postMessage({
+                  sourceName: sourceName,
+                  targetName: targetName,
+                  isReply: true,
+                  callbackId: data.callbackId,
+                  error: reason
+                });
+              });
+            } else {
+              action[0].call(action[1], data.data);
+            }
+          } else {
+            error('Unknown action from worker: ' + data.action);
+          }
+        }.bind(this);
+        comObj.addEventListener('message', this._onComObjOnMessage);
+      }
+      MessageHandler.prototype = {
+        on: function messageHandlerOn(actionName, handler, scope) {
+          var ah = this.actionHandler;
+          if (ah[actionName]) {
+            error('There is already an actionName called "' + actionName + '"');
+          }
+          ah[actionName] = [
+            handler,
+            scope
+          ];
+        },
+        /**
+         * Sends a message to the comObj to invoke the action with the supplied data.
+         * @param {String} actionName Action to call.
+         * @param {JSON} data JSON data to send.
+         * @param {Array} [transfers] Optional list of transfers/ArrayBuffers
+         */
+        send: function messageHandlerSend(actionName, data, transfers) {
+          var message = {
+            sourceName: this.sourceName,
+            targetName: this.targetName,
+            action: actionName,
+            data: data
+          };
+          this.postMessage(message, transfers);
+        },
+        /**
+         * Sends a message to the comObj to invoke the action with the supplied data.
+         * Expects that other side will callback with the response.
+         * @param {String} actionName Action to call.
+         * @param {JSON} data JSON data to send.
+         * @param {Array} [transfers] Optional list of transfers/ArrayBuffers.
+         * @returns {Promise} Promise to be resolved with response data.
+         */
+        sendWithPromise: function messageHandlerSendWithPromise(actionName, data, transfers) {
+          var callbackId = this.callbackIndex++;
+          var message = {
+            sourceName: this.sourceName,
+            targetName: this.targetName,
+            action: actionName,
+            data: data,
+            callbackId: callbackId
+          };
+          var capability = createPromiseCapability();
+          this.callbacksCapabilities[callbackId] = capability;
+          try {
+            this.postMessage(message, transfers);
+          } catch (e) {
+            capability.reject(e);
+          }
+          return capability.promise;
+        },
+        /**
+         * Sends raw message to the comObj.
+         * @private
+         * @param message {Object} Raw message.
+         * @param transfers List of transfers/ArrayBuffers, or undefined.
+         */
+        postMessage: function (message, transfers) {
+          if (transfers && this.postMessageTransfers) {
+            this.comObj.postMessage(message, transfers);
+          } else {
+            this.comObj.postMessage(message);
+          }
+        },
+        destroy: function () {
+          this.comObj.removeEventListener('message', this._onComObjOnMessage);
+        }
+      };
+      function loadJpegStream(id, imageUrl, objs) {
+        var img = new Image();
+        img.onload = function loadJpegStream_onloadClosure() {
+          objs.resolve(id, img);
+        };
+        img.onerror = function loadJpegStream_onerrorClosure() {
+          objs.resolve(id, null);
+          warn('Error during JPEG image loading');
+        };
+        img.src = imageUrl;
+      }
+      exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
+      exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
+      exports.OPS = OPS;
+      exports.VERBOSITY_LEVELS = VERBOSITY_LEVELS;
+      exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
+      exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
+      exports.AnnotationFieldFlag = AnnotationFieldFlag;
+      exports.AnnotationFlag = AnnotationFlag;
+      exports.AnnotationType = AnnotationType;
+      exports.FontType = FontType;
+      exports.ImageKind = ImageKind;
+      exports.InvalidPDFException = InvalidPDFException;
+      exports.MessageHandler = MessageHandler;
+      exports.MissingDataException = MissingDataException;
+      exports.MissingPDFException = MissingPDFException;
+      exports.NotImplementedException = NotImplementedException;
+      exports.PageViewport = PageViewport;
+      exports.PasswordException = PasswordException;
+      exports.PasswordResponses = PasswordResponses;
+      exports.StatTimer = StatTimer;
+      exports.StreamType = StreamType;
+      exports.TextRenderingMode = TextRenderingMode;
+      exports.UnexpectedResponseException = UnexpectedResponseException;
+      exports.UnknownErrorException = UnknownErrorException;
+      exports.Util = Util;
+      exports.XRefParseException = XRefParseException;
+      exports.arrayByteLength = arrayByteLength;
+      exports.arraysToBytes = arraysToBytes;
+      exports.assert = assert;
+      exports.bytesToString = bytesToString;
+      exports.createBlob = createBlob;
+      exports.createPromiseCapability = createPromiseCapability;
+      exports.createObjectURL = createObjectURL;
+      exports.deprecated = deprecated;
+      exports.error = error;
+      exports.getLookupTableFactory = getLookupTableFactory;
+      exports.getVerbosityLevel = getVerbosityLevel;
+      exports.globalScope = globalScope;
+      exports.info = info;
+      exports.isArray = isArray;
+      exports.isArrayBuffer = isArrayBuffer;
+      exports.isBool = isBool;
+      exports.isEmptyObj = isEmptyObj;
+      exports.isInt = isInt;
+      exports.isNum = isNum;
+      exports.isString = isString;
+      exports.isSpace = isSpace;
+      exports.isSameOrigin = isSameOrigin;
+      exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
+      exports.isLittleEndian = isLittleEndian;
+      exports.isEvalSupported = isEvalSupported;
+      exports.loadJpegStream = loadJpegStream;
+      exports.log2 = log2;
+      exports.readInt8 = readInt8;
+      exports.readUint16 = readUint16;
+      exports.readUint32 = readUint32;
+      exports.removeNullCharacters = removeNullCharacters;
+      exports.setVerbosityLevel = setVerbosityLevel;
+      exports.shadow = shadow;
+      exports.string32 = string32;
+      exports.stringToBytes = stringToBytes;
+      exports.stringToPDFString = stringToPDFString;
+      exports.stringToUTF8String = stringToUTF8String;
+      exports.utf8StringToString = utf8StringToString;
+      exports.warn = warn;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayDOMUtils = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var removeNullCharacters = sharedUtil.removeNullCharacters;
+      var warn = sharedUtil.warn;
+      var deprecated = sharedUtil.deprecated;
+      var createValidAbsoluteUrl = sharedUtil.createValidAbsoluteUrl;
+      /**
+       * Optimised CSS custom property getter/setter.
+       * @class
+       */
+      var CustomStyle = function CustomStyleClosure() {
+        // As noted on: http://www.zachstronaut.com/posts/2009/02/17/
+        //              animate-css-transforms-firefox-webkit.html
+        // in some versions of IE9 it is critical that ms appear in this list
+        // before Moz
+        var prefixes = [
+          'ms',
+          'Moz',
+          'Webkit',
+          'O'
+        ];
+        var _cache = Object.create(null);
+        function CustomStyle() {
+        }
+        CustomStyle.getProp = function get(propName, element) {
+          // check cache only when no element is given
+          if (arguments.length === 1 && typeof _cache[propName] === 'string') {
+            return _cache[propName];
+          }
+          element = element || document.documentElement;
+          var style = element.style, prefixed, uPropName;
+          // test standard property first
+          if (typeof style[propName] === 'string') {
+            return _cache[propName] = propName;
+          }
+          // capitalize
+          uPropName = propName.charAt(0).toUpperCase() + propName.slice(1);
+          // test vendor specific properties
+          for (var i = 0, l = prefixes.length; i < l; i++) {
+            prefixed = prefixes[i] + uPropName;
+            if (typeof style[prefixed] === 'string') {
+              return _cache[propName] = prefixed;
+            }
+          }
+          //if all fails then set to undefined
+          return _cache[propName] = 'undefined';
+        };
+        CustomStyle.setProp = function set(propName, element, str) {
+          var prop = this.getProp(propName);
+          if (prop !== 'undefined') {
+            element.style[prop] = str;
+          }
+        };
+        return CustomStyle;
+      }();
+      var hasCanvasTypedArrays;
+      hasCanvasTypedArrays = function () {
+        return true;
+      };
+      var LinkTarget = {
+        NONE: 0,
+        // Default value.
+        SELF: 1,
+        BLANK: 2,
+        PARENT: 3,
+        TOP: 4
+      };
+      var LinkTargetStringMap = [
+        '',
+        '_self',
+        '_blank',
+        '_parent',
+        '_top'
+      ];
+      /**
+       * @typedef ExternalLinkParameters
+       * @typedef {Object} ExternalLinkParameters
+       * @property {string} url - An absolute URL.
+       * @property {LinkTarget} target - The link target.
+       * @property {string} rel - The link relationship.
+       */
+      /**
+       * Adds various attributes (href, title, target, rel) to hyperlinks.
+       * @param {HTMLLinkElement} link - The link element.
+       * @param {ExternalLinkParameters} params
+       */
+      function addLinkAttributes(link, params) {
+        var url = params && params.url;
+        link.href = link.title = url ? removeNullCharacters(url) : '';
+        if (url) {
+          var target = params.target;
+          if (typeof target === 'undefined') {
+            target = getDefaultSetting('externalLinkTarget');
+          }
+          link.target = LinkTargetStringMap[target];
+          var rel = params.rel;
+          if (typeof rel === 'undefined') {
+            rel = getDefaultSetting('externalLinkRel');
+          }
+          link.rel = rel;
+        }
+      }
+      // Gets the file name from a given URL.
+      function getFilenameFromUrl(url) {
+        var anchor = url.indexOf('#');
+        var query = url.indexOf('?');
+        var end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
+        return url.substring(url.lastIndexOf('/', end) + 1, end);
+      }
+      function getDefaultSetting(id) {
+        // The list of the settings and their default is maintained for backward
+        // compatibility and shall not be extended or modified. See also global.js.
+        var globalSettings = sharedUtil.globalScope.PDFJS;
+        switch (id) {
+        case 'pdfBug':
+          return globalSettings ? globalSettings.pdfBug : false;
+        case 'disableAutoFetch':
+          return globalSettings ? globalSettings.disableAutoFetch : false;
+        case 'disableStream':
+          return globalSettings ? globalSettings.disableStream : false;
+        case 'disableRange':
+          return globalSettings ? globalSettings.disableRange : false;
+        case 'disableFontFace':
+          return globalSettings ? globalSettings.disableFontFace : false;
+        case 'disableCreateObjectURL':
+          return globalSettings ? globalSettings.disableCreateObjectURL : false;
+        case 'disableWebGL':
+          return globalSettings ? globalSettings.disableWebGL : true;
+        case 'cMapUrl':
+          return globalSettings ? globalSettings.cMapUrl : null;
+        case 'cMapPacked':
+          return globalSettings ? globalSettings.cMapPacked : false;
+        case 'postMessageTransfers':
+          return globalSettings ? globalSettings.postMessageTransfers : true;
+        case 'workerSrc':
+          return globalSettings ? globalSettings.workerSrc : null;
+        case 'disableWorker':
+          return globalSettings ? globalSettings.disableWorker : false;
+        case 'maxImageSize':
+          return globalSettings ? globalSettings.maxImageSize : -1;
+        case 'imageResourcesPath':
+          return globalSettings ? globalSettings.imageResourcesPath : '';
+        case 'isEvalSupported':
+          return globalSettings ? globalSettings.isEvalSupported : true;
+        case 'externalLinkTarget':
+          if (!globalSettings) {
+            return LinkTarget.NONE;
+          }
+          switch (globalSettings.externalLinkTarget) {
+          case LinkTarget.NONE:
+          case LinkTarget.SELF:
+          case LinkTarget.BLANK:
+          case LinkTarget.PARENT:
+          case LinkTarget.TOP:
+            return globalSettings.externalLinkTarget;
+          }
+          warn('PDFJS.externalLinkTarget is invalid: ' + globalSettings.externalLinkTarget);
+          // Reset the external link target, to suppress further warnings.
+          globalSettings.externalLinkTarget = LinkTarget.NONE;
+          return LinkTarget.NONE;
+        case 'externalLinkRel':
+          return globalSettings ? globalSettings.externalLinkRel : 'noreferrer';
+        case 'enableStats':
+          return !!(globalSettings && globalSettings.enableStats);
+        default:
+          throw new Error('Unknown default setting: ' + id);
+        }
+      }
+      function isExternalLinkTargetSet() {
+        var externalLinkTarget = getDefaultSetting('externalLinkTarget');
+        switch (externalLinkTarget) {
+        case LinkTarget.NONE:
+          return false;
+        case LinkTarget.SELF:
+        case LinkTarget.BLANK:
+        case LinkTarget.PARENT:
+        case LinkTarget.TOP:
+          return true;
+        }
+      }
+      function isValidUrl(url, allowRelative) {
+        deprecated('isValidUrl(), please use createValidAbsoluteUrl() instead.');
+        var baseUrl = allowRelative ? 'http://example.com' : null;
+        return createValidAbsoluteUrl(url, baseUrl) !== null;
+      }
+      exports.CustomStyle = CustomStyle;
+      exports.addLinkAttributes = addLinkAttributes;
+      exports.isExternalLinkTargetSet = isExternalLinkTargetSet;
+      exports.isValidUrl = isValidUrl;
+      exports.getFilenameFromUrl = getFilenameFromUrl;
+      exports.LinkTarget = LinkTarget;
+      exports.hasCanvasTypedArrays = hasCanvasTypedArrays;
+      exports.getDefaultSetting = getDefaultSetting;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayFontLoader = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var assert = sharedUtil.assert;
+      var bytesToString = sharedUtil.bytesToString;
+      var string32 = sharedUtil.string32;
+      var shadow = sharedUtil.shadow;
+      var warn = sharedUtil.warn;
+      function FontLoader(docId) {
+        this.docId = docId;
+        this.styleElement = null;
+      }
+      FontLoader.prototype = {
+        insertRule: function fontLoaderInsertRule(rule) {
+          var styleElement = this.styleElement;
+          if (!styleElement) {
+            styleElement = this.styleElement = document.createElement('style');
+            styleElement.id = 'PDFJS_FONT_STYLE_TAG_' + this.docId;
+            document.documentElement.getElementsByTagName('head')[0].appendChild(styleElement);
+          }
+          var styleSheet = styleElement.sheet;
+          styleSheet.insertRule(rule, styleSheet.cssRules.length);
+        },
+        clear: function fontLoaderClear() {
+          var styleElement = this.styleElement;
+          if (styleElement) {
+            styleElement.parentNode.removeChild(styleElement);
+            styleElement = this.styleElement = null;
+          }
+        }
+      };
+      FontLoader.prototype.bind = function fontLoaderBind(fonts, callback) {
+        for (var i = 0, ii = fonts.length; i < ii; i++) {
+          var font = fonts[i];
+          if (font.attached) {
+            continue;
+          }
+          font.attached = true;
+          var rule = font.createFontFaceRule();
+          if (rule) {
+            this.insertRule(rule);
+          }
+        }
+        setTimeout(callback);
+      };
+      var IsEvalSupportedCached = {
+        get value() {
+          return shadow(this, 'value', sharedUtil.isEvalSupported());
+        }
+      };
+      var FontFaceObject = function FontFaceObjectClosure() {
+        function FontFaceObject(translatedData, options) {
+          this.compiledGlyphs = Object.create(null);
+          // importing translated data
+          for (var i in translatedData) {
+            this[i] = translatedData[i];
+          }
+          this.options = options;
+        }
+        FontFaceObject.prototype = {
+          createNativeFontFace: function FontFaceObject_createNativeFontFace() {
+            throw new Error('Not implemented: createNativeFontFace');
+          },
+          createFontFaceRule: function FontFaceObject_createFontFaceRule() {
+            if (!this.data) {
+              return null;
+            }
+            if (this.options.disableFontFace) {
+              this.disableFontFace = true;
+              return null;
+            }
+            var data = bytesToString(new Uint8Array(this.data));
+            var fontName = this.loadedName;
+            // Add the font-face rule to the document
+            var url = 'url(data:' + this.mimetype + ';base64,' + btoa(data) + ');';
+            var rule = '@font-face { font-family:"' + fontName + '";src:' + url + '}';
+            if (this.options.fontRegistry) {
+              this.options.fontRegistry.registerFont(this, url);
+            }
+            return rule;
+          },
+          getPathGenerator: function FontFaceObject_getPathGenerator(objs, character) {
+            if (!(character in this.compiledGlyphs)) {
+              var cmds = objs.get(this.loadedName + '_path_' + character);
+              var current, i, len;
+              // If we can, compile cmds into JS for MAXIMUM SPEED
+              if (this.options.isEvalSupported && IsEvalSupportedCached.value) {
+                var args, js = '';
+                for (i = 0, len = cmds.length; i < len; i++) {
+                  current = cmds[i];
+                  if (current.args !== undefined) {
+                    args = current.args.join(',');
+                  } else {
+                    args = '';
+                  }
+                  js += 'c.' + current.cmd + '(' + args + ');\n';
+                }
+                this.compiledGlyphs[character] = new Function('c', 'size', js);
+              } else {
+                // But fall back on using Function.prototype.apply() if we're
+                // blocked from using eval() for whatever reason (like CSP policies)
+                this.compiledGlyphs[character] = function (c, size) {
+                  for (i = 0, len = cmds.length; i < len; i++) {
+                    current = cmds[i];
+                    if (current.cmd === 'scale') {
+                      current.args = [
+                        size,
+                        -size
+                      ];
+                    }
+                    c[current.cmd].apply(c, current.args);
+                  }
+                };
+              }
+            }
+            return this.compiledGlyphs[character];
+          }
+        };
+        return FontFaceObject;
+      }();
+      exports.FontFaceObject = FontFaceObject;
+      exports.FontLoader = FontLoader;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayMetadata = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var error = sharedUtil.error;
+      function fixMetadata(meta) {
+        return meta.replace(/>\\376\\377([^<]+)/g, function (all, codes) {
+          var bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
+            return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
+          });
+          var chars = '';
+          for (var i = 0; i < bytes.length; i += 2) {
+            var code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
+            chars += code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38 && false ? String.fromCharCode(code) : '&#x' + (0x10000 + code).toString(16).substring(1) + ';';
+          }
+          return '>' + chars;
+        });
+      }
+      function Metadata(meta) {
+        if (typeof meta === 'string') {
+          // Ghostscript produces invalid metadata
+          meta = fixMetadata(meta);
+          var parser = new DOMParser();
+          meta = parser.parseFromString(meta, 'application/xml');
+        } else if (!(meta instanceof Document)) {
+          error('Metadata: Invalid metadata object');
+        }
+        this.metaDocument = meta;
+        this.metadata = Object.create(null);
+        this.parse();
+      }
+      Metadata.prototype = {
+        parse: function Metadata_parse() {
+          var doc = this.metaDocument;
+          var rdf = doc.documentElement;
+          if (rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
+            // Wrapped in <xmpmeta>
+            rdf = rdf.firstChild;
+            while (rdf && rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
+              rdf = rdf.nextSibling;
+            }
+          }
+          var nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
+          if (!rdf || nodeName !== 'rdf:rdf' || !rdf.hasChildNodes()) {
+            return;
+          }
+          var children = rdf.childNodes, desc, entry, name, i, ii, length, iLength;
+          for (i = 0, length = children.length; i < length; i++) {
+            desc = children[i];
+            if (desc.nodeName.toLowerCase() !== 'rdf:description') {
+              continue;
+            }
+            for (ii = 0, iLength = desc.childNodes.length; ii < iLength; ii++) {
+              if (desc.childNodes[ii].nodeName.toLowerCase() !== '#text') {
+                entry = desc.childNodes[ii];
+                name = entry.nodeName.toLowerCase();
+                this.metadata[name] = entry.textContent.trim();
+              }
+            }
+          }
+        },
+        get: function Metadata_get(name) {
+          return this.metadata[name] || null;
+        },
+        has: function Metadata_has(name) {
+          return typeof this.metadata[name] !== 'undefined';
+        }
+      };
+      exports.Metadata = Metadata;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplaySVG = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayAnnotationLayer = {}, root.pdfjsSharedUtil, root.pdfjsDisplayDOMUtils);
+    }(this, function (exports, sharedUtil, displayDOMUtils) {
+      var AnnotationBorderStyleType = sharedUtil.AnnotationBorderStyleType;
+      var AnnotationType = sharedUtil.AnnotationType;
+      var Util = sharedUtil.Util;
+      var addLinkAttributes = displayDOMUtils.addLinkAttributes;
+      var LinkTarget = displayDOMUtils.LinkTarget;
+      var getFilenameFromUrl = displayDOMUtils.getFilenameFromUrl;
+      var warn = sharedUtil.warn;
+      var CustomStyle = displayDOMUtils.CustomStyle;
+      var getDefaultSetting = displayDOMUtils.getDefaultSetting;
+      /**
+       * @typedef {Object} AnnotationElementParameters
+       * @property {Object} data
+       * @property {HTMLDivElement} layer
+       * @property {PDFPage} page
+       * @property {PageViewport} viewport
+       * @property {IPDFLinkService} linkService
+       * @property {DownloadManager} downloadManager
+       * @property {string} imageResourcesPath
+       * @property {boolean} renderInteractiveForms
+       */
+      /**
+       * @class
+       * @alias AnnotationElementFactory
+       */
+      function AnnotationElementFactory() {
+      }
+      AnnotationElementFactory.prototype = /** @lends AnnotationElementFactory.prototype */
+      {
+        /**
+         * @param {AnnotationElementParameters} parameters
+         * @returns {AnnotationElement}
+         */
+        create: function AnnotationElementFactory_create(parameters) {
+          var subtype = parameters.data.annotationType;
+          switch (subtype) {
+          case AnnotationType.LINK:
+            return new LinkAnnotationElement(parameters);
+          case AnnotationType.TEXT:
+            return new TextAnnotationElement(parameters);
+          case AnnotationType.WIDGET:
+            var fieldType = parameters.data.fieldType;
+            switch (fieldType) {
+            case 'Tx':
+              return new TextWidgetAnnotationElement(parameters);
+            case 'Ch':
+              return new ChoiceWidgetAnnotationElement(parameters);
+            }
+            return new WidgetAnnotationElement(parameters);
+          case AnnotationType.POPUP:
+            return new PopupAnnotationElement(parameters);
+          case AnnotationType.HIGHLIGHT:
+            return new HighlightAnnotationElement(parameters);
+          case AnnotationType.UNDERLINE:
+            return new UnderlineAnnotationElement(parameters);
+          case AnnotationType.SQUIGGLY:
+            return new SquigglyAnnotationElement(parameters);
+          case AnnotationType.STRIKEOUT:
+            return new StrikeOutAnnotationElement(parameters);
+          case AnnotationType.FILEATTACHMENT:
+            return new FileAttachmentAnnotationElement(parameters);
+          default:
+            return new AnnotationElement(parameters);
+          }
+        }
+      };
+      /**
+       * @class
+       * @alias AnnotationElement
+       */
+      var AnnotationElement = function AnnotationElementClosure() {
+        function AnnotationElement(parameters, isRenderable) {
+          this.isRenderable = isRenderable || false;
+          this.data = parameters.data;
+          this.layer = parameters.layer;
+          this.page = parameters.page;
+          this.viewport = parameters.viewport;
+          this.linkService = parameters.linkService;
+          this.downloadManager = parameters.downloadManager;
+          this.imageResourcesPath = parameters.imageResourcesPath;
+          this.renderInteractiveForms = parameters.renderInteractiveForms;
+          if (isRenderable) {
+            this.container = this._createContainer();
+          }
+        }
+        AnnotationElement.prototype = /** @lends AnnotationElement.prototype */
+        {
+          /**
+           * Create an empty container for the annotation's HTML element.
+           *
+           * @private
+           * @memberof AnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          _createContainer: function AnnotationElement_createContainer() {
+            var data = this.data, page = this.page, viewport = this.viewport;
+            var container = document.createElement('section');
+            var width = data.rect[2] - data.rect[0];
+            var height = data.rect[3] - data.rect[1];
+            container.setAttribute('data-annotation-id', data.id);
+            // Do *not* modify `data.rect`, since that will corrupt the annotation
+            // position on subsequent calls to `_createContainer` (see issue 6804).
+            var rect = Util.normalizeRect([
+              data.rect[0],
+              page.view[3] - data.rect[1] + page.view[1],
+              data.rect[2],
+              page.view[3] - data.rect[3] + page.view[1]
+            ]);
+            CustomStyle.setProp('transform', container, 'matrix(' + viewport.transform.join(',') + ')');
+            CustomStyle.setProp('transformOrigin', container, -rect[0] + 'px ' + -rect[1] + 'px');
+            if (data.borderStyle.width > 0) {
+              container.style.borderWidth = data.borderStyle.width + 'px';
+              if (data.borderStyle.style !== AnnotationBorderStyleType.UNDERLINE) {
+                // Underline styles only have a bottom border, so we do not need
+                // to adjust for all borders. This yields a similar result as
+                // Adobe Acrobat/Reader.
+                width = width - 2 * data.borderStyle.width;
+                height = height - 2 * data.borderStyle.width;
+              }
+              var horizontalRadius = data.borderStyle.horizontalCornerRadius;
+              var verticalRadius = data.borderStyle.verticalCornerRadius;
+              if (horizontalRadius > 0 || verticalRadius > 0) {
+                var radius = horizontalRadius + 'px / ' + verticalRadius + 'px';
+                CustomStyle.setProp('borderRadius', container, radius);
+              }
+              switch (data.borderStyle.style) {
+              case AnnotationBorderStyleType.SOLID:
+                container.style.borderStyle = 'solid';
+                break;
+              case AnnotationBorderStyleType.DASHED:
+                container.style.borderStyle = 'dashed';
+                break;
+              case AnnotationBorderStyleType.BEVELED:
+                warn('Unimplemented border style: beveled');
+                break;
+              case AnnotationBorderStyleType.INSET:
+                warn('Unimplemented border style: inset');
+                break;
+              case AnnotationBorderStyleType.UNDERLINE:
+                container.style.borderBottomStyle = 'solid';
+                break;
+              default:
+                break;
+              }
+              if (data.color) {
+                container.style.borderColor = Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
+              } else {
+                // Transparent (invisible) border, so do not draw it at all.
+                container.style.borderWidth = 0;
+              }
+            }
+            container.style.left = rect[0] + 'px';
+            container.style.top = rect[1] + 'px';
+            container.style.width = width + 'px';
+            container.style.height = height + 'px';
+            return container;
+          },
+          /**
+           * Create a popup for the annotation's HTML element. This is used for
+           * annotations that do not have a Popup entry in the dictionary, but
+           * are of a type that works with popups (such as Highlight annotations).
+           *
+           * @private
+           * @param {HTMLSectionElement} container
+           * @param {HTMLDivElement|HTMLImageElement|null} trigger
+           * @param {Object} data
+           * @memberof AnnotationElement
+           */
+          _createPopup: function AnnotationElement_createPopup(container, trigger, data) {
+            // If no trigger element is specified, create it.
+            if (!trigger) {
+              trigger = document.createElement('div');
+              trigger.style.height = container.style.height;
+              trigger.style.width = container.style.width;
+              container.appendChild(trigger);
+            }
+            var popupElement = new PopupElement({
+              container: container,
+              trigger: trigger,
+              color: data.color,
+              title: data.title,
+              contents: data.contents,
+              hideWrapper: true
+            });
+            var popup = popupElement.render();
+            // Position the popup next to the annotation's container.
+            popup.style.left = container.style.width;
+            container.appendChild(popup);
+          },
+          /**
+           * Render the annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof AnnotationElement
+           */
+          render: function AnnotationElement_render() {
+            throw new Error('Abstract method AnnotationElement.render called');
+          }
+        };
+        return AnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias LinkAnnotationElement
+       */
+      var LinkAnnotationElement = function LinkAnnotationElementClosure() {
+        function LinkAnnotationElement(parameters) {
+          AnnotationElement.call(this, parameters, true);
+        }
+        Util.inherit(LinkAnnotationElement, AnnotationElement, {
+          /**
+           * Render the link annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof LinkAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function LinkAnnotationElement_render() {
+            this.container.className = 'linkAnnotation';
+            var link = document.createElement('a');
+            addLinkAttributes(link, {
+              url: this.data.url,
+              target: this.data.newWindow ? LinkTarget.BLANK : undefined
+            });
+            if (!this.data.url) {
+              if (this.data.action) {
+                this._bindNamedAction(link, this.data.action);
+              } else {
+                this._bindLink(link, this.data.dest);
+              }
+            }
+            this.container.appendChild(link);
+            return this.container;
+          },
+          /**
+           * Bind internal links to the link element.
+           *
+           * @private
+           * @param {Object} link
+           * @param {Object} destination
+           * @memberof LinkAnnotationElement
+           */
+          _bindLink: function LinkAnnotationElement_bindLink(link, destination) {
+            var self = this;
+            link.href = this.linkService.getDestinationHash(destination);
+            link.onclick = function () {
+              if (destination) {
+                self.linkService.navigateTo(destination);
+              }
+              return false;
+            };
+            if (destination) {
+              link.className = 'internalLink';
+            }
+          },
+          /**
+           * Bind named actions to the link element.
+           *
+           * @private
+           * @param {Object} link
+           * @param {Object} action
+           * @memberof LinkAnnotationElement
+           */
+          _bindNamedAction: function LinkAnnotationElement_bindNamedAction(link, action) {
+            var self = this;
+            link.href = this.linkService.getAnchorUrl('');
+            link.onclick = function () {
+              self.linkService.executeNamedAction(action);
+              return false;
+            };
+            link.className = 'internalLink';
+          }
+        });
+        return LinkAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias TextAnnotationElement
+       */
+      var TextAnnotationElement = function TextAnnotationElementClosure() {
+        function TextAnnotationElement(parameters) {
+          var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(TextAnnotationElement, AnnotationElement, {
+          /**
+           * Render the text annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof TextAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function TextAnnotationElement_render() {
+            this.container.className = 'textAnnotation';
+            var image = document.createElement('img');
+            image.style.height = this.container.style.height;
+            image.style.width = this.container.style.width;
+            image.src = this.imageResourcesPath + 'annotation-' + this.data.name.toLowerCase() + '.svg';
+            image.alt = '[{{type}} Annotation]';
+            image.dataset.l10nId = 'text_annotation_type';
+            image.dataset.l10nArgs = JSON.stringify({ type: this.data.name });
+            if (!this.data.hasPopup) {
+              this._createPopup(this.container, image, this.data);
+            }
+            this.container.appendChild(image);
+            return this.container;
+          }
+        });
+        return TextAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias WidgetAnnotationElement
+       */
+      var WidgetAnnotationElement = function WidgetAnnotationElementClosure() {
+        function WidgetAnnotationElement(parameters, isRenderable) {
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(WidgetAnnotationElement, AnnotationElement, {
+          /**
+           * Render the widget annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof WidgetAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function WidgetAnnotationElement_render() {
+            // Show only the container for unsupported field types.
+            return this.container;
+          }
+        });
+        return WidgetAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias TextWidgetAnnotationElement
+       */
+      var TextWidgetAnnotationElement = function TextWidgetAnnotationElementClosure() {
+        var TEXT_ALIGNMENT = [
+          'left',
+          'center',
+          'right'
+        ];
+        function TextWidgetAnnotationElement(parameters) {
+          var isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
+          WidgetAnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(TextWidgetAnnotationElement, WidgetAnnotationElement, {
+          /**
+           * Render the text widget annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof TextWidgetAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function TextWidgetAnnotationElement_render() {
+            this.container.className = 'textWidgetAnnotation';
+            var element = null;
+            if (this.renderInteractiveForms) {
+              // NOTE: We cannot set the values using `element.value` below, since it
+              //       prevents the AnnotationLayer rasterizer in `test/driver.js`
+              //       from parsing the elements correctly for the reference tests.
+              if (this.data.multiLine) {
+                element = document.createElement('textarea');
+                element.textContent = this.data.fieldValue;
+              } else {
+                element = document.createElement('input');
+                element.type = 'text';
+                element.setAttribute('value', this.data.fieldValue);
+              }
+              element.disabled = this.data.readOnly;
+              if (this.data.maxLen !== null) {
+                element.maxLength = this.data.maxLen;
+              }
+              if (this.data.comb) {
+                var fieldWidth = this.data.rect[2] - this.data.rect[0];
+                var combWidth = fieldWidth / this.data.maxLen;
+                element.classList.add('comb');
+                element.style.letterSpacing = 'calc(' + combWidth + 'px - 1ch)';
+              }
+            } else {
+              element = document.createElement('div');
+              element.textContent = this.data.fieldValue;
+              element.style.verticalAlign = 'middle';
+              element.style.display = 'table-cell';
+              var font = null;
+              if (this.data.fontRefName) {
+                font = this.page.commonObjs.getData(this.data.fontRefName);
+              }
+              this._setTextStyle(element, font);
+            }
+            if (this.data.textAlignment !== null) {
+              element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
+            }
+            this.container.appendChild(element);
+            return this.container;
+          },
+          /**
+           * Apply text styles to the text in the element.
+           *
+           * @private
+           * @param {HTMLDivElement} element
+           * @param {Object} font
+           * @memberof TextWidgetAnnotationElement
+           */
+          _setTextStyle: function TextWidgetAnnotationElement_setTextStyle(element, font) {
+            // TODO: This duplicates some of the logic in CanvasGraphics.setFont().
+            var style = element.style;
+            style.fontSize = this.data.fontSize + 'px';
+            style.direction = this.data.fontDirection < 0 ? 'rtl' : 'ltr';
+            if (!font) {
+              return;
+            }
+            style.fontWeight = font.black ? font.bold ? '900' : 'bold' : font.bold ? 'bold' : 'normal';
+            style.fontStyle = font.italic ? 'italic' : 'normal';
+            // Use a reasonable default font if the font doesn't specify a fallback.
+            var fontFamily = font.loadedName ? '"' + font.loadedName + '", ' : '';
+            var fallbackName = font.fallbackName || 'Helvetica, sans-serif';
+            style.fontFamily = fontFamily + fallbackName;
+          }
+        });
+        return TextWidgetAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias ChoiceWidgetAnnotationElement
+       */
+      var ChoiceWidgetAnnotationElement = function ChoiceWidgetAnnotationElementClosure() {
+        function ChoiceWidgetAnnotationElement(parameters) {
+          WidgetAnnotationElement.call(this, parameters, parameters.renderInteractiveForms);
+        }
+        Util.inherit(ChoiceWidgetAnnotationElement, WidgetAnnotationElement, {
+          /**
+           * Render the choice widget annotation's HTML element in the empty
+           * container.
+           *
+           * @public
+           * @memberof ChoiceWidgetAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function ChoiceWidgetAnnotationElement_render() {
+            this.container.className = 'choiceWidgetAnnotation';
+            var selectElement = document.createElement('select');
+            selectElement.disabled = this.data.readOnly;
+            if (!this.data.combo) {
+              // List boxes have a size and (optionally) multiple selection.
+              selectElement.size = this.data.options.length;
+              if (this.data.multiSelect) {
+                selectElement.multiple = true;
+              }
+            }
+            // Insert the options into the choice field.
+            for (var i = 0, ii = this.data.options.length; i < ii; i++) {
+              var option = this.data.options[i];
+              var optionElement = document.createElement('option');
+              optionElement.textContent = option.displayValue;
+              optionElement.value = option.exportValue;
+              if (this.data.fieldValue.indexOf(option.displayValue) >= 0) {
+                optionElement.setAttribute('selected', true);
+              }
+              selectElement.appendChild(optionElement);
+            }
+            this.container.appendChild(selectElement);
+            return this.container;
+          }
+        });
+        return ChoiceWidgetAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias PopupAnnotationElement
+       */
+      var PopupAnnotationElement = function PopupAnnotationElementClosure() {
+        function PopupAnnotationElement(parameters) {
+          var isRenderable = !!(parameters.data.title || parameters.data.contents);
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(PopupAnnotationElement, AnnotationElement, {
+          /**
+           * Render the popup annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof PopupAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function PopupAnnotationElement_render() {
+            this.container.className = 'popupAnnotation';
+            var selector = '[data-annotation-id="' + this.data.parentId + '"]';
+            var parentElement = this.layer.querySelector(selector);
+            if (!parentElement) {
+              return this.container;
+            }
+            var popup = new PopupElement({
+              container: this.container,
+              trigger: parentElement,
+              color: this.data.color,
+              title: this.data.title,
+              contents: this.data.contents
+            });
+            // Position the popup next to the parent annotation's container.
+            // PDF viewers ignore a popup annotation's rectangle.
+            var parentLeft = parseFloat(parentElement.style.left);
+            var parentWidth = parseFloat(parentElement.style.width);
+            CustomStyle.setProp('transformOrigin', this.container, -(parentLeft + parentWidth) + 'px -' + parentElement.style.top);
+            this.container.style.left = parentLeft + parentWidth + 'px';
+            this.container.appendChild(popup.render());
+            return this.container;
+          }
+        });
+        return PopupAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias PopupElement
+       */
+      var PopupElement = function PopupElementClosure() {
+        var BACKGROUND_ENLIGHT = 0.7;
+        function PopupElement(parameters) {
+          this.container = parameters.container;
+          this.trigger = parameters.trigger;
+          this.color = parameters.color;
+          this.title = parameters.title;
+          this.contents = parameters.contents;
+          this.hideWrapper = parameters.hideWrapper || false;
+          this.pinned = false;
+        }
+        PopupElement.prototype = /** @lends PopupElement.prototype */
+        {
+          /**
+           * Render the popup's HTML element.
+           *
+           * @public
+           * @memberof PopupElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function PopupElement_render() {
+            var wrapper = document.createElement('div');
+            wrapper.className = 'popupWrapper';
+            // For Popup annotations we hide the entire section because it contains
+            // only the popup. However, for Text annotations without a separate Popup
+            // annotation, we cannot hide the entire container as the image would
+            // disappear too. In that special case, hiding the wrapper suffices.
+            this.hideElement = this.hideWrapper ? wrapper : this.container;
+            this.hideElement.setAttribute('hidden', true);
+            var popup = document.createElement('div');
+            popup.className = 'popup';
+            var color = this.color;
+            if (color) {
+              // Enlighten the color.
+              var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
+              var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
+              var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
+              popup.style.backgroundColor = Util.makeCssRgb(r | 0, g | 0, b | 0);
+            }
+            var contents = this._formatContents(this.contents);
+            var title = document.createElement('h1');
+            title.textContent = this.title;
+            // Attach the event listeners to the trigger element.
+            this.trigger.addEventListener('click', this._toggle.bind(this));
+            this.trigger.addEventListener('mouseover', this._show.bind(this, false));
+            this.trigger.addEventListener('mouseout', this._hide.bind(this, false));
+            popup.addEventListener('click', this._hide.bind(this, true));
+            popup.appendChild(title);
+            popup.appendChild(contents);
+            wrapper.appendChild(popup);
+            return wrapper;
+          },
+          /**
+           * Format the contents of the popup by adding newlines where necessary.
+           *
+           * @private
+           * @param {string} contents
+           * @memberof PopupElement
+           * @returns {HTMLParagraphElement}
+           */
+          _formatContents: function PopupElement_formatContents(contents) {
+            var p = document.createElement('p');
+            var lines = contents.split(/(?:\r\n?|\n)/);
+            for (var i = 0, ii = lines.length; i < ii; ++i) {
+              var line = lines[i];
+              p.appendChild(document.createTextNode(line));
+              if (i < ii - 1) {
+                p.appendChild(document.createElement('br'));
+              }
+            }
+            return p;
+          },
+          /**
+           * Toggle the visibility of the popup.
+           *
+           * @private
+           * @memberof PopupElement
+           */
+          _toggle: function PopupElement_toggle() {
+            if (this.pinned) {
+              this._hide(true);
+            } else {
+              this._show(true);
+            }
+          },
+          /**
+           * Show the popup.
+           *
+           * @private
+           * @param {boolean} pin
+           * @memberof PopupElement
+           */
+          _show: function PopupElement_show(pin) {
+            if (pin) {
+              this.pinned = true;
+            }
+            if (this.hideElement.hasAttribute('hidden')) {
+              this.hideElement.removeAttribute('hidden');
+              this.container.style.zIndex += 1;
+            }
+          },
+          /**
+           * Hide the popup.
+           *
+           * @private
+           * @param {boolean} unpin
+           * @memberof PopupElement
+           */
+          _hide: function PopupElement_hide(unpin) {
+            if (unpin) {
+              this.pinned = false;
+            }
+            if (!this.hideElement.hasAttribute('hidden') && !this.pinned) {
+              this.hideElement.setAttribute('hidden', true);
+              this.container.style.zIndex -= 1;
+            }
+          }
+        };
+        return PopupElement;
+      }();
+      /**
+       * @class
+       * @alias HighlightAnnotationElement
+       */
+      var HighlightAnnotationElement = function HighlightAnnotationElementClosure() {
+        function HighlightAnnotationElement(parameters) {
+          var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(HighlightAnnotationElement, AnnotationElement, {
+          /**
+           * Render the highlight annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof HighlightAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function HighlightAnnotationElement_render() {
+            this.container.className = 'highlightAnnotation';
+            if (!this.data.hasPopup) {
+              this._createPopup(this.container, null, this.data);
+            }
+            return this.container;
+          }
+        });
+        return HighlightAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias UnderlineAnnotationElement
+       */
+      var UnderlineAnnotationElement = function UnderlineAnnotationElementClosure() {
+        function UnderlineAnnotationElement(parameters) {
+          var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(UnderlineAnnotationElement, AnnotationElement, {
+          /**
+           * Render the underline annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof UnderlineAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function UnderlineAnnotationElement_render() {
+            this.container.className = 'underlineAnnotation';
+            if (!this.data.hasPopup) {
+              this._createPopup(this.container, null, this.data);
+            }
+            return this.container;
+          }
+        });
+        return UnderlineAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias SquigglyAnnotationElement
+       */
+      var SquigglyAnnotationElement = function SquigglyAnnotationElementClosure() {
+        function SquigglyAnnotationElement(parameters) {
+          var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(SquigglyAnnotationElement, AnnotationElement, {
+          /**
+           * Render the squiggly annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof SquigglyAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function SquigglyAnnotationElement_render() {
+            this.container.className = 'squigglyAnnotation';
+            if (!this.data.hasPopup) {
+              this._createPopup(this.container, null, this.data);
+            }
+            return this.container;
+          }
+        });
+        return SquigglyAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias StrikeOutAnnotationElement
+       */
+      var StrikeOutAnnotationElement = function StrikeOutAnnotationElementClosure() {
+        function StrikeOutAnnotationElement(parameters) {
+          var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
+          AnnotationElement.call(this, parameters, isRenderable);
+        }
+        Util.inherit(StrikeOutAnnotationElement, AnnotationElement, {
+          /**
+           * Render the strikeout annotation's HTML element in the empty container.
+           *
+           * @public
+           * @memberof StrikeOutAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function StrikeOutAnnotationElement_render() {
+            this.container.className = 'strikeoutAnnotation';
+            if (!this.data.hasPopup) {
+              this._createPopup(this.container, null, this.data);
+            }
+            return this.container;
+          }
+        });
+        return StrikeOutAnnotationElement;
+      }();
+      /**
+       * @class
+       * @alias FileAttachmentAnnotationElement
+       */
+      var FileAttachmentAnnotationElement = function FileAttachmentAnnotationElementClosure() {
+        function FileAttachmentAnnotationElement(parameters) {
+          AnnotationElement.call(this, parameters, true);
+          this.filename = getFilenameFromUrl(parameters.data.file.filename);
+          this.content = parameters.data.file.content;
+        }
+        Util.inherit(FileAttachmentAnnotationElement, AnnotationElement, {
+          /**
+           * Render the file attachment annotation's HTML element in the empty
+           * container.
+           *
+           * @public
+           * @memberof FileAttachmentAnnotationElement
+           * @returns {HTMLSectionElement}
+           */
+          render: function FileAttachmentAnnotationElement_render() {
+            this.container.className = 'fileAttachmentAnnotation';
+            var trigger = document.createElement('div');
+            trigger.style.height = this.container.style.height;
+            trigger.style.width = this.container.style.width;
+            trigger.addEventListener('dblclick', this._download.bind(this));
+            if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
+              this._createPopup(this.container, trigger, this.data);
+            }
+            this.container.appendChild(trigger);
+            return this.container;
+          },
+          /**
+           * Download the file attachment associated with this annotation.
+           *
+           * @private
+           * @memberof FileAttachmentAnnotationElement
+           */
+          _download: function FileAttachmentAnnotationElement_download() {
+            if (!this.downloadManager) {
+              warn('Download cannot be started due to unavailable download manager');
+              return;
+            }
+            this.downloadManager.downloadData(this.content, this.filename, '');
+          }
+        });
+        return FileAttachmentAnnotationElement;
+      }();
+      /**
+       * @typedef {Object} AnnotationLayerParameters
+       * @property {PageViewport} viewport
+       * @property {HTMLDivElement} div
+       * @property {Array} annotations
+       * @property {PDFPage} page
+       * @property {IPDFLinkService} linkService
+       * @property {string} imageResourcesPath
+       * @property {boolean} renderInteractiveForms
+       */
+      /**
+       * @class
+       * @alias AnnotationLayer
+       */
+      var AnnotationLayer = function AnnotationLayerClosure() {
+        return {
+          /**
+           * Render a new annotation layer with all annotation elements.
+           *
+           * @public
+           * @param {AnnotationLayerParameters} parameters
+           * @memberof AnnotationLayer
+           */
+          render: function AnnotationLayer_render(parameters) {
+            var annotationElementFactory = new AnnotationElementFactory();
+            for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
+              var data = parameters.annotations[i];
+              if (!data) {
+                continue;
+              }
+              var properties = {
+                data: data,
+                layer: parameters.div,
+                page: parameters.page,
+                viewport: parameters.viewport,
+                linkService: parameters.linkService,
+                downloadManager: parameters.downloadManager,
+                imageResourcesPath: parameters.imageResourcesPath || getDefaultSetting('imageResourcesPath'),
+                renderInteractiveForms: parameters.renderInteractiveForms || false
+              };
+              var element = annotationElementFactory.create(properties);
+              if (element.isRenderable) {
+                parameters.div.appendChild(element.render());
+              }
+            }
+          },
+          /**
+           * Update the annotation elements on existing annotation layer.
+           *
+           * @public
+           * @param {AnnotationLayerParameters} parameters
+           * @memberof AnnotationLayer
+           */
+          update: function AnnotationLayer_update(parameters) {
+            for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
+              var data = parameters.annotations[i];
+              var element = parameters.div.querySelector('[data-annotation-id="' + data.id + '"]');
+              if (element) {
+                CustomStyle.setProp('transform', element, 'matrix(' + parameters.viewport.transform.join(',') + ')');
+              }
+            }
+            parameters.div.removeAttribute('hidden');
+          }
+        };
+      }();
+      exports.AnnotationLayer = AnnotationLayer;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayTextLayer = {}, root.pdfjsSharedUtil, root.pdfjsDisplayDOMUtils);
+    }(this, function (exports, sharedUtil, displayDOMUtils) {
+      var Util = sharedUtil.Util;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var CustomStyle = displayDOMUtils.CustomStyle;
+      var getDefaultSetting = displayDOMUtils.getDefaultSetting;
+      /**
+       * Text layer render parameters.
+       *
+       * @typedef {Object} TextLayerRenderParameters
+       * @property {TextContent} textContent - Text content to render (the object is
+       *   returned by the page's getTextContent() method).
+       * @property {HTMLElement} container - HTML element that will contain text runs.
+       * @property {PageViewport} viewport - The target viewport to properly
+       *   layout the text runs.
+       * @property {Array} textDivs - (optional) HTML elements that are correspond
+       *   the text items of the textContent input. This is output and shall be
+       *   initially be set to empty array.
+       * @property {number} timeout - (optional) Delay in milliseconds before
+       *   rendering of the text  runs occurs.
+       * @property {boolean} enhanceTextSelection - (optional) Whether to turn on the
+       *   text selection enhancement.
+       */
+      var renderTextLayer = function renderTextLayerClosure() {
+        var MAX_TEXT_DIVS_TO_RENDER = 100000;
+        var NonWhitespaceRegexp = /\S/;
+        function isAllWhitespace(str) {
+          return !NonWhitespaceRegexp.test(str);
+        }
+        // Text layers may contain many thousand div's, and using `styleBuf` avoids
+        // creating many intermediate strings when building their 'style' properties.
+        var styleBuf = [
+          'left: ',
+          0,
+          'px; top: ',
+          0,
+          'px; font-size: ',
+          0,
+          'px; font-family: ',
+          '',
+          ';'
+        ];
+        function appendText(task, geom, styles) {
+          // Initialize all used properties to keep the caches monomorphic.
+          var textDiv = document.createElement('div');
+          var textDivProperties = {
+            style: null,
+            angle: 0,
+            canvasWidth: 0,
+            isWhitespace: false,
+            originalTransform: null,
+            paddingBottom: 0,
+            paddingLeft: 0,
+            paddingRight: 0,
+            paddingTop: 0,
+            scale: 1
+          };
+          task._textDivs.push(textDiv);
+          if (isAllWhitespace(geom.str)) {
+            textDivProperties.isWhitespace = true;
+            task._textDivProperties.set(textDiv, textDivProperties);
+            return;
+          }
+          var tx = Util.transform(task._viewport.transform, geom.transform);
+          var angle = Math.atan2(tx[1], tx[0]);
+          var style = styles[geom.fontName];
+          if (style.vertical) {
+            angle += Math.PI / 2;
+          }
+          var fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);
+          var fontAscent = fontHeight;
+          if (style.ascent) {
+            fontAscent = style.ascent * fontAscent;
+          } else if (style.descent) {
+            fontAscent = (1 + style.descent) * fontAscent;
+          }
+          var left;
+          var top;
+          if (angle === 0) {
+            left = tx[4];
+            top = tx[5] - fontAscent;
+          } else {
+            left = tx[4] + fontAscent * Math.sin(angle);
+            top = tx[5] - fontAscent * Math.cos(angle);
+          }
+          styleBuf[1] = left;
+          styleBuf[3] = top;
+          styleBuf[5] = fontHeight;
+          styleBuf[7] = style.fontFamily;
+          textDivProperties.style = styleBuf.join('');
+          textDiv.setAttribute('style', textDivProperties.style);
+          textDiv.textContent = geom.str;
+          // |fontName| is only used by the Font Inspector. This test will succeed
+          // when e.g. the Font Inspector is off but the Stepper is on, but it's
+          // not worth the effort to do a more accurate test. We only use `dataset`
+          // here to make the font name available for the debugger.
+          if (getDefaultSetting('pdfBug')) {
+            textDiv.dataset.fontName = geom.fontName;
+          }
+          if (angle !== 0) {
+            textDivProperties.angle = angle * (180 / Math.PI);
+          }
+          // We don't bother scaling single-char text divs, because it has very
+          // little effect on text highlighting. This makes scrolling on docs with
+          // lots of such divs a lot faster.
+          if (geom.str.length > 1) {
+            if (style.vertical) {
+              textDivProperties.canvasWidth = geom.height * task._viewport.scale;
+            } else {
+              textDivProperties.canvasWidth = geom.width * task._viewport.scale;
+            }
+          }
+          task._textDivProperties.set(textDiv, textDivProperties);
+          if (task._enhanceTextSelection) {
+            var angleCos = 1, angleSin = 0;
+            if (angle !== 0) {
+              angleCos = Math.cos(angle);
+              angleSin = Math.sin(angle);
+            }
+            var divWidth = (style.vertical ? geom.height : geom.width) * task._viewport.scale;
+            var divHeight = fontHeight;
+            var m, b;
+            if (angle !== 0) {
+              m = [
+                angleCos,
+                angleSin,
+                -angleSin,
+                angleCos,
+                left,
+                top
+              ];
+              b = Util.getAxialAlignedBoundingBox([
+                0,
+                0,
+                divWidth,
+                divHeight
+              ], m);
+            } else {
+              b = [
+                left,
+                top,
+                left + divWidth,
+                top + divHeight
+              ];
+            }
+            task._bounds.push({
+              left: b[0],
+              top: b[1],
+              right: b[2],
+              bottom: b[3],
+              div: textDiv,
+              size: [
+                divWidth,
+                divHeight
+              ],
+              m: m
+            });
+          }
+        }
+        function render(task) {
+          if (task._canceled) {
+            return;
+          }
+          var textLayerFrag = task._container;
+          var textDivs = task._textDivs;
+          var capability = task._capability;
+          var textDivsLength = textDivs.length;
+          // No point in rendering many divs as it would make the browser
+          // unusable even after the divs are rendered.
+          if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {
+            task._renderingDone = true;
+            capability.resolve();
+            return;
+          }
+          var canvas = document.createElement('canvas');
+          canvas.mozOpaque = true;
+          var ctx = canvas.getContext('2d', { alpha: false });
+          var lastFontSize;
+          var lastFontFamily;
+          for (var i = 0; i < textDivsLength; i++) {
+            var textDiv = textDivs[i];
+            var textDivProperties = task._textDivProperties.get(textDiv);
+            if (textDivProperties.isWhitespace) {
+              continue;
+            }
+            var fontSize = textDiv.style.fontSize;
+            var fontFamily = textDiv.style.fontFamily;
+            // Only build font string and set to context if different from last.
+            if (fontSize !== lastFontSize || fontFamily !== lastFontFamily) {
+              ctx.font = fontSize + ' ' + fontFamily;
+              lastFontSize = fontSize;
+              lastFontFamily = fontFamily;
+            }
+            var width = ctx.measureText(textDiv.textContent).width;
+            textLayerFrag.appendChild(textDiv);
+            var transform = '';
+            if (textDivProperties.canvasWidth !== 0 && width > 0) {
+              textDivProperties.scale = textDivProperties.canvasWidth / width;
+              transform = 'scaleX(' + textDivProperties.scale + ')';
+            }
+            if (textDivProperties.angle !== 0) {
+              transform = 'rotate(' + textDivProperties.angle + 'deg) ' + transform;
+            }
+            if (transform !== '') {
+              textDivProperties.originalTransform = transform;
+              CustomStyle.setProp('transform', textDiv, transform);
+            }
+            task._textDivProperties.set(textDiv, textDivProperties);
+          }
+          task._renderingDone = true;
+          capability.resolve();
+        }
+        function expand(task) {
+          var bounds = task._bounds;
+          var viewport = task._viewport;
+          var expanded = expandBounds(viewport.width, viewport.height, bounds);
+          for (var i = 0; i < expanded.length; i++) {
+            var div = bounds[i].div;
+            var divProperties = task._textDivProperties.get(div);
+            if (divProperties.angle === 0) {
+              divProperties.paddingLeft = bounds[i].left - expanded[i].left;
+              divProperties.paddingTop = bounds[i].top - expanded[i].top;
+              divProperties.paddingRight = expanded[i].right - bounds[i].right;
+              divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;
+              task._textDivProperties.set(div, divProperties);
+              continue;
+            }
+            // Box is rotated -- trying to find padding so rotated div will not
+            // exceed its expanded bounds.
+            var e = expanded[i], b = bounds[i];
+            var m = b.m, c = m[0], s = m[1];
+            // Finding intersections with expanded box.
+            var points = [
+              [
+                0,
+                0
+              ],
+              [
+                0,
+                b.size[1]
+              ],
+              [
+                b.size[0],
+                0
+              ],
+              b.size
+            ];
+            var ts = new Float64Array(64);
+            points.forEach(function (p, i) {
+              var t = Util.applyTransform(p, m);
+              ts[i + 0] = c && (e.left - t[0]) / c;
+              ts[i + 4] = s && (e.top - t[1]) / s;
+              ts[i + 8] = c && (e.right - t[0]) / c;
+              ts[i + 12] = s && (e.bottom - t[1]) / s;
+              ts[i + 16] = s && (e.left - t[0]) / -s;
+              ts[i + 20] = c && (e.top - t[1]) / c;
+              ts[i + 24] = s && (e.right - t[0]) / -s;
+              ts[i + 28] = c && (e.bottom - t[1]) / c;
+              ts[i + 32] = c && (e.left - t[0]) / -c;
+              ts[i + 36] = s && (e.top - t[1]) / -s;
+              ts[i + 40] = c && (e.right - t[0]) / -c;
+              ts[i + 44] = s && (e.bottom - t[1]) / -s;
+              ts[i + 48] = s && (e.left - t[0]) / s;
+              ts[i + 52] = c && (e.top - t[1]) / -c;
+              ts[i + 56] = s && (e.right - t[0]) / s;
+              ts[i + 60] = c && (e.bottom - t[1]) / -c;
+            });
+            var findPositiveMin = function (ts, offset, count) {
+              var result = 0;
+              for (var i = 0; i < count; i++) {
+                var t = ts[offset++];
+                if (t > 0) {
+                  result = result ? Math.min(t, result) : t;
+                }
+              }
+              return result;
+            };
+            // Not based on math, but to simplify calculations, using cos and sin
+            // absolute values to not exceed the box (it can but insignificantly).
+            var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
+            divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
+            divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
+            divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
+            divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
+            task._textDivProperties.set(div, divProperties);
+          }
+        }
+        function expandBounds(width, height, boxes) {
+          var bounds = boxes.map(function (box, i) {
+            return {
+              x1: box.left,
+              y1: box.top,
+              x2: box.right,
+              y2: box.bottom,
+              index: i,
+              x1New: undefined,
+              x2New: undefined
+            };
+          });
+          expandBoundsLTR(width, bounds);
+          var expanded = new Array(boxes.length);
+          bounds.forEach(function (b) {
+            var i = b.index;
+            expanded[i] = {
+              left: b.x1New,
+              top: 0,
+              right: b.x2New,
+              bottom: 0
+            };
+          });
+          // Rotating on 90 degrees and extending extended boxes. Reusing the bounds
+          // array and objects.
+          boxes.map(function (box, i) {
+            var e = expanded[i], b = bounds[i];
+            b.x1 = box.top;
+            b.y1 = width - e.right;
+            b.x2 = box.bottom;
+            b.y2 = width - e.left;
+            b.index = i;
+            b.x1New = undefined;
+            b.x2New = undefined;
+          });
+          expandBoundsLTR(height, bounds);
+          bounds.forEach(function (b) {
+            var i = b.index;
+            expanded[i].top = b.x1New;
+            expanded[i].bottom = b.x2New;
+          });
+          return expanded;
+        }
+        function expandBoundsLTR(width, bounds) {
+          // Sorting by x1 coordinate and walk by the bounds in the same order.
+          bounds.sort(function (a, b) {
+            return a.x1 - b.x1 || a.index - b.index;
+          });
+          // First we see on the horizon is a fake boundary.
+          var fakeBoundary = {
+            x1: -Infinity,
+            y1: -Infinity,
+            x2: 0,
+            y2: Infinity,
+            index: -1,
+            x1New: 0,
+            x2New: 0
+          };
+          var horizon = [{
+              start: -Infinity,
+              end: Infinity,
+              boundary: fakeBoundary
+            }];
+          bounds.forEach(function (boundary) {
+            // Searching for the affected part of horizon.
+            // TODO red-black tree or simple binary search
+            var i = 0;
+            while (i < horizon.length && horizon[i].end <= boundary.y1) {
+              i++;
+            }
+            var j = horizon.length - 1;
+            while (j >= 0 && horizon[j].start >= boundary.y2) {
+              j--;
+            }
+            var horizonPart, affectedBoundary;
+            var q, k, maxXNew = -Infinity;
+            for (q = i; q <= j; q++) {
+              horizonPart = horizon[q];
+              affectedBoundary = horizonPart.boundary;
+              var xNew;
+              if (affectedBoundary.x2 > boundary.x1) {
+                // In the middle of the previous element, new x shall be at the
+                // boundary start. Extending if further if the affected bondary
+                // placed on top of the current one.
+                xNew = affectedBoundary.index > boundary.index ? affectedBoundary.x1New : boundary.x1;
+              } else if (affectedBoundary.x2New === undefined) {
+                // We have some space in between, new x in middle will be a fair
+                // choice.
+                xNew = (affectedBoundary.x2 + boundary.x1) / 2;
+              } else {
+                // Affected boundary has x2new set, using it as new x.
+                xNew = affectedBoundary.x2New;
+              }
+              if (xNew > maxXNew) {
+                maxXNew = xNew;
+              }
+            }
+            // Set new x1 for current boundary.
+            boundary.x1New = maxXNew;
+            // Adjusts new x2 for the affected boundaries.
+            for (q = i; q <= j; q++) {
+              horizonPart = horizon[q];
+              affectedBoundary = horizonPart.boundary;
+              if (affectedBoundary.x2New === undefined) {
+                // Was not set yet, choosing new x if possible.
+                if (affectedBoundary.x2 > boundary.x1) {
+                  // Current and affected boundaries intersect. If affected boundary
+                  // is placed on top of the current, shrinking the affected.
+                  if (affectedBoundary.index > boundary.index) {
+                    affectedBoundary.x2New = affectedBoundary.x2;
+                  }
+                } else {
+                  affectedBoundary.x2New = maxXNew;
+                }
+              } else if (affectedBoundary.x2New > maxXNew) {
+                // Affected boundary is touching new x, pushing it back.
+                affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);
+              }
+            }
+            // Fixing the horizon.
+            var changedHorizon = [], lastBoundary = null;
+            for (q = i; q <= j; q++) {
+              horizonPart = horizon[q];
+              affectedBoundary = horizonPart.boundary;
+              // Checking which boundary will be visible.
+              var useBoundary = affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;
+              if (lastBoundary === useBoundary) {
+                // Merging with previous.
+                changedHorizon[changedHorizon.length - 1].end = horizonPart.end;
+              } else {
+                changedHorizon.push({
+                  start: horizonPart.start,
+                  end: horizonPart.end,
+                  boundary: useBoundary
+                });
+                lastBoundary = useBoundary;
+              }
+            }
+            if (horizon[i].start < boundary.y1) {
+              changedHorizon[0].start = boundary.y1;
+              changedHorizon.unshift({
+                start: horizon[i].start,
+                end: boundary.y1,
+                boundary: horizon[i].boundary
+              });
+            }
+            if (boundary.y2 < horizon[j].end) {
+              changedHorizon[changedHorizon.length - 1].end = boundary.y2;
+              changedHorizon.push({
+                start: boundary.y2,
+                end: horizon[j].end,
+                boundary: horizon[j].boundary
+              });
+            }
+            // Set x2 new of boundary that is no longer visible (see overlapping case
+            // above).
+            // TODO more efficient, e.g. via reference counting.
+            for (q = i; q <= j; q++) {
+              horizonPart = horizon[q];
+              affectedBoundary = horizonPart.boundary;
+              if (affectedBoundary.x2New !== undefined) {
+                continue;
+              }
+              var used = false;
+              for (k = i - 1; !used && k >= 0 && horizon[k].start >= affectedBoundary.y1; k--) {
+                used = horizon[k].boundary === affectedBoundary;
+              }
+              for (k = j + 1; !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2; k++) {
+                used = horizon[k].boundary === affectedBoundary;
+              }
+              for (k = 0; !used && k < changedHorizon.length; k++) {
+                used = changedHorizon[k].boundary === affectedBoundary;
+              }
+              if (!used) {
+                affectedBoundary.x2New = maxXNew;
+              }
+            }
+            Array.prototype.splice.apply(horizon, [
+              i,
+              j - i + 1
+            ].concat(changedHorizon));
+          });
+          // Set new x2 for all unset boundaries.
+          horizon.forEach(function (horizonPart) {
+            var affectedBoundary = horizonPart.boundary;
+            if (affectedBoundary.x2New === undefined) {
+              affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);
+            }
+          });
+        }
+        /**
+         * Text layer rendering task.
+         *
+         * @param {TextContent} textContent
+         * @param {HTMLElement} container
+         * @param {PageViewport} viewport
+         * @param {Array} textDivs
+         * @param {boolean} enhanceTextSelection
+         * @private
+         */
+        function TextLayerRenderTask(textContent, container, viewport, textDivs, enhanceTextSelection) {
+          this._textContent = textContent;
+          this._container = container;
+          this._viewport = viewport;
+          this._textDivs = textDivs || [];
+          this._textDivProperties = new WeakMap();
+          this._renderingDone = false;
+          this._canceled = false;
+          this._capability = createPromiseCapability();
+          this._renderTimer = null;
+          this._bounds = [];
+          this._enhanceTextSelection = !!enhanceTextSelection;
+        }
+        TextLayerRenderTask.prototype = {
+          get promise() {
+            return this._capability.promise;
+          },
+          cancel: function TextLayer_cancel() {
+            this._canceled = true;
+            if (this._renderTimer !== null) {
+              clearTimeout(this._renderTimer);
+              this._renderTimer = null;
+            }
+            this._capability.reject('canceled');
+          },
+          _render: function TextLayer_render(timeout) {
+            var textItems = this._textContent.items;
+            var textStyles = this._textContent.styles;
+            for (var i = 0, len = textItems.length; i < len; i++) {
+              appendText(this, textItems[i], textStyles);
+            }
+            if (!timeout) {
+              // Render right away
+              render(this);
+            } else {
+              // Schedule
+              var self = this;
+              this._renderTimer = setTimeout(function () {
+                render(self);
+                self._renderTimer = null;
+              }, timeout);
+            }
+          },
+          expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {
+            if (!this._enhanceTextSelection || !this._renderingDone) {
+              return;
+            }
+            if (this._bounds !== null) {
+              expand(this);
+              this._bounds = null;
+            }
+            for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
+              var div = this._textDivs[i];
+              var divProperties = this._textDivProperties.get(div);
+              if (divProperties.isWhitespace) {
+                continue;
+              }
+              if (expandDivs) {
+                var transform = '', padding = '';
+                if (divProperties.scale !== 1) {
+                  transform = 'scaleX(' + divProperties.scale + ')';
+                }
+                if (divProperties.angle !== 0) {
+                  transform = 'rotate(' + divProperties.angle + 'deg) ' + transform;
+                }
+                if (divProperties.paddingLeft !== 0) {
+                  padding += ' padding-left: ' + divProperties.paddingLeft / divProperties.scale + 'px;';
+                  transform += ' translateX(' + -divProperties.paddingLeft / divProperties.scale + 'px)';
+                }
+                if (divProperties.paddingTop !== 0) {
+                  padding += ' padding-top: ' + divProperties.paddingTop + 'px;';
+                  transform += ' translateY(' + -divProperties.paddingTop + 'px)';
+                }
+                if (divProperties.paddingRight !== 0) {
+                  padding += ' padding-right: ' + divProperties.paddingRight / divProperties.scale + 'px;';
+                }
+                if (divProperties.paddingBottom !== 0) {
+                  padding += ' padding-bottom: ' + divProperties.paddingBottom + 'px;';
+                }
+                if (padding !== '') {
+                  div.setAttribute('style', divProperties.style + padding);
+                }
+                if (transform !== '') {
+                  CustomStyle.setProp('transform', div, transform);
+                }
+              } else {
+                div.style.padding = 0;
+                CustomStyle.setProp('transform', div, divProperties.originalTransform || '');
+              }
+            }
+          }
+        };
+        /**
+         * Starts rendering of the text layer.
+         *
+         * @param {TextLayerRenderParameters} renderParameters
+         * @returns {TextLayerRenderTask}
+         */
+        function renderTextLayer(renderParameters) {
+          var task = new TextLayerRenderTask(renderParameters.textContent, renderParameters.container, renderParameters.viewport, renderParameters.textDivs, renderParameters.enhanceTextSelection);
+          task._render(renderParameters.timeout);
+          return task;
+        }
+        return renderTextLayer;
+      }();
+      exports.renderTextLayer = renderTextLayer;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayWebGL = {}, root.pdfjsSharedUtil, root.pdfjsDisplayDOMUtils);
+    }(this, function (exports, sharedUtil, displayDOMUtils) {
+      var shadow = sharedUtil.shadow;
+      var getDefaultSetting = displayDOMUtils.getDefaultSetting;
+      var WebGLUtils = function WebGLUtilsClosure() {
+        function loadShader(gl, code, shaderType) {
+          var shader = gl.createShader(shaderType);
+          gl.shaderSource(shader, code);
+          gl.compileShader(shader);
+          var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
+          if (!compiled) {
+            var errorMsg = gl.getShaderInfoLog(shader);
+            throw new Error('Error during shader compilation: ' + errorMsg);
+          }
+          return shader;
+        }
+        function createVertexShader(gl, code) {
+          return loadShader(gl, code, gl.VERTEX_SHADER);
+        }
+        function createFragmentShader(gl, code) {
+          return loadShader(gl, code, gl.FRAGMENT_SHADER);
+        }
+        function createProgram(gl, shaders) {
+          var program = gl.createProgram();
+          for (var i = 0, ii = shaders.length; i < ii; ++i) {
+            gl.attachShader(program, shaders[i]);
+          }
+          gl.linkProgram(program);
+          var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
+          if (!linked) {
+            var errorMsg = gl.getProgramInfoLog(program);
+            throw new Error('Error during program linking: ' + errorMsg);
+          }
+          return program;
+        }
+        function createTexture(gl, image, textureId) {
+          gl.activeTexture(textureId);
+          var texture = gl.createTexture();
+          gl.bindTexture(gl.TEXTURE_2D, texture);
+          // Set the parameters so we can render any size image.
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+          // Upload the image into the texture.
+          gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+          return texture;
+        }
+        var currentGL, currentCanvas;
+        function generateGL() {
+          if (currentGL) {
+            return;
+          }
+          currentCanvas = document.createElement('canvas');
+          currentGL = currentCanvas.getContext('webgl', { premultipliedalpha: false });
+        }
+        var smaskVertexShaderCode = '\
+  attribute vec2 a_position;                                    \
+  attribute vec2 a_texCoord;                                    \
+                                                                \
+  uniform vec2 u_resolution;                                    \
+                                                                \
+  varying vec2 v_texCoord;                                      \
+                                                                \
+  void main() {                                                 \
+    vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0;   \
+    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
+                                                                \
+    v_texCoord = a_texCoord;                                    \
+  }                                                             ';
+        var smaskFragmentShaderCode = '\
+  precision mediump float;                                      \
+                                                                \
+  uniform vec4 u_backdrop;                                      \
+  uniform int u_subtype;                                        \
+  uniform sampler2D u_image;                                    \
+  uniform sampler2D u_mask;                                     \
+                                                                \
+  varying vec2 v_texCoord;                                      \
+                                                                \
+  void main() {                                                 \
+    vec4 imageColor = texture2D(u_image, v_texCoord);           \
+    vec4 maskColor = texture2D(u_mask, v_texCoord);             \
+    if (u_backdrop.a > 0.0) {                                   \
+      maskColor.rgb = maskColor.rgb * maskColor.a +             \
+                      u_backdrop.rgb * (1.0 - maskColor.a);     \
+    }                                                           \
+    float lum;                                                  \
+    if (u_subtype == 0) {                                       \
+      lum = maskColor.a;                                        \
+    } else {                                                    \
+      lum = maskColor.r * 0.3 + maskColor.g * 0.59 +            \
+            maskColor.b * 0.11;                                 \
+    }                                                           \
+    imageColor.a *= lum;                                        \
+    imageColor.rgb *= imageColor.a;                             \
+    gl_FragColor = imageColor;                                  \
+  }                                                             ';
+        var smaskCache = null;
+        function initSmaskGL() {
+          var canvas, gl;
+          generateGL();
+          canvas = currentCanvas;
+          currentCanvas = null;
+          gl = currentGL;
+          currentGL = null;
+          // setup a GLSL program
+          var vertexShader = createVertexShader(gl, smaskVertexShaderCode);
+          var fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);
+          var program = createProgram(gl, [
+            vertexShader,
+            fragmentShader
+          ]);
+          gl.useProgram(program);
+          var cache = {};
+          cache.gl = gl;
+          cache.canvas = canvas;
+          cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution');
+          cache.positionLocation = gl.getAttribLocation(program, 'a_position');
+          cache.backdropLocation = gl.getUniformLocation(program, 'u_backdrop');
+          cache.subtypeLocation = gl.getUniformLocation(program, 'u_subtype');
+          var texCoordLocation = gl.getAttribLocation(program, 'a_texCoord');
+          var texLayerLocation = gl.getUniformLocation(program, 'u_image');
+          var texMaskLocation = gl.getUniformLocation(program, 'u_mask');
+          // provide texture coordinates for the rectangle.
+          var texCoordBuffer = gl.createBuffer();
+          gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
+          gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            0.0,
+            0.0,
+            1.0,
+            0.0,
+            0.0,
+            1.0,
+            0.0,
+            1.0,
+            1.0,
+            0.0,
+            1.0,
+            1.0
+          ]), gl.STATIC_DRAW);
+          gl.enableVertexAttribArray(texCoordLocation);
+          gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);
+          gl.uniform1i(texLayerLocation, 0);
+          gl.uniform1i(texMaskLocation, 1);
+          smaskCache = cache;
+        }
+        function composeSMask(layer, mask, properties) {
+          var width = layer.width, height = layer.height;
+          if (!smaskCache) {
+            initSmaskGL();
+          }
+          var cache = smaskCache, canvas = cache.canvas, gl = cache.gl;
+          canvas.width = width;
+          canvas.height = height;
+          gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+          gl.uniform2f(cache.resolutionLocation, width, height);
+          if (properties.backdrop) {
+            gl.uniform4f(cache.resolutionLocation, properties.backdrop[0], properties.backdrop[1], properties.backdrop[2], 1);
+          } else {
+            gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);
+          }
+          gl.uniform1i(cache.subtypeLocation, properties.subtype === 'Luminosity' ? 1 : 0);
+          // Create a textures
+          var texture = createTexture(gl, layer, gl.TEXTURE0);
+          var maskTexture = createTexture(gl, mask, gl.TEXTURE1);
+          // Create a buffer and put a single clipspace rectangle in
+          // it (2 triangles)
+          var buffer = gl.createBuffer();
+          gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+          gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+            0,
+            0,
+            width,
+            0,
+            0,
+            height,
+            0,
+            height,
+            width,
+            0,
+            width,
+            height
+          ]), gl.STATIC_DRAW);
+          gl.enableVertexAttribArray(cache.positionLocation);
+          gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
+          // draw
+          gl.clearColor(0, 0, 0, 0);
+          gl.enable(gl.BLEND);
+          gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+          gl.clear(gl.COLOR_BUFFER_BIT);
+          gl.drawArrays(gl.TRIANGLES, 0, 6);
+          gl.flush();
+          gl.deleteTexture(texture);
+          gl.deleteTexture(maskTexture);
+          gl.deleteBuffer(buffer);
+          return canvas;
+        }
+        var figuresVertexShaderCode = '\
+  attribute vec2 a_position;                                    \
+  attribute vec3 a_color;                                       \
+                                                                \
+  uniform vec2 u_resolution;                                    \
+  uniform vec2 u_scale;                                         \
+  uniform vec2 u_offset;                                        \
+                                                                \
+  varying vec4 v_color;                                         \
+                                                                \
+  void main() {                                                 \
+    vec2 position = (a_position + u_offset) * u_scale;          \
+    vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0;     \
+    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
+                                                                \
+    v_color = vec4(a_color / 255.0, 1.0);                       \
+  }                                                             ';
+        var figuresFragmentShaderCode = '\
+  precision mediump float;                                      \
+                                                                \
+  varying vec4 v_color;                                         \
+                                                                \
+  void main() {                                                 \
+    gl_FragColor = v_color;                                     \
+  }                                                             ';
+        var figuresCache = null;
+        function initFiguresGL() {
+          var canvas, gl;
+          generateGL();
+          canvas = currentCanvas;
+          currentCanvas = null;
+          gl = currentGL;
+          currentGL = null;
+          // setup a GLSL program
+          var vertexShader = createVertexShader(gl, figuresVertexShaderCode);
+          var fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);
+          var program = createProgram(gl, [
+            vertexShader,
+            fragmentShader
+          ]);
+          gl.useProgram(program);
+          var cache = {};
+          cache.gl = gl;
+          cache.canvas = canvas;
+          cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution');
+          cache.scaleLocation = gl.getUniformLocation(program, 'u_scale');
+          cache.offsetLocation = gl.getUniformLocation(program, 'u_offset');
+          cache.positionLocation = gl.getAttribLocation(program, 'a_position');
+          cache.colorLocation = gl.getAttribLocation(program, 'a_color');
+          figuresCache = cache;
+        }
+        function drawFigures(width, height, backgroundColor, figures, context) {
+          if (!figuresCache) {
+            initFiguresGL();
+          }
+          var cache = figuresCache, canvas = cache.canvas, gl = cache.gl;
+          canvas.width = width;
+          canvas.height = height;
+          gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+          gl.uniform2f(cache.resolutionLocation, width, height);
+          // count triangle points
+          var count = 0;
+          var i, ii, rows;
+          for (i = 0, ii = figures.length; i < ii; i++) {
+            switch (figures[i].type) {
+            case 'lattice':
+              rows = figures[i].coords.length / figures[i].verticesPerRow | 0;
+              count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;
+              break;
+            case 'triangles':
+              count += figures[i].coords.length;
+              break;
+            }
+          }
+          // transfer data
+          var coords = new Float32Array(count * 2);
+          var colors = new Uint8Array(count * 3);
+          var coordsMap = context.coords, colorsMap = context.colors;
+          var pIndex = 0, cIndex = 0;
+          for (i = 0, ii = figures.length; i < ii; i++) {
+            var figure = figures[i], ps = figure.coords, cs = figure.colors;
+            switch (figure.type) {
+            case 'lattice':
+              var cols = figure.verticesPerRow;
+              rows = ps.length / cols | 0;
+              for (var row = 1; row < rows; row++) {
+                var offset = row * cols + 1;
+                for (var col = 1; col < cols; col++, offset++) {
+                  coords[pIndex] = coordsMap[ps[offset - cols - 1]];
+                  coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];
+                  coords[pIndex + 2] = coordsMap[ps[offset - cols]];
+                  coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];
+                  coords[pIndex + 4] = coordsMap[ps[offset - 1]];
+                  coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];
+                  colors[cIndex] = colorsMap[cs[offset - cols - 1]];
+                  colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1];
+                  colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2];
+                  colors[cIndex + 3] = colorsMap[cs[offset - cols]];
+                  colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1];
+                  colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2];
+                  colors[cIndex + 6] = colorsMap[cs[offset - 1]];
+                  colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1];
+                  colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2];
+                  coords[pIndex + 6] = coords[pIndex + 2];
+                  coords[pIndex + 7] = coords[pIndex + 3];
+                  coords[pIndex + 8] = coords[pIndex + 4];
+                  coords[pIndex + 9] = coords[pIndex + 5];
+                  coords[pIndex + 10] = coordsMap[ps[offset]];
+                  coords[pIndex + 11] = coordsMap[ps[offset] + 1];
+                  colors[cIndex + 9] = colors[cIndex + 3];
+                  colors[cIndex + 10] = colors[cIndex + 4];
+                  colors[cIndex + 11] = colors[cIndex + 5];
+                  colors[cIndex + 12] = colors[cIndex + 6];
+                  colors[cIndex + 13] = colors[cIndex + 7];
+                  colors[cIndex + 14] = colors[cIndex + 8];
+                  colors[cIndex + 15] = colorsMap[cs[offset]];
+                  colors[cIndex + 16] = colorsMap[cs[offset] + 1];
+                  colors[cIndex + 17] = colorsMap[cs[offset] + 2];
+                  pIndex += 12;
+                  cIndex += 18;
+                }
+              }
+              break;
+            case 'triangles':
+              for (var j = 0, jj = ps.length; j < jj; j++) {
+                coords[pIndex] = coordsMap[ps[j]];
+                coords[pIndex + 1] = coordsMap[ps[j] + 1];
+                colors[cIndex] = colorsMap[cs[j]];
+                colors[cIndex + 1] = colorsMap[cs[j] + 1];
+                colors[cIndex + 2] = colorsMap[cs[j] + 2];
+                pIndex += 2;
+                cIndex += 3;
+              }
+              break;
+            }
+          }
+          // draw
+          if (backgroundColor) {
+            gl.clearColor(backgroundColor[0] / 255, backgroundColor[1] / 255, backgroundColor[2] / 255, 1.0);
+          } else {
+            gl.clearColor(0, 0, 0, 0);
+          }
+          gl.clear(gl.COLOR_BUFFER_BIT);
+          var coordsBuffer = gl.createBuffer();
+          gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);
+          gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);
+          gl.enableVertexAttribArray(cache.positionLocation);
+          gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
+          var colorsBuffer = gl.createBuffer();
+          gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);
+          gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);
+          gl.enableVertexAttribArray(cache.colorLocation);
+          gl.vertexAttribPointer(cache.colorLocation, 3, gl.UNSIGNED_BYTE, false, 0, 0);
+          gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);
+          gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);
+          gl.drawArrays(gl.TRIANGLES, 0, count);
+          gl.flush();
+          gl.deleteBuffer(coordsBuffer);
+          gl.deleteBuffer(colorsBuffer);
+          return canvas;
+        }
+        function cleanup() {
+          if (smaskCache && smaskCache.canvas) {
+            smaskCache.canvas.width = 0;
+            smaskCache.canvas.height = 0;
+          }
+          if (figuresCache && figuresCache.canvas) {
+            figuresCache.canvas.width = 0;
+            figuresCache.canvas.height = 0;
+          }
+          smaskCache = null;
+          figuresCache = null;
+        }
+        return {
+          get isEnabled() {
+            if (getDefaultSetting('disableWebGL')) {
+              return false;
+            }
+            var enabled = false;
+            try {
+              generateGL();
+              enabled = !!currentGL;
+            } catch (e) {
+            }
+            return shadow(this, 'isEnabled', enabled);
+          },
+          composeSMask: composeSMask,
+          drawFigures: drawFigures,
+          clear: cleanup
+        };
+      }();
+      exports.WebGLUtils = WebGLUtils;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayPatternHelper = {}, root.pdfjsSharedUtil, root.pdfjsDisplayWebGL);
+    }(this, function (exports, sharedUtil, displayWebGL) {
+      var Util = sharedUtil.Util;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var error = sharedUtil.error;
+      var WebGLUtils = displayWebGL.WebGLUtils;
+      var ShadingIRs = {};
+      ShadingIRs.RadialAxial = {
+        fromIR: function RadialAxial_fromIR(raw) {
+          var type = raw[1];
+          var colorStops = raw[2];
+          var p0 = raw[3];
+          var p1 = raw[4];
+          var r0 = raw[5];
+          var r1 = raw[6];
+          return {
+            type: 'Pattern',
+            getPattern: function RadialAxial_getPattern(ctx) {
+              var grad;
+              if (type === 'axial') {
+                grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
+              } else if (type === 'radial') {
+                grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
+              }
+              for (var i = 0, ii = colorStops.length; i < ii; ++i) {
+                var c = colorStops[i];
+                grad.addColorStop(c[0], c[1]);
+              }
+              return grad;
+            }
+          };
+        }
+      };
+      var createMeshCanvas = function createMeshCanvasClosure() {
+        function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
+          // Very basic Gouraud-shaded triangle rasterization algorithm.
+          var coords = context.coords, colors = context.colors;
+          var bytes = data.data, rowSize = data.width * 4;
+          var tmp;
+          if (coords[p1 + 1] > coords[p2 + 1]) {
+            tmp = p1;
+            p1 = p2;
+            p2 = tmp;
+            tmp = c1;
+            c1 = c2;
+            c2 = tmp;
+          }
+          if (coords[p2 + 1] > coords[p3 + 1]) {
+            tmp = p2;
+            p2 = p3;
+            p3 = tmp;
+            tmp = c2;
+            c2 = c3;
+            c3 = tmp;
+          }
+          if (coords[p1 + 1] > coords[p2 + 1]) {
+            tmp = p1;
+            p1 = p2;
+            p2 = tmp;
+            tmp = c1;
+            c1 = c2;
+            c2 = tmp;
+          }
+          var x1 = (coords[p1] + context.offsetX) * context.scaleX;
+          var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
+          var x2 = (coords[p2] + context.offsetX) * context.scaleX;
+          var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
+          var x3 = (coords[p3] + context.offsetX) * context.scaleX;
+          var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
+          if (y1 >= y3) {
+            return;
+          }
+          var c1r = colors[c1], c1g = colors[c1 + 1], c1b = colors[c1 + 2];
+          var c2r = colors[c2], c2g = colors[c2 + 1], c2b = colors[c2 + 2];
+          var c3r = colors[c3], c3g = colors[c3 + 1], c3b = colors[c3 + 2];
+          var minY = Math.round(y1), maxY = Math.round(y3);
+          var xa, car, cag, cab;
+          var xb, cbr, cbg, cbb;
+          var k;
+          for (var y = minY; y <= maxY; y++) {
+            if (y < y2) {
+              k = y < y1 ? 0 : y1 === y2 ? 1 : (y1 - y) / (y1 - y2);
+              xa = x1 - (x1 - x2) * k;
+              car = c1r - (c1r - c2r) * k;
+              cag = c1g - (c1g - c2g) * k;
+              cab = c1b - (c1b - c2b) * k;
+            } else {
+              k = y > y3 ? 1 : y2 === y3 ? 0 : (y2 - y) / (y2 - y3);
+              xa = x2 - (x2 - x3) * k;
+              car = c2r - (c2r - c3r) * k;
+              cag = c2g - (c2g - c3g) * k;
+              cab = c2b - (c2b - c3b) * k;
+            }
+            k = y < y1 ? 0 : y > y3 ? 1 : (y1 - y) / (y1 - y3);
+            xb = x1 - (x1 - x3) * k;
+            cbr = c1r - (c1r - c3r) * k;
+            cbg = c1g - (c1g - c3g) * k;
+            cbb = c1b - (c1b - c3b) * k;
+            var x1_ = Math.round(Math.min(xa, xb));
+            var x2_ = Math.round(Math.max(xa, xb));
+            var j = rowSize * y + x1_ * 4;
+            for (var x = x1_; x <= x2_; x++) {
+              k = (xa - x) / (xa - xb);
+              k = k < 0 ? 0 : k > 1 ? 1 : k;
+              bytes[j++] = car - (car - cbr) * k | 0;
+              bytes[j++] = cag - (cag - cbg) * k | 0;
+              bytes[j++] = cab - (cab - cbb) * k | 0;
+              bytes[j++] = 255;
+            }
+          }
+        }
+        function drawFigure(data, figure, context) {
+          var ps = figure.coords;
+          var cs = figure.colors;
+          var i, ii;
+          switch (figure.type) {
+          case 'lattice':
+            var verticesPerRow = figure.verticesPerRow;
+            var rows = Math.floor(ps.length / verticesPerRow) - 1;
+            var cols = verticesPerRow - 1;
+            for (i = 0; i < rows; i++) {
+              var q = i * verticesPerRow;
+              for (var j = 0; j < cols; j++, q++) {
+                drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow], cs[q], cs[q + 1], cs[q + verticesPerRow]);
+                drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q + verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
+              }
+            }
+            break;
+          case 'triangles':
+            for (i = 0, ii = ps.length; i < ii; i += 3) {
+              drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i + 1], cs[i + 2]);
+            }
+            break;
+          default:
+            error('illigal figure');
+            break;
+          }
+        }
+        function createMeshCanvas(bounds, combinesScale, coords, colors, figures, backgroundColor, cachedCanvases) {
+          // we will increase scale on some weird factor to let antialiasing take
+          // care of "rough" edges
+          var EXPECTED_SCALE = 1.1;
+          // MAX_PATTERN_SIZE is used to avoid OOM situation.
+          var MAX_PATTERN_SIZE = 3000;
+          // 10in @ 300dpi shall be enough
+          // We need to keep transparent border around our pattern for fill():
+          // createPattern with 'no-repeat' will bleed edges across entire area.
+          var BORDER_SIZE = 2;
+          var offsetX = Math.floor(bounds[0]);
+          var offsetY = Math.floor(bounds[1]);
+          var boundsWidth = Math.ceil(bounds[2]) - offsetX;
+          var boundsHeight = Math.ceil(bounds[3]) - offsetY;
+          var width = Math.min(Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
+          var height = Math.min(Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
+          var scaleX = boundsWidth / width;
+          var scaleY = boundsHeight / height;
+          var context = {
+            coords: coords,
+            colors: colors,
+            offsetX: -offsetX,
+            offsetY: -offsetY,
+            scaleX: 1 / scaleX,
+            scaleY: 1 / scaleY
+          };
+          var paddedWidth = width + BORDER_SIZE * 2;
+          var paddedHeight = height + BORDER_SIZE * 2;
+          var canvas, tmpCanvas, i, ii;
+          if (WebGLUtils.isEnabled) {
+            canvas = WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
+            // https://bugzilla.mozilla.org/show_bug.cgi?id=972126
+            tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
+            tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
+            canvas = tmpCanvas.canvas;
+          } else {
+            tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
+            var tmpCtx = tmpCanvas.context;
+            var data = tmpCtx.createImageData(width, height);
+            if (backgroundColor) {
+              var bytes = data.data;
+              for (i = 0, ii = bytes.length; i < ii; i += 4) {
+                bytes[i] = backgroundColor[0];
+                bytes[i + 1] = backgroundColor[1];
+                bytes[i + 2] = backgroundColor[2];
+                bytes[i + 3] = 255;
+              }
+            }
+            for (i = 0; i < figures.length; i++) {
+              drawFigure(data, figures[i], context);
+            }
+            tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
+            canvas = tmpCanvas.canvas;
+          }
+          return {
+            canvas: canvas,
+            offsetX: offsetX - BORDER_SIZE * scaleX,
+            offsetY: offsetY - BORDER_SIZE * scaleY,
+            scaleX: scaleX,
+            scaleY: scaleY
+          };
+        }
+        return createMeshCanvas;
+      }();
+      ShadingIRs.Mesh = {
+        fromIR: function Mesh_fromIR(raw) {
+          //var type = raw[1];
+          var coords = raw[2];
+          var colors = raw[3];
+          var figures = raw[4];
+          var bounds = raw[5];
+          var matrix = raw[6];
+          //var bbox = raw[7];
+          var background = raw[8];
+          return {
+            type: 'Pattern',
+            getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
+              var scale;
+              if (shadingFill) {
+                scale = Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
+              } else {
+                // Obtain scale from matrix and current transformation matrix.
+                scale = Util.singularValueDecompose2dScale(owner.baseTransform);
+                if (matrix) {
+                  var matrixScale = Util.singularValueDecompose2dScale(matrix);
+                  scale = [
+                    scale[0] * matrixScale[0],
+                    scale[1] * matrixScale[1]
+                  ];
+                }
+              }
+              // Rasterizing on the main thread since sending/queue large canvases
+              // might cause OOM.
+              var temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords, colors, figures, shadingFill ? null : background, owner.cachedCanvases);
+              if (!shadingFill) {
+                ctx.setTransform.apply(ctx, owner.baseTransform);
+                if (matrix) {
+                  ctx.transform.apply(ctx, matrix);
+                }
+              }
+              ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
+              ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
+              return ctx.createPattern(temporaryPatternCanvas.canvas, 'no-repeat');
+            }
+          };
+        }
+      };
+      ShadingIRs.Dummy = {
+        fromIR: function Dummy_fromIR() {
+          return {
+            type: 'Pattern',
+            getPattern: function Dummy_fromIR_getPattern() {
+              return 'hotpink';
+            }
+          };
+        }
+      };
+      function getShadingPatternFromIR(raw) {
+        var shadingIR = ShadingIRs[raw[0]];
+        if (!shadingIR) {
+          error('Unknown IR type: ' + raw[0]);
+        }
+        return shadingIR.fromIR(raw);
+      }
+      var TilingPattern = function TilingPatternClosure() {
+        var PaintType = {
+          COLORED: 1,
+          UNCOLORED: 2
+        };
+        var MAX_PATTERN_SIZE = 3000;
+        // 10in @ 300dpi shall be enough
+        function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
+          this.operatorList = IR[2];
+          this.matrix = IR[3] || [
+            1,
+            0,
+            0,
+            1,
+            0,
+            0
+          ];
+          this.bbox = IR[4];
+          this.xstep = IR[5];
+          this.ystep = IR[6];
+          this.paintType = IR[7];
+          this.tilingType = IR[8];
+          this.color = color;
+          this.canvasGraphicsFactory = canvasGraphicsFactory;
+          this.baseTransform = baseTransform;
+          this.type = 'Pattern';
+          this.ctx = ctx;
+        }
+        TilingPattern.prototype = {
+          createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
+            var operatorList = this.operatorList;
+            var bbox = this.bbox;
+            var xstep = this.xstep;
+            var ystep = this.ystep;
+            var paintType = this.paintType;
+            var tilingType = this.tilingType;
+            var color = this.color;
+            var canvasGraphicsFactory = this.canvasGraphicsFactory;
+            info('TilingType: ' + tilingType);
+            var x0 = bbox[0], y0 = bbox[1], x1 = bbox[2], y1 = bbox[3];
+            var topLeft = [
+              x0,
+              y0
+            ];
+            // we want the canvas to be as large as the step size
+            var botRight = [
+              x0 + xstep,
+              y0 + ystep
+            ];
+            var width = botRight[0] - topLeft[0];
+            var height = botRight[1] - topLeft[1];
+            // Obtain scale from matrix and current transformation matrix.
+            var matrixScale = Util.singularValueDecompose2dScale(this.matrix);
+            var curMatrixScale = Util.singularValueDecompose2dScale(this.baseTransform);
+            var combinedScale = [
+              matrixScale[0] * curMatrixScale[0],
+              matrixScale[1] * curMatrixScale[1]
+            ];
+            // MAX_PATTERN_SIZE is used to avoid OOM situation.
+            // Use width and height values that are as close as possible to the end
+            // result when the pattern is used. Too low value makes the pattern look
+            // blurry. Too large value makes it look too crispy.
+            width = Math.min(Math.ceil(Math.abs(width * combinedScale[0])), MAX_PATTERN_SIZE);
+            height = Math.min(Math.ceil(Math.abs(height * combinedScale[1])), MAX_PATTERN_SIZE);
+            var tmpCanvas = owner.cachedCanvases.getCanvas('pattern', width, height, true);
+            var tmpCtx = tmpCanvas.context;
+            var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
+            graphics.groupLevel = owner.groupLevel;
+            this.setFillAndStrokeStyleToContext(tmpCtx, paintType, color);
+            this.setScale(width, height, xstep, ystep);
+            this.transformToScale(graphics);
+            // transform coordinates to pattern space
+            var tmpTranslate = [
+              1,
+              0,
+              0,
+              1,
+              -topLeft[0],
+              -topLeft[1]
+            ];
+            graphics.transform.apply(graphics, tmpTranslate);
+            this.clipBbox(graphics, bbox, x0, y0, x1, y1);
+            graphics.executeOperatorList(operatorList);
+            return tmpCanvas.canvas;
+          },
+          setScale: function TilingPattern_setScale(width, height, xstep, ystep) {
+            this.scale = [
+              width / xstep,
+              height / ystep
+            ];
+          },
+          transformToScale: function TilingPattern_transformToScale(graphics) {
+            var scale = this.scale;
+            var tmpScale = [
+              scale[0],
+              0,
+              0,
+              scale[1],
+              0,
+              0
+            ];
+            graphics.transform.apply(graphics, tmpScale);
+          },
+          scaleToContext: function TilingPattern_scaleToContext() {
+            var scale = this.scale;
+            this.ctx.scale(1 / scale[0], 1 / scale[1]);
+          },
+          clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
+            if (bbox && isArray(bbox) && bbox.length === 4) {
+              var bboxWidth = x1 - x0;
+              var bboxHeight = y1 - y0;
+              graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
+              graphics.clip();
+              graphics.endPath();
+            }
+          },
+          setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(context, paintType, color) {
+            switch (paintType) {
+            case PaintType.COLORED:
+              var ctx = this.ctx;
+              context.fillStyle = ctx.fillStyle;
+              context.strokeStyle = ctx.strokeStyle;
+              break;
+            case PaintType.UNCOLORED:
+              var cssColor = Util.makeCssRgb(color[0], color[1], color[2]);
+              context.fillStyle = cssColor;
+              context.strokeStyle = cssColor;
+              break;
+            default:
+              error('Unsupported paint type: ' + paintType);
+            }
+          },
+          getPattern: function TilingPattern_getPattern(ctx, owner) {
+            var temporaryPatternCanvas = this.createPatternCanvas(owner);
+            ctx = this.ctx;
+            ctx.setTransform.apply(ctx, this.baseTransform);
+            ctx.transform.apply(ctx, this.matrix);
+            this.scaleToContext();
+            return ctx.createPattern(temporaryPatternCanvas, 'repeat');
+          }
+        };
+        return TilingPattern;
+      }();
+      exports.getShadingPatternFromIR = getShadingPatternFromIR;
+      exports.TilingPattern = TilingPattern;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayCanvas = {}, root.pdfjsSharedUtil, root.pdfjsDisplayDOMUtils, root.pdfjsDisplayPatternHelper, root.pdfjsDisplayWebGL);
+    }(this, function (exports, sharedUtil, displayDOMUtils, displayPatternHelper, displayWebGL) {
+      var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX;
+      var IDENTITY_MATRIX = sharedUtil.IDENTITY_MATRIX;
+      var ImageKind = sharedUtil.ImageKind;
+      var OPS = sharedUtil.OPS;
+      var TextRenderingMode = sharedUtil.TextRenderingMode;
+      var Uint32ArrayView = sharedUtil.Uint32ArrayView;
+      var Util = sharedUtil.Util;
+      var assert = sharedUtil.assert;
+      var info = sharedUtil.info;
+      var isNum = sharedUtil.isNum;
+      var isArray = sharedUtil.isArray;
+      var isLittleEndian = sharedUtil.isLittleEndian;
+      var error = sharedUtil.error;
+      var shadow = sharedUtil.shadow;
+      var warn = sharedUtil.warn;
+      var TilingPattern = displayPatternHelper.TilingPattern;
+      var getShadingPatternFromIR = displayPatternHelper.getShadingPatternFromIR;
+      var WebGLUtils = displayWebGL.WebGLUtils;
+      var hasCanvasTypedArrays = displayDOMUtils.hasCanvasTypedArrays;
+      // <canvas> contexts store most of the state we need natively.
+      // However, PDF needs a bit more state, which we store here.
+      // Minimal font size that would be used during canvas fillText operations.
+      var MIN_FONT_SIZE = 16;
+      // Maximum font size that would be used during canvas fillText operations.
+      var MAX_FONT_SIZE = 100;
+      var MAX_GROUP_SIZE = 4096;
+      // Heuristic value used when enforcing minimum line widths.
+      var MIN_WIDTH_FACTOR = 0.65;
+      var COMPILE_TYPE3_GLYPHS = true;
+      var MAX_SIZE_TO_COMPILE = 1000;
+      var FULL_CHUNK_HEIGHT = 16;
+      var HasCanvasTypedArraysCached = {
+        get value() {
+          return shadow(HasCanvasTypedArraysCached, 'value', hasCanvasTypedArrays());
+        }
+      };
+      var IsLittleEndianCached = {
+        get value() {
+          return shadow(IsLittleEndianCached, 'value', isLittleEndian());
+        }
+      };
+      function createScratchCanvas(width, height) {
+        var canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        return canvas;
+      }
+      function addContextCurrentTransform(ctx) {
+        // If the context doesn't expose a `mozCurrentTransform`, add a JS based one.
+        if (!ctx.mozCurrentTransform) {
+          ctx._originalSave = ctx.save;
+          ctx._originalRestore = ctx.restore;
+          ctx._originalRotate = ctx.rotate;
+          ctx._originalScale = ctx.scale;
+          ctx._originalTranslate = ctx.translate;
+          ctx._originalTransform = ctx.transform;
+          ctx._originalSetTransform = ctx.setTransform;
+          ctx._transformMatrix = ctx._transformMatrix || [
+            1,
+            0,
+            0,
+            1,
+            0,
+            0
+          ];
+          ctx._transformStack = [];
+          Object.defineProperty(ctx, 'mozCurrentTransform', {
+            get: function getCurrentTransform() {
+              return this._transformMatrix;
+            }
+          });
+          Object.defineProperty(ctx, 'mozCurrentTransformInverse', {
+            get: function getCurrentTransformInverse() {
+              // Calculation done using WolframAlpha:
+              // http://www.wolframalpha.com/input/?
+              //   i=Inverse+{{a%2C+c%2C+e}%2C+{b%2C+d%2C+f}%2C+{0%2C+0%2C+1}}
+              var m = this._transformMatrix;
+              var a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
+              var ad_bc = a * d - b * c;
+              var bc_ad = b * c - a * d;
+              return [
+                d / ad_bc,
+                b / bc_ad,
+                c / bc_ad,
+                a / ad_bc,
+                (d * e - c * f) / bc_ad,
+                (b * e - a * f) / ad_bc
+              ];
+            }
+          });
+          ctx.save = function ctxSave() {
+            var old = this._transformMatrix;
+            this._transformStack.push(old);
+            this._transformMatrix = old.slice(0, 6);
+            this._originalSave();
+          };
+          ctx.restore = function ctxRestore() {
+            var prev = this._transformStack.pop();
+            if (prev) {
+              this._transformMatrix = prev;
+              this._originalRestore();
+            }
+          };
+          ctx.translate = function ctxTranslate(x, y) {
+            var m = this._transformMatrix;
+            m[4] = m[0] * x + m[2] * y + m[4];
+            m[5] = m[1] * x + m[3] * y + m[5];
+            this._originalTranslate(x, y);
+          };
+          ctx.scale = function ctxScale(x, y) {
+            var m = this._transformMatrix;
+            m[0] = m[0] * x;
+            m[1] = m[1] * x;
+            m[2] = m[2] * y;
+            m[3] = m[3] * y;
+            this._originalScale(x, y);
+          };
+          ctx.transform = function ctxTransform(a, b, c, d, e, f) {
+            var m = this._transformMatrix;
+            this._transformMatrix = [
+              m[0] * a + m[2] * b,
+              m[1] * a + m[3] * b,
+              m[0] * c + m[2] * d,
+              m[1] * c + m[3] * d,
+              m[0] * e + m[2] * f + m[4],
+              m[1] * e + m[3] * f + m[5]
+            ];
+            ctx._originalTransform(a, b, c, d, e, f);
+          };
+          ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
+            this._transformMatrix = [
+              a,
+              b,
+              c,
+              d,
+              e,
+              f
+            ];
+            ctx._originalSetTransform(a, b, c, d, e, f);
+          };
+          ctx.rotate = function ctxRotate(angle) {
+            var cosValue = Math.cos(angle);
+            var sinValue = Math.sin(angle);
+            var m = this._transformMatrix;
+            this._transformMatrix = [
+              m[0] * cosValue + m[2] * sinValue,
+              m[1] * cosValue + m[3] * sinValue,
+              m[0] * -sinValue + m[2] * cosValue,
+              m[1] * -sinValue + m[3] * cosValue,
+              m[4],
+              m[5]
+            ];
+            this._originalRotate(angle);
+          };
+        }
+      }
+      var CachedCanvases = function CachedCanvasesClosure() {
+        function CachedCanvases() {
+          this.cache = Object.create(null);
+        }
+        CachedCanvases.prototype = {
+          getCanvas: function CachedCanvases_getCanvas(id, width, height, trackTransform) {
+            var canvasEntry;
+            if (this.cache[id] !== undefined) {
+              canvasEntry = this.cache[id];
+              canvasEntry.canvas.width = width;
+              canvasEntry.canvas.height = height;
+              // reset canvas transform for emulated mozCurrentTransform, if needed
+              canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);
+            } else {
+              var canvas = createScratchCanvas(width, height);
+              var ctx = canvas.getContext('2d');
+              if (trackTransform) {
+                addContextCurrentTransform(ctx);
+              }
+              this.cache[id] = canvasEntry = {
+                canvas: canvas,
+                context: ctx
+              };
+            }
+            return canvasEntry;
+          },
+          clear: function () {
+            for (var id in this.cache) {
+              var canvasEntry = this.cache[id];
+              // Zeroing the width and height causes Firefox to release graphics
+              // resources immediately, which can greatly reduce memory consumption.
+              canvasEntry.canvas.width = 0;
+              canvasEntry.canvas.height = 0;
+              delete this.cache[id];
+            }
+          }
+        };
+        return CachedCanvases;
+      }();
+      function compileType3Glyph(imgData) {
+        var POINT_TO_PROCESS_LIMIT = 1000;
+        var width = imgData.width, height = imgData.height;
+        var i, j, j0, width1 = width + 1;
+        var points = new Uint8Array(width1 * (height + 1));
+        var POINT_TYPES = new Uint8Array([
+          0,
+          2,
+          4,
+          0,
+          1,
+          0,
+          5,
+          4,
+          8,
+          10,
+          0,
+          8,
+          0,
+          2,
+          1,
+          0
+        ]);
+        // decodes bit-packed mask data
+        var lineSize = width + 7 & ~7, data0 = imgData.data;
+        var data = new Uint8Array(lineSize * height), pos = 0, ii;
+        for (i = 0, ii = data0.length; i < ii; i++) {
+          var mask = 128, elem = data0[i];
+          while (mask > 0) {
+            data[pos++] = elem & mask ? 0 : 255;
+            mask >>= 1;
+          }
+        }
+        // finding iteresting points: every point is located between mask pixels,
+        // so there will be points of the (width + 1)x(height + 1) grid. Every point
+        // will have flags assigned based on neighboring mask pixels:
+        //   4 | 8
+        //   --P--
+        //   2 | 1
+        // We are interested only in points with the flags:
+        //   - outside corners: 1, 2, 4, 8;
+        //   - inside corners: 7, 11, 13, 14;
+        //   - and, intersections: 5, 10.
+        var count = 0;
+        pos = 0;
+        if (data[pos] !== 0) {
+          points[0] = 1;
+          ++count;
+        }
+        for (j = 1; j < width; j++) {
+          if (data[pos] !== data[pos + 1]) {
+            points[j] = data[pos] ? 2 : 1;
+            ++count;
+          }
+          pos++;
+        }
+        if (data[pos] !== 0) {
+          points[j] = 2;
+          ++count;
+        }
+        for (i = 1; i < height; i++) {
+          pos = i * lineSize;
+          j0 = i * width1;
+          if (data[pos - lineSize] !== data[pos]) {
+            points[j0] = data[pos] ? 1 : 8;
+            ++count;
+          }
+          // 'sum' is the position of the current pixel configuration in the 'TYPES'
+          // array (in order 8-1-2-4, so we can use '>>2' to shift the column).
+          var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
+          for (j = 1; j < width; j++) {
+            sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
+            if (POINT_TYPES[sum]) {
+              points[j0 + j] = POINT_TYPES[sum];
+              ++count;
+            }
+            pos++;
+          }
+          if (data[pos - lineSize] !== data[pos]) {
+            points[j0 + j] = data[pos] ? 2 : 4;
+            ++count;
+          }
+          if (count > POINT_TO_PROCESS_LIMIT) {
+            return null;
+          }
+        }
+        pos = lineSize * (height - 1);
+        j0 = i * width1;
+        if (data[pos] !== 0) {
+          points[j0] = 8;
+          ++count;
+        }
+        for (j = 1; j < width; j++) {
+          if (data[pos] !== data[pos + 1]) {
+            points[j0 + j] = data[pos] ? 4 : 8;
+            ++count;
+          }
+          pos++;
+        }
+        if (data[pos] !== 0) {
+          points[j0 + j] = 4;
+          ++count;
+        }
+        if (count > POINT_TO_PROCESS_LIMIT) {
+          return null;
+        }
+        // building outlines
+        var steps = new Int32Array([
+          0,
+          width1,
+          -1,
+          0,
+          -width1,
+          0,
+          0,
+          0,
+          1
+        ]);
+        var outlines = [];
+        for (i = 0; count && i <= height; i++) {
+          var p = i * width1;
+          var end = p + width;
+          while (p < end && !points[p]) {
+            p++;
+          }
+          if (p === end) {
+            continue;
+          }
+          var coords = [
+            p % width1,
+            i
+          ];
+          var type = points[p], p0 = p, pp;
+          do {
+            var step = steps[type];
+            do {
+              p += step;
+            } while (!points[p]);
+            pp = points[p];
+            if (pp !== 5 && pp !== 10) {
+              // set new direction
+              type = pp;
+              // delete mark
+              points[p] = 0;
+            } else {
+              // type is 5 or 10, ie, a crossing
+              // set new direction
+              type = pp & 0x33 * type >> 4;
+              // set new type for "future hit"
+              points[p] &= type >> 2 | type << 2;
+            }
+            coords.push(p % width1);
+            coords.push(p / width1 | 0);
+            --count;
+          } while (p0 !== p);
+          outlines.push(coords);
+          --i;
+        }
+        var drawOutline = function (c) {
+          c.save();
+          // the path shall be painted in [0..1]x[0..1] space
+          c.scale(1 / width, -1 / height);
+          c.translate(0, -height);
+          c.beginPath();
+          for (var i = 0, ii = outlines.length; i < ii; i++) {
+            var o = outlines[i];
+            c.moveTo(o[0], o[1]);
+            for (var j = 2, jj = o.length; j < jj; j += 2) {
+              c.lineTo(o[j], o[j + 1]);
+            }
+          }
+          c.fill();
+          c.beginPath();
+          c.restore();
+        };
+        return drawOutline;
+      }
+      var CanvasExtraState = function CanvasExtraStateClosure() {
+        function CanvasExtraState(old) {
+          // Are soft masks and alpha values shapes or opacities?
+          this.alphaIsShape = false;
+          this.fontSize = 0;
+          this.fontSizeScale = 1;
+          this.textMatrix = IDENTITY_MATRIX;
+          this.textMatrixScale = 1;
+          this.fontMatrix = FONT_IDENTITY_MATRIX;
+          this.leading = 0;
+          // Current point (in user coordinates)
+          this.x = 0;
+          this.y = 0;
+          // Start of text line (in text coordinates)
+          this.lineX = 0;
+          this.lineY = 0;
+          // Character and word spacing
+          this.charSpacing = 0;
+          this.wordSpacing = 0;
+          this.textHScale = 1;
+          this.textRenderingMode = TextRenderingMode.FILL;
+          this.textRise = 0;
+          // Default fore and background colors
+          this.fillColor = '#000000';
+          this.strokeColor = '#000000';
+          this.patternFill = false;
+          // Note: fill alpha applies to all non-stroking operations
+          this.fillAlpha = 1;
+          this.strokeAlpha = 1;
+          this.lineWidth = 1;
+          this.activeSMask = null;
+          this.resumeSMaskCtx = null;
+          // nonclonable field (see the save method below)
+          this.old = old;
+        }
+        CanvasExtraState.prototype = {
+          clone: function CanvasExtraState_clone() {
+            return Object.create(this);
+          },
+          setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {
+            this.x = x;
+            this.y = y;
+          }
+        };
+        return CanvasExtraState;
+      }();
+      var CanvasGraphics = function CanvasGraphicsClosure() {
+        // Defines the time the executeOperatorList is going to be executing
+        // before it stops and shedules a continue of execution.
+        var EXECUTION_TIME = 15;
+        // Defines the number of steps before checking the execution time
+        var EXECUTION_STEPS = 10;
+        function CanvasGraphics(canvasCtx, commonObjs, objs, imageLayer) {
+          this.ctx = canvasCtx;
+          this.current = new CanvasExtraState();
+          this.stateStack = [];
+          this.pendingClip = null;
+          this.pendingEOFill = false;
+          this.res = null;
+          this.xobjs = null;
+          this.commonObjs = commonObjs;
+          this.objs = objs;
+          this.imageLayer = imageLayer;
+          this.groupStack = [];
+          this.processingType3 = null;
+          // Patterns are painted relative to the initial page/form transform, see pdf
+          // spec 8.7.2 NOTE 1.
+          this.baseTransform = null;
+          this.baseTransformStack = [];
+          this.groupLevel = 0;
+          this.smaskStack = [];
+          this.smaskCounter = 0;
+          this.tempSMask = null;
+          this.cachedCanvases = new CachedCanvases();
+          if (canvasCtx) {
+            // NOTE: if mozCurrentTransform is polyfilled, then the current state of
+            // the transformation must already be set in canvasCtx._transformMatrix.
+            addContextCurrentTransform(canvasCtx);
+          }
+          this.cachedGetSinglePixelWidth = null;
+        }
+        function putBinaryImageData(ctx, imgData) {
+          if (typeof ImageData !== 'undefined' && imgData instanceof ImageData) {
+            ctx.putImageData(imgData, 0, 0);
+            return;
+          }
+          // Put the image data to the canvas in chunks, rather than putting the
+          // whole image at once.  This saves JS memory, because the ImageData object
+          // is smaller. It also possibly saves C++ memory within the implementation
+          // of putImageData(). (E.g. in Firefox we make two short-lived copies of
+          // the data passed to putImageData()). |n| shouldn't be too small, however,
+          // because too many putImageData() calls will slow things down.
+          //
+          // Note: as written, if the last chunk is partial, the putImageData() call
+          // will (conceptually) put pixels past the bounds of the canvas.  But
+          // that's ok; any such pixels are ignored.
+          var height = imgData.height, width = imgData.width;
+          var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
+          var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
+          var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
+          var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
+          var srcPos = 0, destPos;
+          var src = imgData.data;
+          var dest = chunkImgData.data;
+          var i, j, thisChunkHeight, elemsInThisChunk;
+          // There are multiple forms in which the pixel data can be passed, and
+          // imgData.kind tells us which one this is.
+          if (imgData.kind === ImageKind.GRAYSCALE_1BPP) {
+            // Grayscale, 1 bit per pixel (i.e. black-and-white).
+            var srcLength = src.byteLength;
+            var dest32 = HasCanvasTypedArraysCached.value ? new Uint32Array(dest.buffer) : new Uint32ArrayView(dest);
+            var dest32DataLength = dest32.length;
+            var fullSrcDiff = width + 7 >> 3;
+            var white = 0xFFFFFFFF;
+            var black = IsLittleEndianCached.value || !HasCanvasTypedArraysCached.value ? 0xFF000000 : 0x000000FF;
+            for (i = 0; i < totalChunks; i++) {
+              thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
+              destPos = 0;
+              for (j = 0; j < thisChunkHeight; j++) {
+                var srcDiff = srcLength - srcPos;
+                var k = 0;
+                var kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;
+                var kEndUnrolled = kEnd & ~7;
+                var mask = 0;
+                var srcByte = 0;
+                for (; k < kEndUnrolled; k += 8) {
+                  srcByte = src[srcPos++];
+                  dest32[destPos++] = srcByte & 128 ? white : black;
+                  dest32[destPos++] = srcByte & 64 ? white : black;
+                  dest32[destPos++] = srcByte & 32 ? white : black;
+                  dest32[destPos++] = srcByte & 16 ? white : black;
+                  dest32[destPos++] = srcByte & 8 ? white : black;
+                  dest32[destPos++] = srcByte & 4 ? white : black;
+                  dest32[destPos++] = srcByte & 2 ? white : black;
+                  dest32[destPos++] = srcByte & 1 ? white : black;
+                }
+                for (; k < kEnd; k++) {
+                  if (mask === 0) {
+                    srcByte = src[srcPos++];
+                    mask = 128;
+                  }
+                  dest32[destPos++] = srcByte & mask ? white : black;
+                  mask >>= 1;
+                }
+              }
+              // We ran out of input. Make all remaining pixels transparent.
+              while (destPos < dest32DataLength) {
+                dest32[destPos++] = 0;
+              }
+              ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+            }
+          } else if (imgData.kind === ImageKind.RGBA_32BPP) {
+            // RGBA, 32-bits per pixel.
+            j = 0;
+            elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;
+            for (i = 0; i < fullChunks; i++) {
+              dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
+              srcPos += elemsInThisChunk;
+              ctx.putImageData(chunkImgData, 0, j);
+              j += FULL_CHUNK_HEIGHT;
+            }
+            if (i < totalChunks) {
+              elemsInThisChunk = width * partialChunkHeight * 4;
+              dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
+              ctx.putImageData(chunkImgData, 0, j);
+            }
+          } else if (imgData.kind === ImageKind.RGB_24BPP) {
+            // RGB, 24-bits per pixel.
+            thisChunkHeight = FULL_CHUNK_HEIGHT;
+            elemsInThisChunk = width * thisChunkHeight;
+            for (i = 0; i < totalChunks; i++) {
+              if (i >= fullChunks) {
+                thisChunkHeight = partialChunkHeight;
+                elemsInThisChunk = width * thisChunkHeight;
+              }
+              destPos = 0;
+              for (j = elemsInThisChunk; j--;) {
+                dest[destPos++] = src[srcPos++];
+                dest[destPos++] = src[srcPos++];
+                dest[destPos++] = src[srcPos++];
+                dest[destPos++] = 255;
+              }
+              ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+            }
+          } else {
+            error('bad image kind: ' + imgData.kind);
+          }
+        }
+        function putBinaryImageMask(ctx, imgData) {
+          var height = imgData.height, width = imgData.width;
+          var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
+          var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
+          var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
+          var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
+          var srcPos = 0;
+          var src = imgData.data;
+          var dest = chunkImgData.data;
+          for (var i = 0; i < totalChunks; i++) {
+            var thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
+            // Expand the mask so it can be used by the canvas.  Any required
+            // inversion has already been handled.
+            var destPos = 3;
+            // alpha component offset
+            for (var j = 0; j < thisChunkHeight; j++) {
+              var mask = 0;
+              for (var k = 0; k < width; k++) {
+                if (!mask) {
+                  var elem = src[srcPos++];
+                  mask = 128;
+                }
+                dest[destPos] = elem & mask ? 0 : 255;
+                destPos += 4;
+                mask >>= 1;
+              }
+            }
+            ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
+          }
+        }
+        function copyCtxState(sourceCtx, destCtx) {
+          var properties = [
+            'strokeStyle',
+            'fillStyle',
+            'fillRule',
+            'globalAlpha',
+            'lineWidth',
+            'lineCap',
+            'lineJoin',
+            'miterLimit',
+            'globalCompositeOperation',
+            'font'
+          ];
+          for (var i = 0, ii = properties.length; i < ii; i++) {
+            var property = properties[i];
+            if (sourceCtx[property] !== undefined) {
+              destCtx[property] = sourceCtx[property];
+            }
+          }
+          if (sourceCtx.setLineDash !== undefined) {
+            destCtx.setLineDash(sourceCtx.getLineDash());
+            destCtx.lineDashOffset = sourceCtx.lineDashOffset;
+          }
+        }
+        function composeSMaskBackdrop(bytes, r0, g0, b0) {
+          var length = bytes.length;
+          for (var i = 3; i < length; i += 4) {
+            var alpha = bytes[i];
+            if (alpha === 0) {
+              bytes[i - 3] = r0;
+              bytes[i - 2] = g0;
+              bytes[i - 1] = b0;
+            } else if (alpha < 255) {
+              var alpha_ = 255 - alpha;
+              bytes[i - 3] = bytes[i - 3] * alpha + r0 * alpha_ >> 8;
+              bytes[i - 2] = bytes[i - 2] * alpha + g0 * alpha_ >> 8;
+              bytes[i - 1] = bytes[i - 1] * alpha + b0 * alpha_ >> 8;
+            }
+          }
+        }
+        function composeSMaskAlpha(maskData, layerData, transferMap) {
+          var length = maskData.length;
+          var scale = 1 / 255;
+          for (var i = 3; i < length; i += 4) {
+            var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];
+            layerData[i] = layerData[i] * alpha * scale | 0;
+          }
+        }
+        function composeSMaskLuminosity(maskData, layerData, transferMap) {
+          var length = maskData.length;
+          for (var i = 3; i < length; i += 4) {
+            var y = maskData[i - 3] * 77 + // * 0.3 / 255 * 0x10000
+            maskData[i - 2] * 152 + // * 0.59 ....
+            maskData[i - 1] * 28;
+            // * 0.11 ....
+            layerData[i] = transferMap ? layerData[i] * transferMap[y >> 8] >> 8 : layerData[i] * y >> 16;
+          }
+        }
+        function genericComposeSMask(maskCtx, layerCtx, width, height, subtype, backdrop, transferMap) {
+          var hasBackdrop = !!backdrop;
+          var r0 = hasBackdrop ? backdrop[0] : 0;
+          var g0 = hasBackdrop ? backdrop[1] : 0;
+          var b0 = hasBackdrop ? backdrop[2] : 0;
+          var composeFn;
+          if (subtype === 'Luminosity') {
+            composeFn = composeSMaskLuminosity;
+          } else {
+            composeFn = composeSMaskAlpha;
+          }
+          // processing image in chunks to save memory
+          var PIXELS_TO_PROCESS = 1048576;
+          var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));
+          for (var row = 0; row < height; row += chunkSize) {
+            var chunkHeight = Math.min(chunkSize, height - row);
+            var maskData = maskCtx.getImageData(0, row, width, chunkHeight);
+            var layerData = layerCtx.getImageData(0, row, width, chunkHeight);
+            if (hasBackdrop) {
+              composeSMaskBackdrop(maskData.data, r0, g0, b0);
+            }
+            composeFn(maskData.data, layerData.data, transferMap);
+            maskCtx.putImageData(layerData, 0, row);
+          }
+        }
+        function composeSMask(ctx, smask, layerCtx) {
+          var mask = smask.canvas;
+          var maskCtx = smask.context;
+          ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, smask.offsetX, smask.offsetY);
+          var backdrop = smask.backdrop || null;
+          if (!smask.transferMap && WebGLUtils.isEnabled) {
+            var composed = WebGLUtils.composeSMask(layerCtx.canvas, mask, {
+              subtype: smask.subtype,
+              backdrop: backdrop
+            });
+            ctx.setTransform(1, 0, 0, 1, 0, 0);
+            ctx.drawImage(composed, smask.offsetX, smask.offsetY);
+            return;
+          }
+          genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, smask.subtype, backdrop, smask.transferMap);
+          ctx.drawImage(mask, 0, 0);
+        }
+        var LINE_CAP_STYLES = [
+          'butt',
+          'round',
+          'square'
+        ];
+        var LINE_JOIN_STYLES = [
+          'miter',
+          'round',
+          'bevel'
+        ];
+        var NORMAL_CLIP = {};
+        var EO_CLIP = {};
+        CanvasGraphics.prototype = {
+          beginDrawing: function CanvasGraphics_beginDrawing(transform, viewport, transparency) {
+            // For pdfs that use blend modes we have to clear the canvas else certain
+            // blend modes can look wrong since we'd be blending with a white
+            // backdrop. The problem with a transparent backdrop though is we then
+            // don't get sub pixel anti aliasing on text, creating temporary
+            // transparent canvas when we have blend modes.
+            var width = this.ctx.canvas.width;
+            var height = this.ctx.canvas.height;
+            this.ctx.save();
+            this.ctx.fillStyle = 'rgb(255, 255, 255)';
+            this.ctx.fillRect(0, 0, width, height);
+            this.ctx.restore();
+            if (transparency) {
+              var transparentCanvas = this.cachedCanvases.getCanvas('transparent', width, height, true);
+              this.compositeCtx = this.ctx;
+              this.transparentCanvas = transparentCanvas.canvas;
+              this.ctx = transparentCanvas.context;
+              this.ctx.save();
+              // The transform can be applied before rendering, transferring it to
+              // the new canvas.
+              this.ctx.transform.apply(this.ctx, this.compositeCtx.mozCurrentTransform);
+            }
+            this.ctx.save();
+            if (transform) {
+              this.ctx.transform.apply(this.ctx, transform);
+            }
+            this.ctx.transform.apply(this.ctx, viewport.transform);
+            this.baseTransform = this.ctx.mozCurrentTransform.slice();
+            if (this.imageLayer) {
+              this.imageLayer.beginLayout();
+            }
+          },
+          executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
+            var argsArray = operatorList.argsArray;
+            var fnArray = operatorList.fnArray;
+            var i = executionStartIdx || 0;
+            var argsArrayLen = argsArray.length;
+            // Sometimes the OperatorList to execute is empty.
+            if (argsArrayLen === i) {
+              return i;
+            }
+            var chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof continueCallback === 'function';
+            var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
+            var steps = 0;
+            var commonObjs = this.commonObjs;
+            var objs = this.objs;
+            var fnId;
+            while (true) {
+              if (stepper !== undefined && i === stepper.nextBreakPoint) {
+                stepper.breakIt(i, continueCallback);
+                return i;
+              }
+              fnId = fnArray[i];
+              if (fnId !== OPS.dependency) {
+                this[fnId].apply(this, argsArray[i]);
+              } else {
+                var deps = argsArray[i];
+                for (var n = 0, nn = deps.length; n < nn; n++) {
+                  var depObjId = deps[n];
+                  var common = depObjId[0] === 'g' && depObjId[1] === '_';
+                  var objsPool = common ? commonObjs : objs;
+                  // If the promise isn't resolved yet, add the continueCallback
+                  // to the promise and bail out.
+                  if (!objsPool.isResolved(depObjId)) {
+                    objsPool.get(depObjId, continueCallback);
+                    return i;
+                  }
+                }
+              }
+              i++;
+              // If the entire operatorList was executed, stop as were done.
+              if (i === argsArrayLen) {
+                return i;
+              }
+              // If the execution took longer then a certain amount of time and
+              // `continueCallback` is specified, interrupt the execution.
+              if (chunkOperations && ++steps > EXECUTION_STEPS) {
+                if (Date.now() > endTime) {
+                  continueCallback();
+                  return i;
+                }
+                steps = 0;
+              }
+            }
+          },
+          // If the operatorList isn't executed completely yet OR the execution
+          // time was short enough, do another execution round.
+          endDrawing: function CanvasGraphics_endDrawing() {
+            // Finishing all opened operations such as SMask group painting.
+            if (this.current.activeSMask !== null) {
+              this.endSMaskGroup();
+            }
+            this.ctx.restore();
+            if (this.transparentCanvas) {
+              this.ctx = this.compositeCtx;
+              this.ctx.save();
+              this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+              // Avoid apply transform twice
+              this.ctx.drawImage(this.transparentCanvas, 0, 0);
+              this.ctx.restore();
+              this.transparentCanvas = null;
+            }
+            this.cachedCanvases.clear();
+            WebGLUtils.clear();
+            if (this.imageLayer) {
+              this.imageLayer.endLayout();
+            }
+          },
+          // Graphics state
+          setLineWidth: function CanvasGraphics_setLineWidth(width) {
+            this.current.lineWidth = width;
+            this.ctx.lineWidth = width;
+          },
+          setLineCap: function CanvasGraphics_setLineCap(style) {
+            this.ctx.lineCap = LINE_CAP_STYLES[style];
+          },
+          setLineJoin: function CanvasGraphics_setLineJoin(style) {
+            this.ctx.lineJoin = LINE_JOIN_STYLES[style];
+          },
+          setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {
+            this.ctx.miterLimit = limit;
+          },
+          setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
+            var ctx = this.ctx;
+            if (ctx.setLineDash !== undefined) {
+              ctx.setLineDash(dashArray);
+              ctx.lineDashOffset = dashPhase;
+            }
+          },
+          setRenderingIntent: function CanvasGraphics_setRenderingIntent(intent) {
+          },
+          setFlatness: function CanvasGraphics_setFlatness(flatness) {
+          },
+          setGState: function CanvasGraphics_setGState(states) {
+            for (var i = 0, ii = states.length; i < ii; i++) {
+              var state = states[i];
+              var key = state[0];
+              var value = state[1];
+              switch (key) {
+              case 'LW':
+                this.setLineWidth(value);
+                break;
+              case 'LC':
+                this.setLineCap(value);
+                break;
+              case 'LJ':
+                this.setLineJoin(value);
+                break;
+              case 'ML':
+                this.setMiterLimit(value);
+                break;
+              case 'D':
+                this.setDash(value[0], value[1]);
+                break;
+              case 'RI':
+                this.setRenderingIntent(value);
+                break;
+              case 'FL':
+                this.setFlatness(value);
+                break;
+              case 'Font':
+                this.setFont(value[0], value[1]);
+                break;
+              case 'CA':
+                this.current.strokeAlpha = state[1];
+                break;
+              case 'ca':
+                this.current.fillAlpha = state[1];
+                this.ctx.globalAlpha = state[1];
+                break;
+              case 'BM':
+                if (value && value.name && value.name !== 'Normal') {
+                  var mode = value.name.replace(/([A-Z])/g, function (c) {
+                    return '-' + c.toLowerCase();
+                  }).substring(1);
+                  this.ctx.globalCompositeOperation = mode;
+                  if (this.ctx.globalCompositeOperation !== mode) {
+                    warn('globalCompositeOperation "' + mode + '" is not supported');
+                  }
+                } else {
+                  this.ctx.globalCompositeOperation = 'source-over';
+                }
+                break;
+              case 'SMask':
+                if (this.current.activeSMask) {
+                  // If SMask is currrenly used, it needs to be suspended or
+                  // finished. Suspend only makes sense when at least one save()
+                  // was performed and state needs to be reverted on restore().
+                  if (this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1].activeSMask === this.current.activeSMask) {
+                    this.suspendSMaskGroup();
+                  } else {
+                    this.endSMaskGroup();
+                  }
+                }
+                this.current.activeSMask = value ? this.tempSMask : null;
+                if (this.current.activeSMask) {
+                  this.beginSMaskGroup();
+                }
+                this.tempSMask = null;
+                break;
+              }
+            }
+          },
+          beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {
+            var activeSMask = this.current.activeSMask;
+            var drawnWidth = activeSMask.canvas.width;
+            var drawnHeight = activeSMask.canvas.height;
+            var cacheId = 'smaskGroupAt' + this.groupLevel;
+            var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
+            var currentCtx = this.ctx;
+            var currentTransform = currentCtx.mozCurrentTransform;
+            this.ctx.save();
+            var groupCtx = scratchCanvas.context;
+            groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);
+            groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);
+            groupCtx.transform.apply(groupCtx, currentTransform);
+            activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;
+            copyCtxState(currentCtx, groupCtx);
+            this.ctx = groupCtx;
+            this.setGState([
+              [
+                'BM',
+                'Normal'
+              ],
+              [
+                'ca',
+                1
+              ],
+              [
+                'CA',
+                1
+              ]
+            ]);
+            this.groupStack.push(currentCtx);
+            this.groupLevel++;
+          },
+          suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {
+            // Similar to endSMaskGroup, the intermediate canvas has to be composed
+            // and future ctx state restored.
+            var groupCtx = this.ctx;
+            this.groupLevel--;
+            this.ctx = this.groupStack.pop();
+            composeSMask(this.ctx, this.current.activeSMask, groupCtx);
+            this.ctx.restore();
+            this.ctx.save();
+            // save is needed since SMask will be resumed.
+            copyCtxState(groupCtx, this.ctx);
+            // Saving state for resuming.
+            this.current.resumeSMaskCtx = groupCtx;
+            // Transform was changed in the SMask canvas, reflecting this change on
+            // this.ctx.
+            var deltaTransform = Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+            this.ctx.transform.apply(this.ctx, deltaTransform);
+            // SMask was composed, the results at the groupCtx can be cleared.
+            groupCtx.save();
+            groupCtx.setTransform(1, 0, 0, 1, 0, 0);
+            groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);
+            groupCtx.restore();
+          },
+          resumeSMaskGroup: function CanvasGraphics_endSMaskGroup() {
+            // Resuming state saved by suspendSMaskGroup. We don't need to restore
+            // any groupCtx state since restore() command (the only caller) will do
+            // that for us. See also beginSMaskGroup.
+            var groupCtx = this.current.resumeSMaskCtx;
+            var currentCtx = this.ctx;
+            this.ctx = groupCtx;
+            this.groupStack.push(currentCtx);
+            this.groupLevel++;
+          },
+          endSMaskGroup: function CanvasGraphics_endSMaskGroup() {
+            var groupCtx = this.ctx;
+            this.groupLevel--;
+            this.ctx = this.groupStack.pop();
+            composeSMask(this.ctx, this.current.activeSMask, groupCtx);
+            this.ctx.restore();
+            copyCtxState(groupCtx, this.ctx);
+            // Transform was changed in the SMask canvas, reflecting this change on
+            // this.ctx.
+            var deltaTransform = Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+            this.ctx.transform.apply(this.ctx, deltaTransform);
+          },
+          save: function CanvasGraphics_save() {
+            this.ctx.save();
+            var old = this.current;
+            this.stateStack.push(old);
+            this.current = old.clone();
+            this.current.resumeSMaskCtx = null;
+          },
+          restore: function CanvasGraphics_restore() {
+            // SMask was suspended, we just need to resume it.
+            if (this.current.resumeSMaskCtx) {
+              this.resumeSMaskGroup();
+            }
+            // SMask has to be finished once there is no states that are using the
+            // same SMask.
+            if (this.current.activeSMask !== null && (this.stateStack.length === 0 || this.stateStack[this.stateStack.length - 1].activeSMask !== this.current.activeSMask)) {
+              this.endSMaskGroup();
+            }
+            if (this.stateStack.length !== 0) {
+              this.current = this.stateStack.pop();
+              this.ctx.restore();
+              // Ensure that the clipping path is reset (fixes issue6413.pdf).
+              this.pendingClip = null;
+              this.cachedGetSinglePixelWidth = null;
+            }
+          },
+          transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
+            this.ctx.transform(a, b, c, d, e, f);
+            this.cachedGetSinglePixelWidth = null;
+          },
+          // Path
+          constructPath: function CanvasGraphics_constructPath(ops, args) {
+            var ctx = this.ctx;
+            var current = this.current;
+            var x = current.x, y = current.y;
+            for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {
+              switch (ops[i] | 0) {
+              case OPS.rectangle:
+                x = args[j++];
+                y = args[j++];
+                var width = args[j++];
+                var height = args[j++];
+                if (width === 0) {
+                  width = this.getSinglePixelWidth();
+                }
+                if (height === 0) {
+                  height = this.getSinglePixelWidth();
+                }
+                var xw = x + width;
+                var yh = y + height;
+                this.ctx.moveTo(x, y);
+                this.ctx.lineTo(xw, y);
+                this.ctx.lineTo(xw, yh);
+                this.ctx.lineTo(x, yh);
+                this.ctx.lineTo(x, y);
+                this.ctx.closePath();
+                break;
+              case OPS.moveTo:
+                x = args[j++];
+                y = args[j++];
+                ctx.moveTo(x, y);
+                break;
+              case OPS.lineTo:
+                x = args[j++];
+                y = args[j++];
+                ctx.lineTo(x, y);
+                break;
+              case OPS.curveTo:
+                x = args[j + 4];
+                y = args[j + 5];
+                ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x, y);
+                j += 6;
+                break;
+              case OPS.curveTo2:
+                ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], args[j + 3]);
+                x = args[j + 2];
+                y = args[j + 3];
+                j += 4;
+                break;
+              case OPS.curveTo3:
+                x = args[j + 2];
+                y = args[j + 3];
+                ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
+                j += 4;
+                break;
+              case OPS.closePath:
+                ctx.closePath();
+                break;
+              }
+            }
+            current.setCurrentPoint(x, y);
+          },
+          closePath: function CanvasGraphics_closePath() {
+            this.ctx.closePath();
+          },
+          stroke: function CanvasGraphics_stroke(consumePath) {
+            consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
+            var ctx = this.ctx;
+            var strokeColor = this.current.strokeColor;
+            // Prevent drawing too thin lines by enforcing a minimum line width.
+            ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth);
+            // For stroke we want to temporarily change the global alpha to the
+            // stroking alpha.
+            ctx.globalAlpha = this.current.strokeAlpha;
+            if (strokeColor && strokeColor.hasOwnProperty('type') && strokeColor.type === 'Pattern') {
+              // for patterns, we transform to pattern space, calculate
+              // the pattern, call stroke, and restore to user space
+              ctx.save();
+              ctx.strokeStyle = strokeColor.getPattern(ctx, this);
+              ctx.stroke();
+              ctx.restore();
+            } else {
+              ctx.stroke();
+            }
+            if (consumePath) {
+              this.consumePath();
+            }
+            // Restore the global alpha to the fill alpha
+            ctx.globalAlpha = this.current.fillAlpha;
+          },
+          closeStroke: function CanvasGraphics_closeStroke() {
+            this.closePath();
+            this.stroke();
+          },
+          fill: function CanvasGraphics_fill(consumePath) {
+            consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
+            var ctx = this.ctx;
+            var fillColor = this.current.fillColor;
+            var isPatternFill = this.current.patternFill;
+            var needRestore = false;
+            if (isPatternFill) {
+              ctx.save();
+              if (this.baseTransform) {
+                ctx.setTransform.apply(ctx, this.baseTransform);
+              }
+              ctx.fillStyle = fillColor.getPattern(ctx, this);
+              needRestore = true;
+            }
+            if (this.pendingEOFill) {
+              if (ctx.mozFillRule !== undefined) {
+                ctx.mozFillRule = 'evenodd';
+                ctx.fill();
+                ctx.mozFillRule = 'nonzero';
+              } else {
+                ctx.fill('evenodd');
+              }
+              this.pendingEOFill = false;
+            } else {
+              ctx.fill();
+            }
+            if (needRestore) {
+              ctx.restore();
+            }
+            if (consumePath) {
+              this.consumePath();
+            }
+          },
+          eoFill: function CanvasGraphics_eoFill() {
+            this.pendingEOFill = true;
+            this.fill();
+          },
+          fillStroke: function CanvasGraphics_fillStroke() {
+            this.fill(false);
+            this.stroke(false);
+            this.consumePath();
+          },
+          eoFillStroke: function CanvasGraphics_eoFillStroke() {
+            this.pendingEOFill = true;
+            this.fillStroke();
+          },
+          closeFillStroke: function CanvasGraphics_closeFillStroke() {
+            this.closePath();
+            this.fillStroke();
+          },
+          closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {
+            this.pendingEOFill = true;
+            this.closePath();
+            this.fillStroke();
+          },
+          endPath: function CanvasGraphics_endPath() {
+            this.consumePath();
+          },
+          // Clipping
+          clip: function CanvasGraphics_clip() {
+            this.pendingClip = NORMAL_CLIP;
+          },
+          eoClip: function CanvasGraphics_eoClip() {
+            this.pendingClip = EO_CLIP;
+          },
+          // Text
+          beginText: function CanvasGraphics_beginText() {
+            this.current.textMatrix = IDENTITY_MATRIX;
+            this.current.textMatrixScale = 1;
+            this.current.x = this.current.lineX = 0;
+            this.current.y = this.current.lineY = 0;
+          },
+          endText: function CanvasGraphics_endText() {
+            var paths = this.pendingTextPaths;
+            var ctx = this.ctx;
+            if (paths === undefined) {
+              ctx.beginPath();
+              return;
+            }
+            ctx.save();
+            ctx.beginPath();
+            for (var i = 0; i < paths.length; i++) {
+              var path = paths[i];
+              ctx.setTransform.apply(ctx, path.transform);
+              ctx.translate(path.x, path.y);
+              path.addToPath(ctx, path.fontSize);
+            }
+            ctx.restore();
+            ctx.clip();
+            ctx.beginPath();
+            delete this.pendingTextPaths;
+          },
+          setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {
+            this.current.charSpacing = spacing;
+          },
+          setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {
+            this.current.wordSpacing = spacing;
+          },
+          setHScale: function CanvasGraphics_setHScale(scale) {
+            this.current.textHScale = scale / 100;
+          },
+          setLeading: function CanvasGraphics_setLeading(leading) {
+            this.current.leading = -leading;
+          },
+          setFont: function CanvasGraphics_setFont(fontRefName, size) {
+            var fontObj = this.commonObjs.get(fontRefName);
+            var current = this.current;
+            if (!fontObj) {
+              error('Can\'t find font for ' + fontRefName);
+            }
+            current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : FONT_IDENTITY_MATRIX;
+            // A valid matrix needs all main diagonal elements to be non-zero
+            // This also ensures we bypass FF bugzilla bug #719844.
+            if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
+              warn('Invalid font matrix for font ' + fontRefName);
+            }
+            // The spec for Tf (setFont) says that 'size' specifies the font 'scale',
+            // and in some docs this can be negative (inverted x-y axes).
+            if (size < 0) {
+              size = -size;
+              current.fontDirection = -1;
+            } else {
+              current.fontDirection = 1;
+            }
+            this.current.font = fontObj;
+            this.current.fontSize = size;
+            if (fontObj.isType3Font) {
+              return;
+            }
+            // we don't need ctx.font for Type3 fonts
+            var name = fontObj.loadedName || 'sans-serif';
+            var bold = fontObj.black ? fontObj.bold ? '900' : 'bold' : fontObj.bold ? 'bold' : 'normal';
+            var italic = fontObj.italic ? 'italic' : 'normal';
+            var typeface = '"' + name + '", ' + fontObj.fallbackName;
+            // Some font backends cannot handle fonts below certain size.
+            // Keeping the font at minimal size and using the fontSizeScale to change
+            // the current transformation matrix before the fillText/strokeText.
+            // See https://bugzilla.mozilla.org/show_bug.cgi?id=726227
+            var browserFontSize = size < MIN_FONT_SIZE ? MIN_FONT_SIZE : size > MAX_FONT_SIZE ? MAX_FONT_SIZE : size;
+            this.current.fontSizeScale = size / browserFontSize;
+            var rule = italic + ' ' + bold + ' ' + browserFontSize + 'px ' + typeface;
+            this.ctx.font = rule;
+          },
+          setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
+            this.current.textRenderingMode = mode;
+          },
+          setTextRise: function CanvasGraphics_setTextRise(rise) {
+            this.current.textRise = rise;
+          },
+          moveText: function CanvasGraphics_moveText(x, y) {
+            this.current.x = this.current.lineX += x;
+            this.current.y = this.current.lineY += y;
+          },
+          setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {
+            this.setLeading(-y);
+            this.moveText(x, y);
+          },
+          setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {
+            this.current.textMatrix = [
+              a,
+              b,
+              c,
+              d,
+              e,
+              f
+            ];
+            this.current.textMatrixScale = Math.sqrt(a * a + b * b);
+            this.current.x = this.current.lineX = 0;
+            this.current.y = this.current.lineY = 0;
+          },
+          nextLine: function CanvasGraphics_nextLine() {
+            this.moveText(0, this.current.leading);
+          },
+          paintChar: function CanvasGraphics_paintChar(character, x, y) {
+            var ctx = this.ctx;
+            var current = this.current;
+            var font = current.font;
+            var textRenderingMode = current.textRenderingMode;
+            var fontSize = current.fontSize / current.fontSizeScale;
+            var fillStrokeMode = textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;
+            var isAddToPathSet = !!(textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG);
+            var addToPath;
+            if (font.disableFontFace || isAddToPathSet) {
+              addToPath = font.getPathGenerator(this.commonObjs, character);
+            }
+            if (font.disableFontFace) {
+              ctx.save();
+              ctx.translate(x, y);
+              ctx.beginPath();
+              addToPath(ctx, fontSize);
+              if (fillStrokeMode === TextRenderingMode.FILL || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
+                ctx.fill();
+              }
+              if (fillStrokeMode === TextRenderingMode.STROKE || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
+                ctx.stroke();
+              }
+              ctx.restore();
+            } else {
+              if (fillStrokeMode === TextRenderingMode.FILL || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
+                ctx.fillText(character, x, y);
+              }
+              if (fillStrokeMode === TextRenderingMode.STROKE || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
+                ctx.strokeText(character, x, y);
+              }
+            }
+            if (isAddToPathSet) {
+              var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
+              paths.push({
+                transform: ctx.mozCurrentTransform,
+                x: x,
+                y: y,
+                fontSize: fontSize,
+                addToPath: addToPath
+              });
+            }
+          },
+          get isFontSubpixelAAEnabled() {
+            // Checks if anti-aliasing is enabled when scaled text is painted.
+            // On Windows GDI scaled fonts looks bad.
+            var ctx = document.createElement('canvas').getContext('2d');
+            ctx.scale(1.5, 1);
+            ctx.fillText('I', 0, 10);
+            var data = ctx.getImageData(0, 0, 10, 10).data;
+            var enabled = false;
+            for (var i = 3; i < data.length; i += 4) {
+              if (data[i] > 0 && data[i] < 255) {
+                enabled = true;
+                break;
+              }
+            }
+            return shadow(this, 'isFontSubpixelAAEnabled', enabled);
+          },
+          showText: function CanvasGraphics_showText(glyphs) {
+            var current = this.current;
+            var font = current.font;
+            if (font.isType3Font) {
+              return this.showType3Text(glyphs);
+            }
+            var fontSize = current.fontSize;
+            if (fontSize === 0) {
+              return;
+            }
+            var ctx = this.ctx;
+            var fontSizeScale = current.fontSizeScale;
+            var charSpacing = current.charSpacing;
+            var wordSpacing = current.wordSpacing;
+            var fontDirection = current.fontDirection;
+            var textHScale = current.textHScale * fontDirection;
+            var glyphsLength = glyphs.length;
+            var vertical = font.vertical;
+            var spacingDir = vertical ? 1 : -1;
+            var defaultVMetrics = font.defaultVMetrics;
+            var widthAdvanceScale = fontSize * current.fontMatrix[0];
+            var simpleFillText = current.textRenderingMode === TextRenderingMode.FILL && !font.disableFontFace;
+            ctx.save();
+            ctx.transform.apply(ctx, current.textMatrix);
+            ctx.translate(current.x, current.y + current.textRise);
+            if (current.patternFill) {
+              // TODO: Some shading patterns are not applied correctly to text,
+              //       e.g. issues 3988 and 5432, and ShowText-ShadingPattern.pdf.
+              ctx.fillStyle = current.fillColor.getPattern(ctx, this);
+            }
+            if (fontDirection > 0) {
+              ctx.scale(textHScale, -1);
+            } else {
+              ctx.scale(textHScale, 1);
+            }
+            var lineWidth = current.lineWidth;
+            var scale = current.textMatrixScale;
+            if (scale === 0 || lineWidth === 0) {
+              var fillStrokeMode = current.textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;
+              if (fillStrokeMode === TextRenderingMode.STROKE || fillStrokeMode === TextRenderingMode.FILL_STROKE) {
+                this.cachedGetSinglePixelWidth = null;
+                lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;
+              }
+            } else {
+              lineWidth /= scale;
+            }
+            if (fontSizeScale !== 1.0) {
+              ctx.scale(fontSizeScale, fontSizeScale);
+              lineWidth /= fontSizeScale;
+            }
+            ctx.lineWidth = lineWidth;
+            var x = 0, i;
+            for (i = 0; i < glyphsLength; ++i) {
+              var glyph = glyphs[i];
+              if (isNum(glyph)) {
+                x += spacingDir * glyph * fontSize / 1000;
+                continue;
+              }
+              var restoreNeeded = false;
+              var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
+              var character = glyph.fontChar;
+              var accent = glyph.accent;
+              var scaledX, scaledY, scaledAccentX, scaledAccentY;
+              var width = glyph.width;
+              if (vertical) {
+                var vmetric, vx, vy;
+                vmetric = glyph.vmetric || defaultVMetrics;
+                vx = glyph.vmetric ? vmetric[1] : width * 0.5;
+                vx = -vx * widthAdvanceScale;
+                vy = vmetric[2] * widthAdvanceScale;
+                width = vmetric ? -vmetric[0] : width;
+                scaledX = vx / fontSizeScale;
+                scaledY = (x + vy) / fontSizeScale;
+              } else {
+                scaledX = x / fontSizeScale;
+                scaledY = 0;
+              }
+              if (font.remeasure && width > 0) {
+                // Some standard fonts may not have the exact width: rescale per
+                // character if measured width is greater than expected glyph width
+                // and subpixel-aa is enabled, otherwise just center the glyph.
+                var measuredWidth = ctx.measureText(character).width * 1000 / fontSize * fontSizeScale;
+                if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
+                  var characterScaleX = width / measuredWidth;
+                  restoreNeeded = true;
+                  ctx.save();
+                  ctx.scale(characterScaleX, 1);
+                  scaledX /= characterScaleX;
+                } else if (width !== measuredWidth) {
+                  scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
+                }
+              }
+              // Only attempt to draw the glyph if it is actually in the embedded font
+              // file or if there isn't a font file so the fallback font is shown.
+              if (glyph.isInFont || font.missingFile) {
+                if (simpleFillText && !accent) {
+                  // common case
+                  ctx.fillText(character, scaledX, scaledY);
+                } else {
+                  this.paintChar(character, scaledX, scaledY);
+                  if (accent) {
+                    scaledAccentX = scaledX + accent.offset.x / fontSizeScale;
+                    scaledAccentY = scaledY - accent.offset.y / fontSizeScale;
+                    this.paintChar(accent.fontChar, scaledAccentX, scaledAccentY);
+                  }
+                }
+              }
+              var charWidth = width * widthAdvanceScale + spacing * fontDirection;
+              x += charWidth;
+              if (restoreNeeded) {
+                ctx.restore();
+              }
+            }
+            if (vertical) {
+              current.y -= x * textHScale;
+            } else {
+              current.x += x * textHScale;
+            }
+            ctx.restore();
+          },
+          showType3Text: function CanvasGraphics_showType3Text(glyphs) {
+            // Type3 fonts - each glyph is a "mini-PDF"
+            var ctx = this.ctx;
+            var current = this.current;
+            var font = current.font;
+            var fontSize = current.fontSize;
+            var fontDirection = current.fontDirection;
+            var spacingDir = font.vertical ? 1 : -1;
+            var charSpacing = current.charSpacing;
+            var wordSpacing = current.wordSpacing;
+            var textHScale = current.textHScale * fontDirection;
+            var fontMatrix = current.fontMatrix || FONT_IDENTITY_MATRIX;
+            var glyphsLength = glyphs.length;
+            var isTextInvisible = current.textRenderingMode === TextRenderingMode.INVISIBLE;
+            var i, glyph, width, spacingLength;
+            if (isTextInvisible || fontSize === 0) {
+              return;
+            }
+            this.cachedGetSinglePixelWidth = null;
+            ctx.save();
+            ctx.transform.apply(ctx, current.textMatrix);
+            ctx.translate(current.x, current.y);
+            ctx.scale(textHScale, fontDirection);
+            for (i = 0; i < glyphsLength; ++i) {
+              glyph = glyphs[i];
+              if (isNum(glyph)) {
+                spacingLength = spacingDir * glyph * fontSize / 1000;
+                this.ctx.translate(spacingLength, 0);
+                current.x += spacingLength * textHScale;
+                continue;
+              }
+              var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
+              var operatorList = font.charProcOperatorList[glyph.operatorListId];
+              if (!operatorList) {
+                warn('Type3 character \"' + glyph.operatorListId + '\" is not available');
+                continue;
+              }
+              this.processingType3 = glyph;
+              this.save();
+              ctx.scale(fontSize, fontSize);
+              ctx.transform.apply(ctx, fontMatrix);
+              this.executeOperatorList(operatorList);
+              this.restore();
+              var transformed = Util.applyTransform([
+                glyph.width,
+                0
+              ], fontMatrix);
+              width = transformed[0] * fontSize + spacing;
+              ctx.translate(width, 0);
+              current.x += width * textHScale;
+            }
+            ctx.restore();
+            this.processingType3 = null;
+          },
+          // Type3 fonts
+          setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {
+          },
+          setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {
+            // TODO According to the spec we're also suppose to ignore any operators
+            // that set color or include images while processing this type3 font.
+            this.ctx.rect(llx, lly, urx - llx, ury - lly);
+            this.clip();
+            this.endPath();
+          },
+          // Color
+          getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
+            var pattern;
+            if (IR[0] === 'TilingPattern') {
+              var color = IR[1];
+              var baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice();
+              var self = this;
+              var canvasGraphicsFactory = {
+                createCanvasGraphics: function (ctx) {
+                  return new CanvasGraphics(ctx, self.commonObjs, self.objs);
+                }
+              };
+              pattern = new TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform);
+            } else {
+              pattern = getShadingPatternFromIR(IR);
+            }
+            return pattern;
+          },
+          setStrokeColorN: function CanvasGraphics_setStrokeColorN()
+            /*...*/
+            {
+              this.current.strokeColor = this.getColorN_Pattern(arguments);
+            },
+          setFillColorN: function CanvasGraphics_setFillColorN()
+            /*...*/
+            {
+              this.current.fillColor = this.getColorN_Pattern(arguments);
+              this.current.patternFill = true;
+            },
+          setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
+            var color = Util.makeCssRgb(r, g, b);
+            this.ctx.strokeStyle = color;
+            this.current.strokeColor = color;
+          },
+          setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
+            var color = Util.makeCssRgb(r, g, b);
+            this.ctx.fillStyle = color;
+            this.current.fillColor = color;
+            this.current.patternFill = false;
+          },
+          shadingFill: function CanvasGraphics_shadingFill(patternIR) {
+            var ctx = this.ctx;
+            this.save();
+            var pattern = getShadingPatternFromIR(patternIR);
+            ctx.fillStyle = pattern.getPattern(ctx, this, true);
+            var inv = ctx.mozCurrentTransformInverse;
+            if (inv) {
+              var canvas = ctx.canvas;
+              var width = canvas.width;
+              var height = canvas.height;
+              var bl = Util.applyTransform([
+                0,
+                0
+              ], inv);
+              var br = Util.applyTransform([
+                0,
+                height
+              ], inv);
+              var ul = Util.applyTransform([
+                width,
+                0
+              ], inv);
+              var ur = Util.applyTransform([
+                width,
+                height
+              ], inv);
+              var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
+              var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
+              var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
+              var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
+              this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
+            } else {
+              // HACK to draw the gradient onto an infinite rectangle.
+              // PDF gradients are drawn across the entire image while
+              // Canvas only allows gradients to be drawn in a rectangle
+              // The following bug should allow us to remove this.
+              // https://bugzilla.mozilla.org/show_bug.cgi?id=664884
+              this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
+            }
+            this.restore();
+          },
+          // Images
+          beginInlineImage: function CanvasGraphics_beginInlineImage() {
+            error('Should not call beginInlineImage');
+          },
+          beginImageData: function CanvasGraphics_beginImageData() {
+            error('Should not call beginImageData');
+          },
+          paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, bbox) {
+            this.save();
+            this.baseTransformStack.push(this.baseTransform);
+            if (isArray(matrix) && 6 === matrix.length) {
+              this.transform.apply(this, matrix);
+            }
+            this.baseTransform = this.ctx.mozCurrentTransform;
+            if (isArray(bbox) && 4 === bbox.length) {
+              var width = bbox[2] - bbox[0];
+              var height = bbox[3] - bbox[1];
+              this.ctx.rect(bbox[0], bbox[1], width, height);
+              this.clip();
+              this.endPath();
+            }
+          },
+          paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {
+            this.restore();
+            this.baseTransform = this.baseTransformStack.pop();
+          },
+          beginGroup: function CanvasGraphics_beginGroup(group) {
+            this.save();
+            var currentCtx = this.ctx;
+            // TODO non-isolated groups - according to Rik at adobe non-isolated
+            // group results aren't usually that different and they even have tools
+            // that ignore this setting. Notes from Rik on implementing:
+            // - When you encounter an transparency group, create a new canvas with
+            // the dimensions of the bbox
+            // - copy the content from the previous canvas to the new canvas
+            // - draw as usual
+            // - remove the backdrop alpha:
+            // alphaNew = 1 - (1 - alpha)/(1 - alphaBackdrop) with 'alpha' the alpha
+            // value of your transparency group and 'alphaBackdrop' the alpha of the
+            // backdrop
+            // - remove background color:
+            // colorNew = color - alphaNew *colorBackdrop /(1 - alphaNew)
+            if (!group.isolated) {
+              info('TODO: Support non-isolated groups.');
+            }
+            // TODO knockout - supposedly possible with the clever use of compositing
+            // modes.
+            if (group.knockout) {
+              warn('Knockout groups not supported.');
+            }
+            var currentTransform = currentCtx.mozCurrentTransform;
+            if (group.matrix) {
+              currentCtx.transform.apply(currentCtx, group.matrix);
+            }
+            assert(group.bbox, 'Bounding box is required.');
+            // Based on the current transform figure out how big the bounding box
+            // will actually be.
+            var bounds = Util.getAxialAlignedBoundingBox(group.bbox, currentCtx.mozCurrentTransform);
+            // Clip the bounding box to the current canvas.
+            var canvasBounds = [
+              0,
+              0,
+              currentCtx.canvas.width,
+              currentCtx.canvas.height
+            ];
+            bounds = Util.intersect(bounds, canvasBounds) || [
+              0,
+              0,
+              0,
+              0
+            ];
+            // Use ceil in case we're between sizes so we don't create canvas that is
+            // too small and make the canvas at least 1x1 pixels.
+            var offsetX = Math.floor(bounds[0]);
+            var offsetY = Math.floor(bounds[1]);
+            var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);
+            var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
+            var scaleX = 1, scaleY = 1;
+            if (drawnWidth > MAX_GROUP_SIZE) {
+              scaleX = drawnWidth / MAX_GROUP_SIZE;
+              drawnWidth = MAX_GROUP_SIZE;
+            }
+            if (drawnHeight > MAX_GROUP_SIZE) {
+              scaleY = drawnHeight / MAX_GROUP_SIZE;
+              drawnHeight = MAX_GROUP_SIZE;
+            }
+            var cacheId = 'groupAt' + this.groupLevel;
+            if (group.smask) {
+              // Using two cache entries is case if masks are used one after another.
+              cacheId += '_smask_' + this.smaskCounter++ % 2;
+            }
+            var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
+            var groupCtx = scratchCanvas.context;
+            // Since we created a new canvas that is just the size of the bounding box
+            // we have to translate the group ctx.
+            groupCtx.scale(1 / scaleX, 1 / scaleY);
+            groupCtx.translate(-offsetX, -offsetY);
+            groupCtx.transform.apply(groupCtx, currentTransform);
+            if (group.smask) {
+              // Saving state and cached mask to be used in setGState.
+              this.smaskStack.push({
+                canvas: scratchCanvas.canvas,
+                context: groupCtx,
+                offsetX: offsetX,
+                offsetY: offsetY,
+                scaleX: scaleX,
+                scaleY: scaleY,
+                subtype: group.smask.subtype,
+                backdrop: group.smask.backdrop,
+                transferMap: group.smask.transferMap || null,
+                startTransformInverse: null
+              });
+            } else
+              // used during suspend operation
+              {
+                // Setup the current ctx so when the group is popped we draw it at the
+                // right location.
+                currentCtx.setTransform(1, 0, 0, 1, 0, 0);
+                currentCtx.translate(offsetX, offsetY);
+                currentCtx.scale(scaleX, scaleY);
+              }
+            // The transparency group inherits all off the current graphics state
+            // except the blend mode, soft mask, and alpha constants.
+            copyCtxState(currentCtx, groupCtx);
+            this.ctx = groupCtx;
+            this.setGState([
+              [
+                'BM',
+                'Normal'
+              ],
+              [
+                'ca',
+                1
+              ],
+              [
+                'CA',
+                1
+              ]
+            ]);
+            this.groupStack.push(currentCtx);
+            this.groupLevel++;
+            // Reseting mask state, masks will be applied on restore of the group.
+            this.current.activeSMask = null;
+          },
+          endGroup: function CanvasGraphics_endGroup(group) {
+            this.groupLevel--;
+            var groupCtx = this.ctx;
+            this.ctx = this.groupStack.pop();
+            // Turn off image smoothing to avoid sub pixel interpolation which can
+            // look kind of blurry for some pdfs.
+            if (this.ctx.imageSmoothingEnabled !== undefined) {
+              this.ctx.imageSmoothingEnabled = false;
+            } else {
+              this.ctx.mozImageSmoothingEnabled = false;
+            }
+            if (group.smask) {
+              this.tempSMask = this.smaskStack.pop();
+            } else {
+              this.ctx.drawImage(groupCtx.canvas, 0, 0);
+            }
+            this.restore();
+          },
+          beginAnnotations: function CanvasGraphics_beginAnnotations() {
+            this.save();
+            this.current = new CanvasExtraState();
+            if (this.baseTransform) {
+              this.ctx.setTransform.apply(this.ctx, this.baseTransform);
+            }
+          },
+          endAnnotations: function CanvasGraphics_endAnnotations() {
+            this.restore();
+          },
+          beginAnnotation: function CanvasGraphics_beginAnnotation(rect, transform, matrix) {
+            this.save();
+            if (isArray(rect) && 4 === rect.length) {
+              var width = rect[2] - rect[0];
+              var height = rect[3] - rect[1];
+              this.ctx.rect(rect[0], rect[1], width, height);
+              this.clip();
+              this.endPath();
+            }
+            this.transform.apply(this, transform);
+            this.transform.apply(this, matrix);
+          },
+          endAnnotation: function CanvasGraphics_endAnnotation() {
+            this.restore();
+          },
+          paintJpegXObject: function CanvasGraphics_paintJpegXObject(objId, w, h) {
+            var domImage = this.objs.get(objId);
+            if (!domImage) {
+              warn('Dependent image isn\'t ready yet');
+              return;
+            }
+            this.save();
+            var ctx = this.ctx;
+            // scale the image to the unit square
+            ctx.scale(1 / w, -1 / h);
+            ctx.drawImage(domImage, 0, 0, domImage.width, domImage.height, 0, -h, w, h);
+            if (this.imageLayer) {
+              var currentTransform = ctx.mozCurrentTransformInverse;
+              var position = this.getCanvasPosition(0, 0);
+              this.imageLayer.appendImage({
+                objId: objId,
+                left: position[0],
+                top: position[1],
+                width: w / currentTransform[0],
+                height: h / currentTransform[3]
+              });
+            }
+            this.restore();
+          },
+          paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
+            var ctx = this.ctx;
+            var width = img.width, height = img.height;
+            var fillColor = this.current.fillColor;
+            var isPatternFill = this.current.patternFill;
+            var glyph = this.processingType3;
+            if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
+              if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
+                glyph.compiled = compileType3Glyph({
+                  data: img.data,
+                  width: width,
+                  height: height
+                });
+              } else {
+                glyph.compiled = null;
+              }
+            }
+            if (glyph && glyph.compiled) {
+              glyph.compiled(ctx);
+              return;
+            }
+            var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
+            var maskCtx = maskCanvas.context;
+            maskCtx.save();
+            putBinaryImageMask(maskCtx, img);
+            maskCtx.globalCompositeOperation = 'source-in';
+            maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
+            maskCtx.fillRect(0, 0, width, height);
+            maskCtx.restore();
+            this.paintInlineImageXObject(maskCanvas.canvas);
+          },
+          paintImageMaskXObjectRepeat: function CanvasGraphics_paintImageMaskXObjectRepeat(imgData, scaleX, scaleY, positions) {
+            var width = imgData.width;
+            var height = imgData.height;
+            var fillColor = this.current.fillColor;
+            var isPatternFill = this.current.patternFill;
+            var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
+            var maskCtx = maskCanvas.context;
+            maskCtx.save();
+            putBinaryImageMask(maskCtx, imgData);
+            maskCtx.globalCompositeOperation = 'source-in';
+            maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
+            maskCtx.fillRect(0, 0, width, height);
+            maskCtx.restore();
+            var ctx = this.ctx;
+            for (var i = 0, ii = positions.length; i < ii; i += 2) {
+              ctx.save();
+              ctx.transform(scaleX, 0, 0, scaleY, positions[i], positions[i + 1]);
+              ctx.scale(1, -1);
+              ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
+              ctx.restore();
+            }
+          },
+          paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(images) {
+            var ctx = this.ctx;
+            var fillColor = this.current.fillColor;
+            var isPatternFill = this.current.patternFill;
+            for (var i = 0, ii = images.length; i < ii; i++) {
+              var image = images[i];
+              var width = image.width, height = image.height;
+              var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
+              var maskCtx = maskCanvas.context;
+              maskCtx.save();
+              putBinaryImageMask(maskCtx, image);
+              maskCtx.globalCompositeOperation = 'source-in';
+              maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
+              maskCtx.fillRect(0, 0, width, height);
+              maskCtx.restore();
+              ctx.save();
+              ctx.transform.apply(ctx, image.transform);
+              ctx.scale(1, -1);
+              ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
+              ctx.restore();
+            }
+          },
+          paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
+            var imgData = this.objs.get(objId);
+            if (!imgData) {
+              warn('Dependent image isn\'t ready yet');
+              return;
+            }
+            this.paintInlineImageXObject(imgData);
+          },
+          paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
+            var imgData = this.objs.get(objId);
+            if (!imgData) {
+              warn('Dependent image isn\'t ready yet');
+              return;
+            }
+            var width = imgData.width;
+            var height = imgData.height;
+            var map = [];
+            for (var i = 0, ii = positions.length; i < ii; i += 2) {
+              map.push({
+                transform: [
+                  scaleX,
+                  0,
+                  0,
+                  scaleY,
+                  positions[i],
+                  positions[i + 1]
+                ],
+                x: 0,
+                y: 0,
+                w: width,
+                h: height
+              });
+            }
+            this.paintInlineImageXObjectGroup(imgData, map);
+          },
+          paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(imgData) {
+            var width = imgData.width;
+            var height = imgData.height;
+            var ctx = this.ctx;
+            this.save();
+            // scale the image to the unit square
+            ctx.scale(1 / width, -1 / height);
+            var currentTransform = ctx.mozCurrentTransformInverse;
+            var a = currentTransform[0], b = currentTransform[1];
+            var widthScale = Math.max(Math.sqrt(a * a + b * b), 1);
+            var c = currentTransform[2], d = currentTransform[3];
+            var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);
+            var imgToPaint, tmpCanvas;
+            // instanceof HTMLElement does not work in jsdom node.js module
+            if (imgData instanceof HTMLElement || !imgData.data) {
+              imgToPaint = imgData;
+            } else {
+              tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', width, height);
+              var tmpCtx = tmpCanvas.context;
+              putBinaryImageData(tmpCtx, imgData);
+              imgToPaint = tmpCanvas.canvas;
+            }
+            var paintWidth = width, paintHeight = height;
+            var tmpCanvasId = 'prescale1';
+            // Vertial or horizontal scaling shall not be more than 2 to not loose the
+            // pixels during drawImage operation, painting on the temporary canvas(es)
+            // that are twice smaller in size
+            while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight > 1) {
+              var newWidth = paintWidth, newHeight = paintHeight;
+              if (widthScale > 2 && paintWidth > 1) {
+                newWidth = Math.ceil(paintWidth / 2);
+                widthScale /= paintWidth / newWidth;
+              }
+              if (heightScale > 2 && paintHeight > 1) {
+                newHeight = Math.ceil(paintHeight / 2);
+                heightScale /= paintHeight / newHeight;
+              }
+              tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth, newHeight);
+              tmpCtx = tmpCanvas.context;
+              tmpCtx.clearRect(0, 0, newWidth, newHeight);
+              tmpCtx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, 0, newWidth, newHeight);
+              imgToPaint = tmpCanvas.canvas;
+              paintWidth = newWidth;
+              paintHeight = newHeight;
+              tmpCanvasId = tmpCanvasId === 'prescale1' ? 'prescale2' : 'prescale1';
+            }
+            ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width, height);
+            if (this.imageLayer) {
+              var position = this.getCanvasPosition(0, -height);
+              this.imageLayer.appendImage({
+                imgData: imgData,
+                left: position[0],
+                top: position[1],
+                width: width / currentTransform[0],
+                height: height / currentTransform[3]
+              });
+            }
+            this.restore();
+          },
+          paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
+            var ctx = this.ctx;
+            var w = imgData.width;
+            var h = imgData.height;
+            var tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', w, h);
+            var tmpCtx = tmpCanvas.context;
+            putBinaryImageData(tmpCtx, imgData);
+            for (var i = 0, ii = map.length; i < ii; i++) {
+              var entry = map[i];
+              ctx.save();
+              ctx.transform.apply(ctx, entry.transform);
+              ctx.scale(1, -1);
+              ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
+              if (this.imageLayer) {
+                var position = this.getCanvasPosition(entry.x, entry.y);
+                this.imageLayer.appendImage({
+                  imgData: imgData,
+                  left: position[0],
+                  top: position[1],
+                  width: w,
+                  height: h
+                });
+              }
+              ctx.restore();
+            }
+          },
+          paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {
+            this.ctx.fillRect(0, 0, 1, 1);
+          },
+          paintXObject: function CanvasGraphics_paintXObject() {
+            warn('Unsupported \'paintXObject\' command.');
+          },
+          // Marked content
+          markPoint: function CanvasGraphics_markPoint(tag) {
+          },
+          markPointProps: function CanvasGraphics_markPointProps(tag, properties) {
+          },
+          beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {
+          },
+          beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(tag, properties) {
+          },
+          endMarkedContent: function CanvasGraphics_endMarkedContent() {
+          },
+          // Compatibility
+          beginCompat: function CanvasGraphics_beginCompat() {
+          },
+          endCompat: function CanvasGraphics_endCompat() {
+          },
+          // Helper functions
+          consumePath: function CanvasGraphics_consumePath() {
+            var ctx = this.ctx;
+            if (this.pendingClip) {
+              if (this.pendingClip === EO_CLIP) {
+                if (ctx.mozFillRule !== undefined) {
+                  ctx.mozFillRule = 'evenodd';
+                  ctx.clip();
+                  ctx.mozFillRule = 'nonzero';
+                } else {
+                  ctx.clip('evenodd');
+                }
+              } else {
+                ctx.clip();
+              }
+              this.pendingClip = null;
+            }
+            ctx.beginPath();
+          },
+          getSinglePixelWidth: function CanvasGraphics_getSinglePixelWidth(scale) {
+            if (this.cachedGetSinglePixelWidth === null) {
+              // NOTE: The `save` and `restore` commands used below is a workaround
+              // that is necessary in order to prevent `mozCurrentTransformInverse`
+              // from intermittently returning incorrect values in Firefox, see:
+              // https://github.com/mozilla/pdf.js/issues/7188.
+              this.ctx.save();
+              var inverse = this.ctx.mozCurrentTransformInverse;
+              this.ctx.restore();
+              // max of the current horizontal and vertical scale
+              this.cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
+            }
+            return this.cachedGetSinglePixelWidth;
+          },
+          getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
+            var transform = this.ctx.mozCurrentTransform;
+            return [
+              transform[0] * x + transform[2] * y + transform[4],
+              transform[1] * x + transform[3] * y + transform[5]
+            ];
+          }
+        };
+        for (var op in OPS) {
+          CanvasGraphics.prototype[OPS[op]] = CanvasGraphics.prototype[op];
+        }
+        return CanvasGraphics;
+      }();
+      exports.CanvasGraphics = CanvasGraphics;
+      exports.createScratchCanvas = createScratchCanvas;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayAPI = {}, root.pdfjsSharedUtil, root.pdfjsDisplayFontLoader, root.pdfjsDisplayCanvas, root.pdfjsDisplayMetadata, root.pdfjsDisplayDOMUtils);
+    }(this, function (exports, sharedUtil, displayFontLoader, displayCanvas, displayMetadata, displayDOMUtils, amdRequire) {
+      var InvalidPDFException = sharedUtil.InvalidPDFException;
+      var MessageHandler = sharedUtil.MessageHandler;
+      var MissingPDFException = sharedUtil.MissingPDFException;
+      var PageViewport = sharedUtil.PageViewport;
+      var PasswordResponses = sharedUtil.PasswordResponses;
+      var PasswordException = sharedUtil.PasswordException;
+      var StatTimer = sharedUtil.StatTimer;
+      var UnexpectedResponseException = sharedUtil.UnexpectedResponseException;
+      var UnknownErrorException = sharedUtil.UnknownErrorException;
+      var Util = sharedUtil.Util;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var error = sharedUtil.error;
+      var deprecated = sharedUtil.deprecated;
+      var getVerbosityLevel = sharedUtil.getVerbosityLevel;
+      var info = sharedUtil.info;
+      var isInt = sharedUtil.isInt;
+      var isArray = sharedUtil.isArray;
+      var isArrayBuffer = sharedUtil.isArrayBuffer;
+      var isSameOrigin = sharedUtil.isSameOrigin;
+      var loadJpegStream = sharedUtil.loadJpegStream;
+      var stringToBytes = sharedUtil.stringToBytes;
+      var globalScope = sharedUtil.globalScope;
+      var warn = sharedUtil.warn;
+      var FontFaceObject = displayFontLoader.FontFaceObject;
+      var FontLoader = displayFontLoader.FontLoader;
+      var CanvasGraphics = displayCanvas.CanvasGraphics;
+      var createScratchCanvas = displayCanvas.createScratchCanvas;
+      var Metadata = displayMetadata.Metadata;
+      var getDefaultSetting = displayDOMUtils.getDefaultSetting;
+      var DEFAULT_RANGE_CHUNK_SIZE = 65536;
+      // 2^16 = 65536
+      var isWorkerDisabled = false;
+      var workerSrc;
+      var isPostMessageTransfersDisabled = false;
+      var fakeWorkerFilesLoader = null;
+      var useRequireEnsure = false;
+      /**
+       * Document initialization / loading parameters object.
+       *
+       * @typedef {Object} DocumentInitParameters
+       * @property {string}     url   - The URL of the PDF.
+       * @property {TypedArray|Array|string} data - Binary PDF data. Use typed arrays
+       *   (Uint8Array) to improve the memory usage. If PDF data is BASE64-encoded,
+       *   use atob() to convert it to a binary string first.
+       * @property {Object}     httpHeaders - Basic authentication headers.
+       * @property {boolean}    withCredentials - Indicates whether or not cross-site
+       *   Access-Control requests should be made using credentials such as cookies
+       *   or authorization headers. The default is false.
+       * @property {string}     password - For decrypting password-protected PDFs.
+       * @property {TypedArray} initialData - A typed array with the first portion or
+       *   all of the pdf data. Used by the extension since some data is already
+       *   loaded before the switch to range requests.
+       * @property {number}     length - The PDF file length. It's used for progress
+       *   reports and range requests operations.
+       * @property {PDFDataRangeTransport} range
+       * @property {number}     rangeChunkSize - Optional parameter to specify
+       *   maximum number of bytes fetched per range request. The default value is
+       *   2^16 = 65536.
+       * @property {PDFWorker}  worker - The worker that will be used for the loading
+       *   and parsing of the PDF data.
+       * @property {string} docBaseUrl - (optional) The base URL of the document,
+       *   used when attempting to recover valid absolute URLs for annotations, and
+       *   outline items, that (incorrectly) only specify relative URLs.
+       */
+      /**
+       * @typedef {Object} PDFDocumentStats
+       * @property {Array} streamTypes - Used stream types in the document (an item
+       *   is set to true if specific stream ID was used in the document).
+       * @property {Array} fontTypes - Used font type in the document (an item is set
+       *   to true if specific font ID was used in the document).
+       */
+      /**
+       * This is the main entry point for loading a PDF and interacting with it.
+       * NOTE: If a URL is used to fetch the PDF data a standard XMLHttpRequest(XHR)
+       * is used, which means it must follow the same origin rules that any XHR does
+       * e.g. No cross domain requests without CORS.
+       *
+       * @param {string|TypedArray|DocumentInitParameters|PDFDataRangeTransport} src
+       * Can be a url to where a PDF is located, a typed array (Uint8Array)
+       * already populated with data or parameter object.
+       *
+       * @param {PDFDataRangeTransport} pdfDataRangeTransport (deprecated) It is used
+       * if you want to manually serve range requests for data in the PDF.
+       *
+       * @param {function} passwordCallback (deprecated) It is used to request a
+       * password if wrong or no password was provided. The callback receives two
+       * parameters: function that needs to be called with new password and reason
+       * (see {PasswordResponses}).
+       *
+       * @param {function} progressCallback (deprecated) It is used to be able to
+       * monitor the loading progress of the PDF file (necessary to implement e.g.
+       * a loading bar). The callback receives an {Object} with the properties:
+       * {number} loaded and {number} total.
+       *
+       * @return {PDFDocumentLoadingTask}
+       */
+      function getDocument(src, pdfDataRangeTransport, passwordCallback, progressCallback) {
+        var task = new PDFDocumentLoadingTask();
+        // Support of the obsolete arguments (for compatibility with API v1.0)
+        if (arguments.length > 1) {
+          deprecated('getDocument is called with pdfDataRangeTransport, ' + 'passwordCallback or progressCallback argument');
+        }
+        if (pdfDataRangeTransport) {
+          if (!(pdfDataRangeTransport instanceof PDFDataRangeTransport)) {
+            // Not a PDFDataRangeTransport instance, trying to add missing properties.
+            pdfDataRangeTransport = Object.create(pdfDataRangeTransport);
+            pdfDataRangeTransport.length = src.length;
+            pdfDataRangeTransport.initialData = src.initialData;
+            if (!pdfDataRangeTransport.abort) {
+              pdfDataRangeTransport.abort = function () {
+              };
+            }
+          }
+          src = Object.create(src);
+          src.range = pdfDataRangeTransport;
+        }
+        task.onPassword = passwordCallback || null;
+        task.onProgress = progressCallback || null;
+        var source;
+        if (typeof src === 'string') {
+          source = { url: src };
+        } else if (isArrayBuffer(src)) {
+          source = { data: src };
+        } else if (src instanceof PDFDataRangeTransport) {
+          source = { range: src };
+        } else {
+          if (typeof src !== 'object') {
+            error('Invalid parameter in getDocument, need either Uint8Array, ' + 'string or a parameter object');
+          }
+          if (!src.url && !src.data && !src.range) {
+            error('Invalid parameter object: need either .data, .range or .url');
+          }
+          source = src;
+        }
+        var params = {};
+        var rangeTransport = null;
+        var worker = null;
+        for (var key in source) {
+          if (key === 'url' && typeof window !== 'undefined') {
+            // The full path is required in the 'url' field.
+            params[key] = new URL(source[key], window.location).href;
+            continue;
+          } else if (key === 'range') {
+            rangeTransport = source[key];
+            continue;
+          } else if (key === 'worker') {
+            worker = source[key];
+            continue;
+          } else if (key === 'data' && !(source[key] instanceof Uint8Array)) {
+            // Converting string or array-like data to Uint8Array.
+            var pdfBytes = source[key];
+            if (typeof pdfBytes === 'string') {
+              params[key] = stringToBytes(pdfBytes);
+            } else if (typeof pdfBytes === 'object' && pdfBytes !== null && !isNaN(pdfBytes.length)) {
+              params[key] = new Uint8Array(pdfBytes);
+            } else if (isArrayBuffer(pdfBytes)) {
+              params[key] = new Uint8Array(pdfBytes);
+            } else {
+              error('Invalid PDF binary data: either typed array, string or ' + 'array-like object is expected in the data property.');
+            }
+            continue;
+          }
+          params[key] = source[key];
+        }
+        params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
+        if (!worker) {
+          // Worker was not provided -- creating and owning our own.
+          worker = new PDFWorker();
+          task._worker = worker;
+        }
+        var docId = task.docId;
+        worker.promise.then(function () {
+          if (task.destroyed) {
+            throw new Error('Loading aborted');
+          }
+          return _fetchDocument(worker, params, rangeTransport, docId).then(function (workerId) {
+            if (task.destroyed) {
+              throw new Error('Loading aborted');
+            }
+            var messageHandler = new MessageHandler(docId, workerId, worker.port);
+            var transport = new WorkerTransport(messageHandler, task, rangeTransport);
+            task._transport = transport;
+            messageHandler.send('Ready', null);
+          });
+        }).catch(task._capability.reject);
+        return task;
+      }
+      /**
+       * Starts fetching of specified PDF document/data.
+       * @param {PDFWorker} worker
+       * @param {Object} source
+       * @param {PDFDataRangeTransport} pdfDataRangeTransport
+       * @param {string} docId Unique document id, used as MessageHandler id.
+       * @returns {Promise} The promise, which is resolved when worker id of
+       *                    MessageHandler is known.
+       * @private
+       */
+      function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
+        if (worker.destroyed) {
+          return Promise.reject(new Error('Worker was destroyed'));
+        }
+        source.disableAutoFetch = getDefaultSetting('disableAutoFetch');
+        source.disableStream = getDefaultSetting('disableStream');
+        source.chunkedViewerLoading = !!pdfDataRangeTransport;
+        if (pdfDataRangeTransport) {
+          source.length = pdfDataRangeTransport.length;
+          source.initialData = pdfDataRangeTransport.initialData;
+        }
+        return worker.messageHandler.sendWithPromise('GetDocRequest', {
+          docId: docId,
+          source: source,
+          disableRange: getDefaultSetting('disableRange'),
+          maxImageSize: getDefaultSetting('maxImageSize'),
+          cMapUrl: getDefaultSetting('cMapUrl'),
+          cMapPacked: getDefaultSetting('cMapPacked'),
+          disableFontFace: getDefaultSetting('disableFontFace'),
+          disableCreateObjectURL: getDefaultSetting('disableCreateObjectURL'),
+          postMessageTransfers: getDefaultSetting('postMessageTransfers') && !isPostMessageTransfersDisabled,
+          docBaseUrl: source.docBaseUrl
+        }).then(function (workerId) {
+          if (worker.destroyed) {
+            throw new Error('Worker was destroyed');
+          }
+          return workerId;
+        });
+      }
+      /**
+       * PDF document loading operation.
+       * @class
+       * @alias PDFDocumentLoadingTask
+       */
+      var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
+        var nextDocumentId = 0;
+        /** @constructs PDFDocumentLoadingTask */
+        function PDFDocumentLoadingTask() {
+          this._capability = createPromiseCapability();
+          this._transport = null;
+          this._worker = null;
+          /**
+           * Unique document loading task id -- used in MessageHandlers.
+           * @type {string}
+           */
+          this.docId = 'd' + nextDocumentId++;
+          /**
+           * Shows if loading task is destroyed.
+           * @type {boolean}
+           */
+          this.destroyed = false;
+          /**
+           * Callback to request a password if wrong or no password was provided.
+           * The callback receives two parameters: function that needs to be called
+           * with new password and reason (see {PasswordResponses}).
+           */
+          this.onPassword = null;
+          /**
+           * Callback to be able to monitor the loading progress of the PDF file
+           * (necessary to implement e.g. a loading bar). The callback receives
+           * an {Object} with the properties: {number} loaded and {number} total.
+           */
+          this.onProgress = null;
+          /**
+           * Callback to when unsupported feature is used. The callback receives
+           * an {UNSUPPORTED_FEATURES} argument.
+           */
+          this.onUnsupportedFeature = null;
+        }
+        PDFDocumentLoadingTask.prototype = /** @lends PDFDocumentLoadingTask.prototype */
+        {
+          /**
+           * @return {Promise}
+           */
+          get promise() {
+            return this._capability.promise;
+          },
+          /**
+           * Aborts all network requests and destroys worker.
+           * @return {Promise} A promise that is resolved after destruction activity
+           *                   is completed.
+           */
+          destroy: function () {
+            this.destroyed = true;
+            var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
+            return transportDestroyed.then(function () {
+              this._transport = null;
+              if (this._worker) {
+                this._worker.destroy();
+                this._worker = null;
+              }
+            }.bind(this));
+          },
+          /**
+           * Registers callbacks to indicate the document loading completion.
+           *
+           * @param {function} onFulfilled The callback for the loading completion.
+           * @param {function} onRejected The callback for the loading failure.
+           * @return {Promise} A promise that is resolved after the onFulfilled or
+           *                   onRejected callback.
+           */
+          then: function PDFDocumentLoadingTask_then(onFulfilled, onRejected) {
+            return this.promise.then.apply(this.promise, arguments);
+          }
+        };
+        return PDFDocumentLoadingTask;
+      }();
+      /**
+       * Abstract class to support range requests file loading.
+       * @class
+       * @alias PDFDataRangeTransport
+       * @param {number} length
+       * @param {Uint8Array} initialData
+       */
+      var PDFDataRangeTransport = function pdfDataRangeTransportClosure() {
+        function PDFDataRangeTransport(length, initialData) {
+          this.length = length;
+          this.initialData = initialData;
+          this._rangeListeners = [];
+          this._progressListeners = [];
+          this._progressiveReadListeners = [];
+          this._readyCapability = createPromiseCapability();
+        }
+        PDFDataRangeTransport.prototype = /** @lends PDFDataRangeTransport.prototype */
+        {
+          addRangeListener: function PDFDataRangeTransport_addRangeListener(listener) {
+            this._rangeListeners.push(listener);
+          },
+          addProgressListener: function PDFDataRangeTransport_addProgressListener(listener) {
+            this._progressListeners.push(listener);
+          },
+          addProgressiveReadListener: function PDFDataRangeTransport_addProgressiveReadListener(listener) {
+            this._progressiveReadListeners.push(listener);
+          },
+          onDataRange: function PDFDataRangeTransport_onDataRange(begin, chunk) {
+            var listeners = this._rangeListeners;
+            for (var i = 0, n = listeners.length; i < n; ++i) {
+              listeners[i](begin, chunk);
+            }
+          },
+          onDataProgress: function PDFDataRangeTransport_onDataProgress(loaded) {
+            this._readyCapability.promise.then(function () {
+              var listeners = this._progressListeners;
+              for (var i = 0, n = listeners.length; i < n; ++i) {
+                listeners[i](loaded);
+              }
+            }.bind(this));
+          },
+          onDataProgressiveRead: function PDFDataRangeTransport_onDataProgress(chunk) {
+            this._readyCapability.promise.then(function () {
+              var listeners = this._progressiveReadListeners;
+              for (var i = 0, n = listeners.length; i < n; ++i) {
+                listeners[i](chunk);
+              }
+            }.bind(this));
+          },
+          transportReady: function PDFDataRangeTransport_transportReady() {
+            this._readyCapability.resolve();
+          },
+          requestDataRange: function PDFDataRangeTransport_requestDataRange(begin, end) {
+            throw new Error('Abstract method PDFDataRangeTransport.requestDataRange');
+          },
+          abort: function PDFDataRangeTransport_abort() {
+          }
+        };
+        return PDFDataRangeTransport;
+      }();
+      /**
+       * Proxy to a PDFDocument in the worker thread. Also, contains commonly used
+       * properties that can be read synchronously.
+       * @class
+       * @alias PDFDocumentProxy
+       */
+      var PDFDocumentProxy = function PDFDocumentProxyClosure() {
+        function PDFDocumentProxy(pdfInfo, transport, loadingTask) {
+          this.pdfInfo = pdfInfo;
+          this.transport = transport;
+          this.loadingTask = loadingTask;
+        }
+        PDFDocumentProxy.prototype = /** @lends PDFDocumentProxy.prototype */
+        {
+          /**
+           * @return {number} Total number of pages the PDF contains.
+           */
+          get numPages() {
+            return this.pdfInfo.numPages;
+          },
+          /**
+           * @return {string} A unique ID to identify a PDF. Not guaranteed to be
+           * unique.
+           */
+          get fingerprint() {
+            return this.pdfInfo.fingerprint;
+          },
+          /**
+           * @param {number} pageNumber The page number to get. The first page is 1.
+           * @return {Promise} A promise that is resolved with a {@link PDFPageProxy}
+           * object.
+           */
+          getPage: function PDFDocumentProxy_getPage(pageNumber) {
+            return this.transport.getPage(pageNumber);
+          },
+          /**
+           * @param {{num: number, gen: number}} ref The page reference. Must have
+           *   the 'num' and 'gen' properties.
+           * @return {Promise} A promise that is resolved with the page index that is
+           * associated with the reference.
+           */
+          getPageIndex: function PDFDocumentProxy_getPageIndex(ref) {
+            return this.transport.getPageIndex(ref);
+          },
+          /**
+           * @return {Promise} A promise that is resolved with a lookup table for
+           * mapping named destinations to reference numbers.
+           *
+           * This can be slow for large documents: use getDestination instead
+           */
+          getDestinations: function PDFDocumentProxy_getDestinations() {
+            return this.transport.getDestinations();
+          },
+          /**
+           * @param {string} id The named destination to get.
+           * @return {Promise} A promise that is resolved with all information
+           * of the given named destination.
+           */
+          getDestination: function PDFDocumentProxy_getDestination(id) {
+            return this.transport.getDestination(id);
+          },
+          /**
+           * @return {Promise} A promise that is resolved with:
+           *   an Array containing the pageLabels that correspond to the pageIndexes,
+           *   or `null` when no pageLabels are present in the PDF file.
+           */
+          getPageLabels: function PDFDocumentProxy_getPageLabels() {
+            return this.transport.getPageLabels();
+          },
+          /**
+           * @return {Promise} A promise that is resolved with a lookup table for
+           * mapping named attachments to their content.
+           */
+          getAttachments: function PDFDocumentProxy_getAttachments() {
+            return this.transport.getAttachments();
+          },
+          /**
+           * @return {Promise} A promise that is resolved with an array of all the
+           * JavaScript strings in the name tree.
+           */
+          getJavaScript: function PDFDocumentProxy_getJavaScript() {
+            return this.transport.getJavaScript();
+          },
+          /**
+           * @return {Promise} A promise that is resolved with an {Array} that is a
+           * tree outline (if it has one) of the PDF. The tree is in the format of:
+           * [
+           *  {
+           *   title: string,
+           *   bold: boolean,
+           *   italic: boolean,
+           *   color: rgb Uint8Array,
+           *   dest: dest obj,
+           *   url: string,
+           *   items: array of more items like this
+           *  },
+           *  ...
+           * ].
+           */
+          getOutline: function PDFDocumentProxy_getOutline() {
+            return this.transport.getOutline();
+          },
+          /**
+           * @return {Promise} A promise that is resolved with an {Object} that has
+           * info and metadata properties.  Info is an {Object} filled with anything
+           * available in the information dictionary and similarly metadata is a
+           * {Metadata} object with information from the metadata section of the PDF.
+           */
+          getMetadata: function PDFDocumentProxy_getMetadata() {
+            return this.transport.getMetadata();
+          },
+          /**
+           * @return {Promise} A promise that is resolved with a TypedArray that has
+           * the raw data from the PDF.
+           */
+          getData: function PDFDocumentProxy_getData() {
+            return this.transport.getData();
+          },
+          /**
+           * @return {Promise} A promise that is resolved when the document's data
+           * is loaded. It is resolved with an {Object} that contains the length
+           * property that indicates size of the PDF data in bytes.
+           */
+          getDownloadInfo: function PDFDocumentProxy_getDownloadInfo() {
+            return this.transport.downloadInfoCapability.promise;
+          },
+          /**
+           * @return {Promise} A promise this is resolved with current stats about
+           * document structures (see {@link PDFDocumentStats}).
+           */
+          getStats: function PDFDocumentProxy_getStats() {
+            return this.transport.getStats();
+          },
+          /**
+           * Cleans up resources allocated by the document, e.g. created @font-face.
+           */
+          cleanup: function PDFDocumentProxy_cleanup() {
+            this.transport.startCleanup();
+          },
+          /**
+           * Destroys current document instance and terminates worker.
+           */
+          destroy: function PDFDocumentProxy_destroy() {
+            return this.loadingTask.destroy();
+          }
+        };
+        return PDFDocumentProxy;
+      }();
+      /**
+       * Page getTextContent parameters.
+       *
+       * @typedef {Object} getTextContentParameters
+       * @property {boolean} normalizeWhitespace - replaces all occurrences of
+       *   whitespace with standard spaces (0x20). The default value is `false`.
+       * @property {boolean} disableCombineTextItems - do not attempt to combine
+       *   same line {@link TextItem}'s. The default value is `false`.
+       */
+      /**
+       * Page text content.
+       *
+       * @typedef {Object} TextContent
+       * @property {array} items - array of {@link TextItem}
+       * @property {Object} styles - {@link TextStyles} objects, indexed by font name.
+       */
+      /**
+       * Page text content part.
+       *
+       * @typedef {Object} TextItem
+       * @property {string} str - text content.
+       * @property {string} dir - text direction: 'ttb', 'ltr' or 'rtl'.
+       * @property {array} transform - transformation matrix.
+       * @property {number} width - width in device space.
+       * @property {number} height - height in device space.
+       * @property {string} fontName - font name used by pdf.js for converted font.
+       */
+      /**
+       * Text style.
+       *
+       * @typedef {Object} TextStyle
+       * @property {number} ascent - font ascent.
+       * @property {number} descent - font descent.
+       * @property {boolean} vertical - text is in vertical mode.
+       * @property {string} fontFamily - possible font family
+       */
+      /**
+       * Page annotation parameters.
+       *
+       * @typedef {Object} GetAnnotationsParameters
+       * @property {string} intent - Determines the annotations that will be fetched,
+       *                    can be either 'display' (viewable annotations) or 'print'
+       *                    (printable annotations).
+       *                    If the parameter is omitted, all annotations are fetched.
+       */
+      /**
+       * Page render parameters.
+       *
+       * @typedef {Object} RenderParameters
+       * @property {Object} canvasContext - A 2D context of a DOM Canvas object.
+       * @property {PageViewport} viewport - Rendering viewport obtained by
+       *                                calling of PDFPage.getViewport method.
+       * @property {string} intent - Rendering intent, can be 'display' or 'print'
+       *                    (default value is 'display').
+       * @property {boolean} renderInteractiveForms - (optional) Whether or not
+       *                     interactive form elements are rendered in the display
+       *                     layer. If so, we do not render them on canvas as well.
+       * @property {Array}  transform - (optional) Additional transform, applied
+       *                    just before viewport transform.
+       * @property {Object} imageLayer - (optional) An object that has beginLayout,
+       *                    endLayout and appendImage functions.
+       * @property {function} continueCallback - (deprecated) A function that will be
+       *                      called each time the rendering is paused.  To continue
+       *                      rendering call the function that is the first argument
+       *                      to the callback.
+       */
+      /**
+       * PDF page operator list.
+       *
+       * @typedef {Object} PDFOperatorList
+       * @property {Array} fnArray - Array containing the operator functions.
+       * @property {Array} argsArray - Array containing the arguments of the
+       *                               functions.
+       */
+      /**
+       * Proxy to a PDFPage in the worker thread.
+       * @class
+       * @alias PDFPageProxy
+       */
+      var PDFPageProxy = function PDFPageProxyClosure() {
+        function PDFPageProxy(pageIndex, pageInfo, transport) {
+          this.pageIndex = pageIndex;
+          this.pageInfo = pageInfo;
+          this.transport = transport;
+          this.stats = new StatTimer();
+          this.stats.enabled = getDefaultSetting('enableStats');
+          this.commonObjs = transport.commonObjs;
+          this.objs = new PDFObjects();
+          this.cleanupAfterRender = false;
+          this.pendingCleanup = false;
+          this.intentStates = Object.create(null);
+          this.destroyed = false;
+        }
+        PDFPageProxy.prototype = /** @lends PDFPageProxy.prototype */
+        {
+          /**
+           * @return {number} Page number of the page. First page is 1.
+           */
+          get pageNumber() {
+            return this.pageIndex + 1;
+          },
+          /**
+           * @return {number} The number of degrees the page is rotated clockwise.
+           */
+          get rotate() {
+            return this.pageInfo.rotate;
+          },
+          /**
+           * @return {Object} The reference that points to this page. It has 'num' and
+           * 'gen' properties.
+           */
+          get ref() {
+            return this.pageInfo.ref;
+          },
+          /**
+           * @return {Array} An array of the visible portion of the PDF page in the
+           * user space units - [x1, y1, x2, y2].
+           */
+          get view() {
+            return this.pageInfo.view;
+          },
+          /**
+           * @param {number} scale The desired scale of the viewport.
+           * @param {number} rotate Degrees to rotate the viewport. If omitted this
+           * defaults to the page rotation.
+           * @return {PageViewport} Contains 'width' and 'height' properties
+           * along with transforms required for rendering.
+           */
+          getViewport: function PDFPageProxy_getViewport(scale, rotate) {
+            if (arguments.length < 2) {
+              rotate = this.rotate;
+            }
+            return new PageViewport(this.view, scale, rotate, 0, 0);
+          },
+          /**
+           * @param {GetAnnotationsParameters} params - Annotation parameters.
+           * @return {Promise} A promise that is resolved with an {Array} of the
+           * annotation objects.
+           */
+          getAnnotations: function PDFPageProxy_getAnnotations(params) {
+            var intent = params && params.intent || null;
+            if (!this.annotationsPromise || this.annotationsIntent !== intent) {
+              this.annotationsPromise = this.transport.getAnnotations(this.pageIndex, intent);
+              this.annotationsIntent = intent;
+            }
+            return this.annotationsPromise;
+          },
+          /**
+           * Begins the process of rendering a page to the desired context.
+           * @param {RenderParameters} params Page render parameters.
+           * @return {RenderTask} An object that contains the promise, which
+           *                      is resolved when the page finishes rendering.
+           */
+          render: function PDFPageProxy_render(params) {
+            var stats = this.stats;
+            stats.time('Overall');
+            // If there was a pending destroy cancel it so no cleanup happens during
+            // this call to render.
+            this.pendingCleanup = false;
+            var renderingIntent = params.intent === 'print' ? 'print' : 'display';
+            var renderInteractiveForms = params.renderInteractiveForms === true ? true : /* Default */
+            false;
+            if (!this.intentStates[renderingIntent]) {
+              this.intentStates[renderingIntent] = Object.create(null);
+            }
+            var intentState = this.intentStates[renderingIntent];
+            // If there's no displayReadyCapability yet, then the operatorList
+            // was never requested before. Make the request and create the promise.
+            if (!intentState.displayReadyCapability) {
+              intentState.receivingOperatorList = true;
+              intentState.displayReadyCapability = createPromiseCapability();
+              intentState.operatorList = {
+                fnArray: [],
+                argsArray: [],
+                lastChunk: false
+              };
+              this.stats.time('Page Request');
+              this.transport.messageHandler.send('RenderPageRequest', {
+                pageIndex: this.pageNumber - 1,
+                intent: renderingIntent,
+                renderInteractiveForms: renderInteractiveForms
+              });
+            }
+            var internalRenderTask = new InternalRenderTask(complete, params, this.objs, this.commonObjs, intentState.operatorList, this.pageNumber);
+            internalRenderTask.useRequestAnimationFrame = renderingIntent !== 'print';
+            if (!intentState.renderTasks) {
+              intentState.renderTasks = [];
+            }
+            intentState.renderTasks.push(internalRenderTask);
+            var renderTask = internalRenderTask.task;
+            // Obsolete parameter support
+            if (params.continueCallback) {
+              deprecated('render is used with continueCallback parameter');
+              renderTask.onContinue = params.continueCallback;
+            }
+            var self = this;
+            intentState.displayReadyCapability.promise.then(function pageDisplayReadyPromise(transparency) {
+              if (self.pendingCleanup) {
+                complete();
+                return;
+              }
+              stats.time('Rendering');
+              internalRenderTask.initializeGraphics(transparency);
+              internalRenderTask.operatorListChanged();
+            }, function pageDisplayReadPromiseError(reason) {
+              complete(reason);
+            });
+            function complete(error) {
+              var i = intentState.renderTasks.indexOf(internalRenderTask);
+              if (i >= 0) {
+                intentState.renderTasks.splice(i, 1);
+              }
+              if (self.cleanupAfterRender) {
+                self.pendingCleanup = true;
+              }
+              self._tryCleanup();
+              if (error) {
+                internalRenderTask.capability.reject(error);
+              } else {
+                internalRenderTask.capability.resolve();
+              }
+              stats.timeEnd('Rendering');
+              stats.timeEnd('Overall');
+            }
+            return renderTask;
+          },
+          /**
+           * @return {Promise} A promise resolved with an {@link PDFOperatorList}
+           * object that represents page's operator list.
+           */
+          getOperatorList: function PDFPageProxy_getOperatorList() {
+            function operatorListChanged() {
+              if (intentState.operatorList.lastChunk) {
+                intentState.opListReadCapability.resolve(intentState.operatorList);
+                var i = intentState.renderTasks.indexOf(opListTask);
+                if (i >= 0) {
+                  intentState.renderTasks.splice(i, 1);
+                }
+              }
+            }
+            var renderingIntent = 'oplist';
+            if (!this.intentStates[renderingIntent]) {
+              this.intentStates[renderingIntent] = Object.create(null);
+            }
+            var intentState = this.intentStates[renderingIntent];
+            var opListTask;
+            if (!intentState.opListReadCapability) {
+              opListTask = {};
+              opListTask.operatorListChanged = operatorListChanged;
+              intentState.receivingOperatorList = true;
+              intentState.opListReadCapability = createPromiseCapability();
+              intentState.renderTasks = [];
+              intentState.renderTasks.push(opListTask);
+              intentState.operatorList = {
+                fnArray: [],
+                argsArray: [],
+                lastChunk: false
+              };
+              this.transport.messageHandler.send('RenderPageRequest', {
+                pageIndex: this.pageIndex,
+                intent: renderingIntent
+              });
+            }
+            return intentState.opListReadCapability.promise;
+          },
+          /**
+           * @param {getTextContentParameters} params - getTextContent parameters.
+           * @return {Promise} That is resolved a {@link TextContent}
+           * object that represent the page text content.
+           */
+          getTextContent: function PDFPageProxy_getTextContent(params) {
+            return this.transport.messageHandler.sendWithPromise('GetTextContent', {
+              pageIndex: this.pageNumber - 1,
+              normalizeWhitespace: params && params.normalizeWhitespace === true ? true : /* Default */
+              false,
+              combineTextItems: params && params.disableCombineTextItems === true ? false : /* Default */
+              true
+            });
+          },
+          /**
+           * Destroys page object.
+           */
+          _destroy: function PDFPageProxy_destroy() {
+            this.destroyed = true;
+            this.transport.pageCache[this.pageIndex] = null;
+            var waitOn = [];
+            Object.keys(this.intentStates).forEach(function (intent) {
+              if (intent === 'oplist') {
+                // Avoid errors below, since the renderTasks are just stubs.
+                return;
+              }
+              var intentState = this.intentStates[intent];
+              intentState.renderTasks.forEach(function (renderTask) {
+                var renderCompleted = renderTask.capability.promise.catch(function () {
+                });
+                // ignoring failures
+                waitOn.push(renderCompleted);
+                renderTask.cancel();
+              });
+            }, this);
+            this.objs.clear();
+            this.annotationsPromise = null;
+            this.pendingCleanup = false;
+            return Promise.all(waitOn);
+          },
+          /**
+           * Cleans up resources allocated by the page. (deprecated)
+           */
+          destroy: function () {
+            deprecated('page destroy method, use cleanup() instead');
+            this.cleanup();
+          },
+          /**
+           * Cleans up resources allocated by the page.
+           */
+          cleanup: function PDFPageProxy_cleanup() {
+            this.pendingCleanup = true;
+            this._tryCleanup();
+          },
+          /**
+           * For internal use only. Attempts to clean up if rendering is in a state
+           * where that's possible.
+           * @ignore
+           */
+          _tryCleanup: function PDFPageProxy_tryCleanup() {
+            if (!this.pendingCleanup || Object.keys(this.intentStates).some(function (intent) {
+                var intentState = this.intentStates[intent];
+                return intentState.renderTasks.length !== 0 || intentState.receivingOperatorList;
+              }, this)) {
+              return;
+            }
+            Object.keys(this.intentStates).forEach(function (intent) {
+              delete this.intentStates[intent];
+            }, this);
+            this.objs.clear();
+            this.annotationsPromise = null;
+            this.pendingCleanup = false;
+          },
+          /**
+           * For internal use only.
+           * @ignore
+           */
+          _startRenderPage: function PDFPageProxy_startRenderPage(transparency, intent) {
+            var intentState = this.intentStates[intent];
+            // TODO Refactor RenderPageRequest to separate rendering
+            // and operator list logic
+            if (intentState.displayReadyCapability) {
+              intentState.displayReadyCapability.resolve(transparency);
+            }
+          },
+          /**
+           * For internal use only.
+           * @ignore
+           */
+          _renderPageChunk: function PDFPageProxy_renderPageChunk(operatorListChunk, intent) {
+            var intentState = this.intentStates[intent];
+            var i, ii;
+            // Add the new chunk to the current operator list.
+            for (i = 0, ii = operatorListChunk.length; i < ii; i++) {
+              intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
+              intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
+            }
+            intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
+            // Notify all the rendering tasks there are more operators to be consumed.
+            for (i = 0; i < intentState.renderTasks.length; i++) {
+              intentState.renderTasks[i].operatorListChanged();
+            }
+            if (operatorListChunk.lastChunk) {
+              intentState.receivingOperatorList = false;
+              this._tryCleanup();
+            }
+          }
+        };
+        return PDFPageProxy;
+      }();
+      /**
+       * PDF.js web worker abstraction, it controls instantiation of PDF documents and
+       * WorkerTransport for them.  If creation of a web worker is not possible,
+       * a "fake" worker will be used instead.
+       * @class
+       */
+      var PDFWorker = function PDFWorkerClosure() {
+        var nextFakeWorkerId = 0;
+        function getWorkerSrc() {
+          if (typeof workerSrc !== 'undefined') {
+            return workerSrc;
+          }
+          if (getDefaultSetting('workerSrc')) {
+            return getDefaultSetting('workerSrc');
+          }
+          error('No PDFJS.workerSrc specified');
+        }
+        var fakeWorkerFilesLoadedCapability;
+        // Loads worker code into main thread.
+        function setupFakeWorkerGlobal() {
+          var WorkerMessageHandler;
+          if (fakeWorkerFilesLoadedCapability) {
+            return fakeWorkerFilesLoadedCapability.promise;
+          }
+          fakeWorkerFilesLoadedCapability = createPromiseCapability();
+          var loader = fakeWorkerFilesLoader || function (callback) {
+            Util.loadScript(getWorkerSrc(), function () {
+              callback(window.pdfjsDistBuildPdfWorker.WorkerMessageHandler);
+            });
+          };
+          loader(fakeWorkerFilesLoadedCapability.resolve);
+          return fakeWorkerFilesLoadedCapability.promise;
+        }
+        function FakeWorkerPort(defer) {
+          this._listeners = [];
+          this._defer = defer;
+          this._deferred = Promise.resolve(undefined);
+        }
+        FakeWorkerPort.prototype = {
+          postMessage: function (obj, transfers) {
+            function cloneValue(value) {
+              // Trying to perform a structured clone close to the spec, including
+              // transfers.
+              if (typeof value !== 'object' || value === null) {
+                return value;
+              }
+              if (cloned.has(value)) {
+                // already cloned the object
+                return cloned.get(value);
+              }
+              var result;
+              var buffer;
+              if ((buffer = value.buffer) && isArrayBuffer(buffer)) {
+                // We found object with ArrayBuffer (typed array).
+                var transferable = transfers && transfers.indexOf(buffer) >= 0;
+                if (value === buffer) {
+                  // Special case when we are faking typed arrays in compatibility.js.
+                  result = value;
+                } else if (transferable) {
+                  result = new value.constructor(buffer, value.byteOffset, value.byteLength);
+                } else {
+                  result = new value.constructor(value);
+                }
+                cloned.set(value, result);
+                return result;
+              }
+              result = isArray(value) ? [] : {};
+              cloned.set(value, result);
+              // adding to cache now for cyclic references
+              // Cloning all value and object properties, however ignoring properties
+              // defined via getter.
+              for (var i in value) {
+                var desc, p = value;
+                while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
+                  p = Object.getPrototypeOf(p);
+                }
+                if (typeof desc.value === 'undefined' || typeof desc.value === 'function') {
+                  continue;
+                }
+                result[i] = cloneValue(desc.value);
+              }
+              return result;
+            }
+            if (!this._defer) {
+              this._listeners.forEach(function (listener) {
+                listener.call(this, { data: obj });
+              }, this);
+              return;
+            }
+            var cloned = new WeakMap();
+            var e = { data: cloneValue(obj) };
+            this._deferred.then(function () {
+              this._listeners.forEach(function (listener) {
+                listener.call(this, e);
+              }, this);
+            }.bind(this));
+          },
+          addEventListener: function (name, listener) {
+            this._listeners.push(listener);
+          },
+          removeEventListener: function (name, listener) {
+            var i = this._listeners.indexOf(listener);
+            this._listeners.splice(i, 1);
+          },
+          terminate: function () {
+            this._listeners = [];
+          }
+        };
+        function createCDNWrapper(url) {
+          // We will rely on blob URL's property to specify origin.
+          // We want this function to fail in case if createObjectURL or Blob do not
+          // exist or fail for some reason -- our Worker creation will fail anyway.
+          var wrapper = 'importScripts(\'' + url + '\');';
+          return URL.createObjectURL(new Blob([wrapper]));
+        }
+        function PDFWorker(name) {
+          this.name = name;
+          this.destroyed = false;
+          this._readyCapability = createPromiseCapability();
+          this._port = null;
+          this._webWorker = null;
+          this._messageHandler = null;
+          this._initialize();
+        }
+        PDFWorker.prototype = /** @lends PDFWorker.prototype */
+        {
+          get promise() {
+            return this._readyCapability.promise;
+          },
+          get port() {
+            return this._port;
+          },
+          get messageHandler() {
+            return this._messageHandler;
+          },
+          _initialize: function PDFWorker_initialize() {
+            // If worker support isn't disabled explicit and the browser has worker
+            // support, create a new web worker and test if it/the browser fulfills
+            // all requirements to run parts of pdf.js in a web worker.
+            // Right now, the requirement is, that an Uint8Array is still an
+            // Uint8Array as it arrives on the worker. (Chrome added this with v.15.)
+            if (!isWorkerDisabled && !getDefaultSetting('disableWorker') && typeof Worker !== 'undefined') {
+              var workerSrc = getWorkerSrc();
+              try {
+                // Some versions of FF can't create a worker on localhost, see:
+                // https://bugzilla.mozilla.org/show_bug.cgi?id=683280
+                var worker = new Worker(workerSrc);
+                var messageHandler = new MessageHandler('main', 'worker', worker);
+                var terminateEarly = function () {
+                  worker.removeEventListener('error', onWorkerError);
+                  messageHandler.destroy();
+                  worker.terminate();
+                  if (this.destroyed) {
+                    this._readyCapability.reject(new Error('Worker was destroyed'));
+                  } else {
+                    // Fall back to fake worker if the termination is caused by an
+                    // error (e.g. NetworkError / SecurityError).
+                    this._setupFakeWorker();
+                  }
+                }.bind(this);
+                var onWorkerError = function (event) {
+                  if (!this._webWorker) {
+                    // Worker failed to initialize due to an error. Clean up and fall
+                    // back to the fake worker.
+                    terminateEarly();
+                  }
+                }.bind(this);
+                worker.addEventListener('error', onWorkerError);
+                messageHandler.on('test', function PDFWorker_test(data) {
+                  worker.removeEventListener('error', onWorkerError);
+                  if (this.destroyed) {
+                    terminateEarly();
+                    return;
+                  }
+                  // worker was destroyed
+                  var supportTypedArray = data && data.supportTypedArray;
+                  if (supportTypedArray) {
+                    this._messageHandler = messageHandler;
+                    this._port = worker;
+                    this._webWorker = worker;
+                    if (!data.supportTransfers) {
+                      isPostMessageTransfersDisabled = true;
+                    }
+                    this._readyCapability.resolve();
+                    // Send global setting, e.g. verbosity level.
+                    messageHandler.send('configure', { verbosity: getVerbosityLevel() });
+                  } else {
+                    this._setupFakeWorker();
+                    messageHandler.destroy();
+                    worker.terminate();
+                  }
+                }.bind(this));
+                messageHandler.on('console_log', function (data) {
+                  console.log.apply(console, data);
+                });
+                messageHandler.on('console_error', function (data) {
+                  console.error.apply(console, data);
+                });
+                messageHandler.on('ready', function (data) {
+                  worker.removeEventListener('error', onWorkerError);
+                  if (this.destroyed) {
+                    terminateEarly();
+                    return;
+                  }
+                  // worker was destroyed
+                  try {
+                    sendTest();
+                  } catch (e) {
+                    // We need fallback to a faked worker.
+                    this._setupFakeWorker();
+                  }
+                }.bind(this));
+                var sendTest = function () {
+                  var postMessageTransfers = getDefaultSetting('postMessageTransfers') && !isPostMessageTransfersDisabled;
+                  var testObj = new Uint8Array([postMessageTransfers ? 255 : 0]);
+                  // Some versions of Opera throw a DATA_CLONE_ERR on serializing the
+                  // typed array. Also, checking if we can use transfers.
+                  try {
+                    messageHandler.send('test', testObj, [testObj.buffer]);
+                  } catch (ex) {
+                    info('Cannot use postMessage transfers');
+                    testObj[0] = 0;
+                    messageHandler.send('test', testObj);
+                  }
+                };
+                // It might take time for worker to initialize (especially when AMD
+                // loader is used). We will try to send test immediately, and then
+                // when 'ready' message will arrive. The worker shall process only
+                // first received 'test'.
+                sendTest();
+                return;
+              } catch (e) {
+                info('The worker has been disabled.');
+              }
+            }
+            // Either workers are disabled, not supported or have thrown an exception.
+            // Thus, we fallback to a faked worker.
+            this._setupFakeWorker();
+          },
+          _setupFakeWorker: function PDFWorker_setupFakeWorker() {
+            if (!isWorkerDisabled && !getDefaultSetting('disableWorker')) {
+              warn('Setting up fake worker.');
+              isWorkerDisabled = true;
+            }
+            setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
+              if (this.destroyed) {
+                this._readyCapability.reject(new Error('Worker was destroyed'));
+                return;
+              }
+              // We cannot turn on proper fake port simulation (this includes
+              // structured cloning) when typed arrays are not supported. Relying
+              // on a chance that messages will be sent in proper order.
+              var isTypedArraysPresent = Uint8Array !== Float32Array;
+              var port = new FakeWorkerPort(isTypedArraysPresent);
+              this._port = port;
+              // All fake workers use the same port, making id unique.
+              var id = 'fake' + nextFakeWorkerId++;
+              // If the main thread is our worker, setup the handling for the
+              // messages -- the main thread sends to it self.
+              var workerHandler = new MessageHandler(id + '_worker', id, port);
+              WorkerMessageHandler.setup(workerHandler, port);
+              var messageHandler = new MessageHandler(id, id + '_worker', port);
+              this._messageHandler = messageHandler;
+              this._readyCapability.resolve();
+            }.bind(this));
+          },
+          /**
+           * Destroys the worker instance.
+           */
+          destroy: function PDFWorker_destroy() {
+            this.destroyed = true;
+            if (this._webWorker) {
+              // We need to terminate only web worker created resource.
+              this._webWorker.terminate();
+              this._webWorker = null;
+            }
+            this._port = null;
+            if (this._messageHandler) {
+              this._messageHandler.destroy();
+              this._messageHandler = null;
+            }
+          }
+        };
+        return PDFWorker;
+      }();
+      /**
+       * For internal use only.
+       * @ignore
+       */
+      var WorkerTransport = function WorkerTransportClosure() {
+        function WorkerTransport(messageHandler, loadingTask, pdfDataRangeTransport) {
+          this.messageHandler = messageHandler;
+          this.loadingTask = loadingTask;
+          this.pdfDataRangeTransport = pdfDataRangeTransport;
+          this.commonObjs = new PDFObjects();
+          this.fontLoader = new FontLoader(loadingTask.docId);
+          this.destroyed = false;
+          this.destroyCapability = null;
+          this.pageCache = [];
+          this.pagePromises = [];
+          this.downloadInfoCapability = createPromiseCapability();
+          this.setupMessageHandler();
+        }
+        WorkerTransport.prototype = {
+          destroy: function WorkerTransport_destroy() {
+            if (this.destroyCapability) {
+              return this.destroyCapability.promise;
+            }
+            this.destroyed = true;
+            this.destroyCapability = createPromiseCapability();
+            var waitOn = [];
+            // We need to wait for all renderings to be completed, e.g.
+            // timeout/rAF can take a long time.
+            this.pageCache.forEach(function (page) {
+              if (page) {
+                waitOn.push(page._destroy());
+              }
+            });
+            this.pageCache = [];
+            this.pagePromises = [];
+            var self = this;
+            // We also need to wait for the worker to finish its long running tasks.
+            var terminated = this.messageHandler.sendWithPromise('Terminate', null);
+            waitOn.push(terminated);
+            Promise.all(waitOn).then(function () {
+              self.fontLoader.clear();
+              if (self.pdfDataRangeTransport) {
+                self.pdfDataRangeTransport.abort();
+                self.pdfDataRangeTransport = null;
+              }
+              if (self.messageHandler) {
+                self.messageHandler.destroy();
+                self.messageHandler = null;
+              }
+              self.destroyCapability.resolve();
+            }, this.destroyCapability.reject);
+            return this.destroyCapability.promise;
+          },
+          setupMessageHandler: function WorkerTransport_setupMessageHandler() {
+            var messageHandler = this.messageHandler;
+            function updatePassword(password) {
+              messageHandler.send('UpdatePassword', password);
+            }
+            var pdfDataRangeTransport = this.pdfDataRangeTransport;
+            if (pdfDataRangeTransport) {
+              pdfDataRangeTransport.addRangeListener(function (begin, chunk) {
+                messageHandler.send('OnDataRange', {
+                  begin: begin,
+                  chunk: chunk
+                });
+              });
+              pdfDataRangeTransport.addProgressListener(function (loaded) {
+                messageHandler.send('OnDataProgress', { loaded: loaded });
+              });
+              pdfDataRangeTransport.addProgressiveReadListener(function (chunk) {
+                messageHandler.send('OnDataRange', { chunk: chunk });
+              });
+              messageHandler.on('RequestDataRange', function transportDataRange(data) {
+                pdfDataRangeTransport.requestDataRange(data.begin, data.end);
+              }, this);
+            }
+            messageHandler.on('GetDoc', function transportDoc(data) {
+              var pdfInfo = data.pdfInfo;
+              this.numPages = data.pdfInfo.numPages;
+              var loadingTask = this.loadingTask;
+              var pdfDocument = new PDFDocumentProxy(pdfInfo, this, loadingTask);
+              this.pdfDocument = pdfDocument;
+              loadingTask._capability.resolve(pdfDocument);
+            }, this);
+            messageHandler.on('NeedPassword', function transportNeedPassword(exception) {
+              var loadingTask = this.loadingTask;
+              if (loadingTask.onPassword) {
+                return loadingTask.onPassword(updatePassword, PasswordResponses.NEED_PASSWORD);
+              }
+              loadingTask._capability.reject(new PasswordException(exception.message, exception.code));
+            }, this);
+            messageHandler.on('IncorrectPassword', function transportIncorrectPassword(exception) {
+              var loadingTask = this.loadingTask;
+              if (loadingTask.onPassword) {
+                return loadingTask.onPassword(updatePassword, PasswordResponses.INCORRECT_PASSWORD);
+              }
+              loadingTask._capability.reject(new PasswordException(exception.message, exception.code));
+            }, this);
+            messageHandler.on('InvalidPDF', function transportInvalidPDF(exception) {
+              this.loadingTask._capability.reject(new InvalidPDFException(exception.message));
+            }, this);
+            messageHandler.on('MissingPDF', function transportMissingPDF(exception) {
+              this.loadingTask._capability.reject(new MissingPDFException(exception.message));
+            }, this);
+            messageHandler.on('UnexpectedResponse', function transportUnexpectedResponse(exception) {
+              this.loadingTask._capability.reject(new UnexpectedResponseException(exception.message, exception.status));
+            }, this);
+            messageHandler.on('UnknownError', function transportUnknownError(exception) {
+              this.loadingTask._capability.reject(new UnknownErrorException(exception.message, exception.details));
+            }, this);
+            messageHandler.on('DataLoaded', function transportPage(data) {
+              this.downloadInfoCapability.resolve(data);
+            }, this);
+            messageHandler.on('PDFManagerReady', function transportPage(data) {
+              if (this.pdfDataRangeTransport) {
+                this.pdfDataRangeTransport.transportReady();
+              }
+            }, this);
+            messageHandler.on('StartRenderPage', function transportRender(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var page = this.pageCache[data.pageIndex];
+              page.stats.timeEnd('Page Request');
+              page._startRenderPage(data.transparency, data.intent);
+            }, this);
+            messageHandler.on('RenderPageChunk', function transportRender(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var page = this.pageCache[data.pageIndex];
+              page._renderPageChunk(data.operatorList, data.intent);
+            }, this);
+            messageHandler.on('commonobj', function transportObj(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var id = data[0];
+              var type = data[1];
+              if (this.commonObjs.hasData(id)) {
+                return;
+              }
+              switch (type) {
+              case 'Font':
+                var exportedData = data[2];
+                if ('error' in exportedData) {
+                  var exportedError = exportedData.error;
+                  warn('Error during font loading: ' + exportedError);
+                  this.commonObjs.resolve(id, exportedError);
+                  break;
+                }
+                var fontRegistry = null;
+                if (getDefaultSetting('pdfBug') && globalScope.FontInspector && globalScope['FontInspector'].enabled) {
+                  fontRegistry = {
+                    registerFont: function (font, url) {
+                      globalScope['FontInspector'].fontAdded(font, url);
+                    }
+                  };
+                }
+                var font = new FontFaceObject(exportedData, {
+                  isEvalSuported: getDefaultSetting('isEvalSupported'),
+                  disableFontFace: getDefaultSetting('disableFontFace'),
+                  fontRegistry: fontRegistry
+                });
+                this.fontLoader.bind([font], function fontReady(fontObjs) {
+                  this.commonObjs.resolve(id, font);
+                }.bind(this));
+                break;
+              case 'FontPath':
+                this.commonObjs.resolve(id, data[2]);
+                break;
+              default:
+                error('Got unknown common object type ' + type);
+              }
+            }, this);
+            messageHandler.on('obj', function transportObj(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var id = data[0];
+              var pageIndex = data[1];
+              var type = data[2];
+              var pageProxy = this.pageCache[pageIndex];
+              var imageData;
+              if (pageProxy.objs.hasData(id)) {
+                return;
+              }
+              switch (type) {
+              case 'JpegStream':
+                imageData = data[3];
+                loadJpegStream(id, imageData, pageProxy.objs);
+                break;
+              case 'Image':
+                imageData = data[3];
+                pageProxy.objs.resolve(id, imageData);
+                // heuristics that will allow not to store large data
+                var MAX_IMAGE_SIZE_TO_STORE = 8000000;
+                if (imageData && 'data' in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
+                  pageProxy.cleanupAfterRender = true;
+                }
+                break;
+              default:
+                error('Got unknown object type ' + type);
+              }
+            }, this);
+            messageHandler.on('DocProgress', function transportDocProgress(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var loadingTask = this.loadingTask;
+              if (loadingTask.onProgress) {
+                loadingTask.onProgress({
+                  loaded: data.loaded,
+                  total: data.total
+                });
+              }
+            }, this);
+            messageHandler.on('PageError', function transportError(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var page = this.pageCache[data.pageNum - 1];
+              var intentState = page.intentStates[data.intent];
+              if (intentState.displayReadyCapability) {
+                intentState.displayReadyCapability.reject(data.error);
+              } else {
+                error(data.error);
+              }
+              if (intentState.operatorList) {
+                // Mark operator list as complete.
+                intentState.operatorList.lastChunk = true;
+                for (var i = 0; i < intentState.renderTasks.length; i++) {
+                  intentState.renderTasks[i].operatorListChanged();
+                }
+              }
+            }, this);
+            messageHandler.on('UnsupportedFeature', function transportUnsupportedFeature(data) {
+              if (this.destroyed) {
+                return;
+              }
+              // Ignore any pending requests if the worker was terminated.
+              var featureId = data.featureId;
+              var loadingTask = this.loadingTask;
+              if (loadingTask.onUnsupportedFeature) {
+                loadingTask.onUnsupportedFeature(featureId);
+              }
+              _UnsupportedManager.notify(featureId);
+            }, this);
+            messageHandler.on('JpegDecode', function (data) {
+              if (this.destroyed) {
+                return Promise.reject(new Error('Worker was destroyed'));
+              }
+              var imageUrl = data[0];
+              var components = data[1];
+              if (components !== 3 && components !== 1) {
+                return Promise.reject(new Error('Only 3 components or 1 component can be returned'));
+              }
+              return new Promise(function (resolve, reject) {
+                var img = new Image();
+                img.onload = function () {
+                  var width = img.width;
+                  var height = img.height;
+                  var size = width * height;
+                  var rgbaLength = size * 4;
+                  var buf = new Uint8Array(size * components);
+                  var tmpCanvas = createScratchCanvas(width, height);
+                  var tmpCtx = tmpCanvas.getContext('2d');
+                  tmpCtx.drawImage(img, 0, 0);
+                  var data = tmpCtx.getImageData(0, 0, width, height).data;
+                  var i, j;
+                  if (components === 3) {
+                    for (i = 0, j = 0; i < rgbaLength; i += 4, j += 3) {
+                      buf[j] = data[i];
+                      buf[j + 1] = data[i + 1];
+                      buf[j + 2] = data[i + 2];
+                    }
+                  } else if (components === 1) {
+                    for (i = 0, j = 0; i < rgbaLength; i += 4, j++) {
+                      buf[j] = data[i];
+                    }
+                  }
+                  resolve({
+                    data: buf,
+                    width: width,
+                    height: height
+                  });
+                };
+                img.onerror = function () {
+                  reject(new Error('JpegDecode failed to load image'));
+                };
+                img.src = imageUrl;
+              });
+            }, this);
+          },
+          getData: function WorkerTransport_getData() {
+            return this.messageHandler.sendWithPromise('GetData', null);
+          },
+          getPage: function WorkerTransport_getPage(pageNumber, capability) {
+            if (!isInt(pageNumber) || pageNumber <= 0 || pageNumber > this.numPages) {
+              return Promise.reject(new Error('Invalid page request'));
+            }
+            var pageIndex = pageNumber - 1;
+            if (pageIndex in this.pagePromises) {
+              return this.pagePromises[pageIndex];
+            }
+            var promise = this.messageHandler.sendWithPromise('GetPage', { pageIndex: pageIndex }).then(function (pageInfo) {
+              if (this.destroyed) {
+                throw new Error('Transport destroyed');
+              }
+              var page = new PDFPageProxy(pageIndex, pageInfo, this);
+              this.pageCache[pageIndex] = page;
+              return page;
+            }.bind(this));
+            this.pagePromises[pageIndex] = promise;
+            return promise;
+          },
+          getPageIndex: function WorkerTransport_getPageIndexByRef(ref) {
+            return this.messageHandler.sendWithPromise('GetPageIndex', { ref: ref }).catch(function (reason) {
+              return Promise.reject(new Error(reason));
+            });
+          },
+          getAnnotations: function WorkerTransport_getAnnotations(pageIndex, intent) {
+            return this.messageHandler.sendWithPromise('GetAnnotations', {
+              pageIndex: pageIndex,
+              intent: intent
+            });
+          },
+          getDestinations: function WorkerTransport_getDestinations() {
+            return this.messageHandler.sendWithPromise('GetDestinations', null);
+          },
+          getDestination: function WorkerTransport_getDestination(id) {
+            return this.messageHandler.sendWithPromise('GetDestination', { id: id });
+          },
+          getPageLabels: function WorkerTransport_getPageLabels() {
+            return this.messageHandler.sendWithPromise('GetPageLabels', null);
+          },
+          getAttachments: function WorkerTransport_getAttachments() {
+            return this.messageHandler.sendWithPromise('GetAttachments', null);
+          },
+          getJavaScript: function WorkerTransport_getJavaScript() {
+            return this.messageHandler.sendWithPromise('GetJavaScript', null);
+          },
+          getOutline: function WorkerTransport_getOutline() {
+            return this.messageHandler.sendWithPromise('GetOutline', null);
+          },
+          getMetadata: function WorkerTransport_getMetadata() {
+            return this.messageHandler.sendWithPromise('GetMetadata', null).then(function transportMetadata(results) {
+              return {
+                info: results[0],
+                metadata: results[1] ? new Metadata(results[1]) : null
+              };
+            });
+          },
+          getStats: function WorkerTransport_getStats() {
+            return this.messageHandler.sendWithPromise('GetStats', null);
+          },
+          startCleanup: function WorkerTransport_startCleanup() {
+            this.messageHandler.sendWithPromise('Cleanup', null).then(function endCleanup() {
+              for (var i = 0, ii = this.pageCache.length; i < ii; i++) {
+                var page = this.pageCache[i];
+                if (page) {
+                  page.cleanup();
+                }
+              }
+              this.commonObjs.clear();
+              this.fontLoader.clear();
+            }.bind(this));
+          }
+        };
+        return WorkerTransport;
+      }();
+      /**
+       * A PDF document and page is built of many objects. E.g. there are objects
+       * for fonts, images, rendering code and such. These objects might get processed
+       * inside of a worker. The `PDFObjects` implements some basic functions to
+       * manage these objects.
+       * @ignore
+       */
+      var PDFObjects = function PDFObjectsClosure() {
+        function PDFObjects() {
+          this.objs = Object.create(null);
+        }
+        PDFObjects.prototype = {
+          /**
+           * Internal function.
+           * Ensures there is an object defined for `objId`.
+           */
+          ensureObj: function PDFObjects_ensureObj(objId) {
+            if (this.objs[objId]) {
+              return this.objs[objId];
+            }
+            var obj = {
+              capability: createPromiseCapability(),
+              data: null,
+              resolved: false
+            };
+            this.objs[objId] = obj;
+            return obj;
+          },
+          /**
+           * If called *without* callback, this returns the data of `objId` but the
+           * object needs to be resolved. If it isn't, this function throws.
+           *
+           * If called *with* a callback, the callback is called with the data of the
+           * object once the object is resolved. That means, if you call this
+           * function and the object is already resolved, the callback gets called
+           * right away.
+           */
+          get: function PDFObjects_get(objId, callback) {
+            // If there is a callback, then the get can be async and the object is
+            // not required to be resolved right now
+            if (callback) {
+              this.ensureObj(objId).capability.promise.then(callback);
+              return null;
+            }
+            // If there isn't a callback, the user expects to get the resolved data
+            // directly.
+            var obj = this.objs[objId];
+            // If there isn't an object yet or the object isn't resolved, then the
+            // data isn't ready yet!
+            if (!obj || !obj.resolved) {
+              error('Requesting object that isn\'t resolved yet ' + objId);
+            }
+            return obj.data;
+          },
+          /**
+           * Resolves the object `objId` with optional `data`.
+           */
+          resolve: function PDFObjects_resolve(objId, data) {
+            var obj = this.ensureObj(objId);
+            obj.resolved = true;
+            obj.data = data;
+            obj.capability.resolve(data);
+          },
+          isResolved: function PDFObjects_isResolved(objId) {
+            var objs = this.objs;
+            if (!objs[objId]) {
+              return false;
+            } else {
+              return objs[objId].resolved;
+            }
+          },
+          hasData: function PDFObjects_hasData(objId) {
+            return this.isResolved(objId);
+          },
+          /**
+           * Returns the data of `objId` if object exists, null otherwise.
+           */
+          getData: function PDFObjects_getData(objId) {
+            var objs = this.objs;
+            if (!objs[objId] || !objs[objId].resolved) {
+              return null;
+            } else {
+              return objs[objId].data;
+            }
+          },
+          clear: function PDFObjects_clear() {
+            this.objs = Object.create(null);
+          }
+        };
+        return PDFObjects;
+      }();
+      /**
+       * Allows controlling of the rendering tasks.
+       * @class
+       * @alias RenderTask
+       */
+      var RenderTask = function RenderTaskClosure() {
+        function RenderTask(internalRenderTask) {
+          this._internalRenderTask = internalRenderTask;
+          /**
+           * Callback for incremental rendering -- a function that will be called
+           * each time the rendering is paused.  To continue rendering call the
+           * function that is the first argument to the callback.
+           * @type {function}
+           */
+          this.onContinue = null;
+        }
+        RenderTask.prototype = /** @lends RenderTask.prototype */
+        {
+          /**
+           * Promise for rendering task completion.
+           * @return {Promise}
+           */
+          get promise() {
+            return this._internalRenderTask.capability.promise;
+          },
+          /**
+           * Cancels the rendering task. If the task is currently rendering it will
+           * not be cancelled until graphics pauses with a timeout. The promise that
+           * this object extends will resolved when cancelled.
+           */
+          cancel: function RenderTask_cancel() {
+            this._internalRenderTask.cancel();
+          },
+          /**
+           * Registers callbacks to indicate the rendering task completion.
+           *
+           * @param {function} onFulfilled The callback for the rendering completion.
+           * @param {function} onRejected The callback for the rendering failure.
+           * @return {Promise} A promise that is resolved after the onFulfilled or
+           *                   onRejected callback.
+           */
+          then: function RenderTask_then(onFulfilled, onRejected) {
+            return this.promise.then.apply(this.promise, arguments);
+          }
+        };
+        return RenderTask;
+      }();
+      /**
+       * For internal use only.
+       * @ignore
+       */
+      var InternalRenderTask = function InternalRenderTaskClosure() {
+        function InternalRenderTask(callback, params, objs, commonObjs, operatorList, pageNumber) {
+          this.callback = callback;
+          this.params = params;
+          this.objs = objs;
+          this.commonObjs = commonObjs;
+          this.operatorListIdx = null;
+          this.operatorList = operatorList;
+          this.pageNumber = pageNumber;
+          this.running = false;
+          this.graphicsReadyCallback = null;
+          this.graphicsReady = false;
+          this.useRequestAnimationFrame = false;
+          this.cancelled = false;
+          this.capability = createPromiseCapability();
+          this.task = new RenderTask(this);
+          // caching this-bound methods
+          this._continueBound = this._continue.bind(this);
+          this._scheduleNextBound = this._scheduleNext.bind(this);
+          this._nextBound = this._next.bind(this);
+        }
+        InternalRenderTask.prototype = {
+          initializeGraphics: function InternalRenderTask_initializeGraphics(transparency) {
+            if (this.cancelled) {
+              return;
+            }
+            if (getDefaultSetting('pdfBug') && globalScope.StepperManager && globalScope.StepperManager.enabled) {
+              this.stepper = globalScope.StepperManager.create(this.pageNumber - 1);
+              this.stepper.init(this.operatorList);
+              this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
+            }
+            var params = this.params;
+            this.gfx = new CanvasGraphics(params.canvasContext, this.commonObjs, this.objs, params.imageLayer);
+            this.gfx.beginDrawing(params.transform, params.viewport, transparency);
+            this.operatorListIdx = 0;
+            this.graphicsReady = true;
+            if (this.graphicsReadyCallback) {
+              this.graphicsReadyCallback();
+            }
+          },
+          cancel: function InternalRenderTask_cancel() {
+            this.running = false;
+            this.cancelled = true;
+            this.callback('cancelled');
+          },
+          operatorListChanged: function InternalRenderTask_operatorListChanged() {
+            if (!this.graphicsReady) {
+              if (!this.graphicsReadyCallback) {
+                this.graphicsReadyCallback = this._continueBound;
+              }
+              return;
+            }
+            if (this.stepper) {
+              this.stepper.updateOperatorList(this.operatorList);
+            }
+            if (this.running) {
+              return;
+            }
+            this._continue();
+          },
+          _continue: function InternalRenderTask__continue() {
+            this.running = true;
+            if (this.cancelled) {
+              return;
+            }
+            if (this.task.onContinue) {
+              this.task.onContinue.call(this.task, this._scheduleNextBound);
+            } else {
+              this._scheduleNext();
+            }
+          },
+          _scheduleNext: function InternalRenderTask__scheduleNext() {
+            if (this.useRequestAnimationFrame && typeof window !== 'undefined') {
+              window.requestAnimationFrame(this._nextBound);
+            } else {
+              Promise.resolve(undefined).then(this._nextBound);
+            }
+          },
+          _next: function InternalRenderTask__next() {
+            if (this.cancelled) {
+              return;
+            }
+            this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
+            if (this.operatorListIdx === this.operatorList.argsArray.length) {
+              this.running = false;
+              if (this.operatorList.lastChunk) {
+                this.gfx.endDrawing();
+                this.callback();
+              }
+            }
+          }
+        };
+        return InternalRenderTask;
+      }();
+      /**
+       * (Deprecated) Global observer of unsupported feature usages. Use
+       * onUnsupportedFeature callback of the {PDFDocumentLoadingTask} instance.
+       */
+      var _UnsupportedManager = function UnsupportedManagerClosure() {
+        var listeners = [];
+        return {
+          listen: function (cb) {
+            deprecated('Global UnsupportedManager.listen is used: ' + ' use PDFDocumentLoadingTask.onUnsupportedFeature instead');
+            listeners.push(cb);
+          },
+          notify: function (featureId) {
+            for (var i = 0, ii = listeners.length; i < ii; i++) {
+              listeners[i](featureId);
+            }
+          }
+        };
+      }();
+      if (typeof pdfjsVersion !== 'undefined') {
+        exports.version = pdfjsVersion;
+      }
+      if (typeof pdfjsBuild !== 'undefined') {
+        exports.build = pdfjsBuild;
+      }
+      exports.getDocument = getDocument;
+      exports.PDFDataRangeTransport = PDFDataRangeTransport;
+      exports.PDFWorker = PDFWorker;
+      exports.PDFDocumentProxy = PDFDocumentProxy;
+      exports.PDFPageProxy = PDFPageProxy;
+      exports._UnsupportedManager = _UnsupportedManager;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsDisplayGlobal = {}, root.pdfjsSharedUtil, root.pdfjsDisplayDOMUtils, root.pdfjsDisplayAPI, root.pdfjsDisplayAnnotationLayer, root.pdfjsDisplayTextLayer, root.pdfjsDisplayMetadata, root.pdfjsDisplaySVG);
+    }(this, function (exports, sharedUtil, displayDOMUtils, displayAPI, displayAnnotationLayer, displayTextLayer, displayMetadata, displaySVG) {
+      var globalScope = sharedUtil.globalScope;
+      var deprecated = sharedUtil.deprecated;
+      var warn = sharedUtil.warn;
+      var LinkTarget = displayDOMUtils.LinkTarget;
+      var isWorker = typeof window === 'undefined';
+      // The global PDFJS object is now deprecated and will not be supported in
+      // the future. The members below are maintained for backward  compatibility
+      // and shall not be extended or modified. If the global.js is included as
+      // a module, we will create a global PDFJS object instance or use existing.
+      if (!globalScope.PDFJS) {
+        globalScope.PDFJS = {};
+      }
+      var PDFJS = globalScope.PDFJS;
+      if (typeof pdfjsVersion !== 'undefined') {
+        PDFJS.version = pdfjsVersion;
+      }
+      if (typeof pdfjsBuild !== 'undefined') {
+        PDFJS.build = pdfjsBuild;
+      }
+      PDFJS.pdfBug = false;
+      if (PDFJS.verbosity !== undefined) {
+        sharedUtil.setVerbosityLevel(PDFJS.verbosity);
+      }
+      delete PDFJS.verbosity;
+      Object.defineProperty(PDFJS, 'verbosity', {
+        get: function () {
+          return sharedUtil.getVerbosityLevel();
+        },
+        set: function (level) {
+          sharedUtil.setVerbosityLevel(level);
+        },
+        enumerable: true,
+        configurable: true
+      });
+      PDFJS.VERBOSITY_LEVELS = sharedUtil.VERBOSITY_LEVELS;
+      PDFJS.OPS = sharedUtil.OPS;
+      PDFJS.UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES;
+      PDFJS.isValidUrl = displayDOMUtils.isValidUrl;
+      PDFJS.shadow = sharedUtil.shadow;
+      PDFJS.createBlob = sharedUtil.createBlob;
+      PDFJS.createObjectURL = function PDFJS_createObjectURL(data, contentType) {
+        return sharedUtil.createObjectURL(data, contentType, PDFJS.disableCreateObjectURL);
+      };
+      Object.defineProperty(PDFJS, 'isLittleEndian', {
+        configurable: true,
+        get: function PDFJS_isLittleEndian() {
+          var value = sharedUtil.isLittleEndian();
+          return sharedUtil.shadow(PDFJS, 'isLittleEndian', value);
+        }
+      });
+      PDFJS.removeNullCharacters = sharedUtil.removeNullCharacters;
+      PDFJS.PasswordResponses = sharedUtil.PasswordResponses;
+      PDFJS.PasswordException = sharedUtil.PasswordException;
+      PDFJS.UnknownErrorException = sharedUtil.UnknownErrorException;
+      PDFJS.InvalidPDFException = sharedUtil.InvalidPDFException;
+      PDFJS.MissingPDFException = sharedUtil.MissingPDFException;
+      PDFJS.UnexpectedResponseException = sharedUtil.UnexpectedResponseException;
+      PDFJS.Util = sharedUtil.Util;
+      PDFJS.PageViewport = sharedUtil.PageViewport;
+      PDFJS.createPromiseCapability = sharedUtil.createPromiseCapability;
+      /**
+       * The maximum allowed image size in total pixels e.g. width * height. Images
+       * above this value will not be drawn. Use -1 for no limit.
+       * @var {number}
+       */
+      PDFJS.maxImageSize = PDFJS.maxImageSize === undefined ? -1 : PDFJS.maxImageSize;
+      /**
+       * The url of where the predefined Adobe CMaps are located. Include trailing
+       * slash.
+       * @var {string}
+       */
+      PDFJS.cMapUrl = PDFJS.cMapUrl === undefined ? null : PDFJS.cMapUrl;
+      /**
+       * Specifies if CMaps are binary packed.
+       * @var {boolean}
+       */
+      PDFJS.cMapPacked = PDFJS.cMapPacked === undefined ? false : PDFJS.cMapPacked;
+      /**
+       * By default fonts are converted to OpenType fonts and loaded via font face
+       * rules. If disabled, the font will be rendered using a built in font
+       * renderer that constructs the glyphs with primitive path commands.
+       * @var {boolean}
+       */
+      PDFJS.disableFontFace = PDFJS.disableFontFace === undefined ? false : PDFJS.disableFontFace;
+      /**
+       * Path for image resources, mainly for annotation icons. Include trailing
+       * slash.
+       * @var {string}
+       */
+      PDFJS.imageResourcesPath = PDFJS.imageResourcesPath === undefined ? '' : PDFJS.imageResourcesPath;
+      /**
+       * Disable the web worker and run all code on the main thread. This will
+       * happen automatically if the browser doesn't support workers or sending
+       * typed arrays to workers.
+       * @var {boolean}
+       */
+      PDFJS.disableWorker = PDFJS.disableWorker === undefined ? false : PDFJS.disableWorker;
+      /**
+       * Path and filename of the worker file. Required when the worker is enabled
+       * in development mode. If unspecified in the production build, the worker
+       * will be loaded based on the location of the pdf.js file. It is recommended
+       * that the workerSrc is set in a custom application to prevent issues caused
+       * by third-party frameworks and libraries.
+       * @var {string}
+       */
+      PDFJS.workerSrc = PDFJS.workerSrc === undefined ? null : PDFJS.workerSrc;
+      /**
+       * Disable range request loading of PDF files. When enabled and if the server
+       * supports partial content requests then the PDF will be fetched in chunks.
+       * Enabled (false) by default.
+       * @var {boolean}
+       */
+      PDFJS.disableRange = PDFJS.disableRange === undefined ? false : PDFJS.disableRange;
+      /**
+       * Disable streaming of PDF file data. By default PDF.js attempts to load PDF
+       * in chunks. This default behavior can be disabled.
+       * @var {boolean}
+       */
+      PDFJS.disableStream = PDFJS.disableStream === undefined ? false : PDFJS.disableStream;
+      /**
+       * Disable pre-fetching of PDF file data. When range requests are enabled
+       * PDF.js will automatically keep fetching more data even if it isn't needed
+       * to display the current page. This default behavior can be disabled.
+       *
+       * NOTE: It is also necessary to disable streaming, see above,
+       *       in order for disabling of pre-fetching to work correctly.
+       * @var {boolean}
+       */
+      PDFJS.disableAutoFetch = PDFJS.disableAutoFetch === undefined ? false : PDFJS.disableAutoFetch;
+      /**
+       * Enables special hooks for debugging PDF.js.
+       * @var {boolean}
+       */
+      PDFJS.pdfBug = PDFJS.pdfBug === undefined ? false : PDFJS.pdfBug;
+      /**
+       * Enables transfer usage in postMessage for ArrayBuffers.
+       * @var {boolean}
+       */
+      PDFJS.postMessageTransfers = PDFJS.postMessageTransfers === undefined ? true : PDFJS.postMessageTransfers;
+      /**
+       * Disables URL.createObjectURL usage.
+       * @var {boolean}
+       */
+      PDFJS.disableCreateObjectURL = PDFJS.disableCreateObjectURL === undefined ? false : PDFJS.disableCreateObjectURL;
+      /**
+       * Disables WebGL usage.
+       * @var {boolean}
+       */
+      PDFJS.disableWebGL = PDFJS.disableWebGL === undefined ? true : PDFJS.disableWebGL;
+      /**
+       * Specifies the |target| attribute for external links.
+       * The constants from PDFJS.LinkTarget should be used:
+       *  - NONE [default]
+       *  - SELF
+       *  - BLANK
+       *  - PARENT
+       *  - TOP
+       * @var {number}
+       */
+      PDFJS.externalLinkTarget = PDFJS.externalLinkTarget === undefined ? LinkTarget.NONE : PDFJS.externalLinkTarget;
+      /**
+       * Specifies the |rel| attribute for external links. Defaults to stripping
+       * the referrer.
+       * @var {string}
+       */
+      PDFJS.externalLinkRel = PDFJS.externalLinkRel === undefined ? 'noreferrer' : PDFJS.externalLinkRel;
+      /**
+      * Determines if we can eval strings as JS. Primarily used to improve
+      * performance for font rendering.
+      * @var {boolean}
+      */
+      PDFJS.isEvalSupported = PDFJS.isEvalSupported === undefined ? true : PDFJS.isEvalSupported;
+      PDFJS.getDocument = displayAPI.getDocument;
+      PDFJS.PDFDataRangeTransport = displayAPI.PDFDataRangeTransport;
+      PDFJS.PDFWorker = displayAPI.PDFWorker;
+      Object.defineProperty(PDFJS, 'hasCanvasTypedArrays', {
+        configurable: true,
+        get: function PDFJS_hasCanvasTypedArrays() {
+          var value = displayDOMUtils.hasCanvasTypedArrays();
+          return sharedUtil.shadow(PDFJS, 'hasCanvasTypedArrays', value);
+        }
+      });
+      PDFJS.CustomStyle = displayDOMUtils.CustomStyle;
+      PDFJS.LinkTarget = LinkTarget;
+      PDFJS.addLinkAttributes = displayDOMUtils.addLinkAttributes;
+      PDFJS.getFilenameFromUrl = displayDOMUtils.getFilenameFromUrl;
+      PDFJS.isExternalLinkTargetSet = displayDOMUtils.isExternalLinkTargetSet;
+      PDFJS.AnnotationLayer = displayAnnotationLayer.AnnotationLayer;
+      PDFJS.renderTextLayer = displayTextLayer.renderTextLayer;
+      PDFJS.Metadata = displayMetadata.Metadata;
+      PDFJS.SVGGraphics = displaySVG.SVGGraphics;
+      PDFJS.UnsupportedManager = displayAPI._UnsupportedManager;
+      exports.globalScope = globalScope;
+      exports.isWorker = isWorker;
+      exports.PDFJS = globalScope.PDFJS;
+    }));
+  }.call(pdfjsLibs));
+  exports.PDFJS = pdfjsLibs.pdfjsDisplayGlobal.PDFJS;
+  exports.build = pdfjsLibs.pdfjsDisplayAPI.build;
+  exports.version = pdfjsLibs.pdfjsDisplayAPI.version;
+  exports.getDocument = pdfjsLibs.pdfjsDisplayAPI.getDocument;
+  exports.PDFDataRangeTransport = pdfjsLibs.pdfjsDisplayAPI.PDFDataRangeTransport;
+  exports.PDFWorker = pdfjsLibs.pdfjsDisplayAPI.PDFWorker;
+  exports.renderTextLayer = pdfjsLibs.pdfjsDisplayTextLayer.renderTextLayer;
+  exports.AnnotationLayer = pdfjsLibs.pdfjsDisplayAnnotationLayer.AnnotationLayer;
+  exports.CustomStyle = pdfjsLibs.pdfjsDisplayDOMUtils.CustomStyle;
+  exports.PasswordResponses = pdfjsLibs.pdfjsSharedUtil.PasswordResponses;
+  exports.InvalidPDFException = pdfjsLibs.pdfjsSharedUtil.InvalidPDFException;
+  exports.MissingPDFException = pdfjsLibs.pdfjsSharedUtil.MissingPDFException;
+  exports.SVGGraphics = pdfjsLibs.pdfjsDisplaySVG.SVGGraphics;
+  exports.UnexpectedResponseException = pdfjsLibs.pdfjsSharedUtil.UnexpectedResponseException;
+  exports.OPS = pdfjsLibs.pdfjsSharedUtil.OPS;
+  exports.UNSUPPORTED_FEATURES = pdfjsLibs.pdfjsSharedUtil.UNSUPPORTED_FEATURES;
+  exports.isValidUrl = pdfjsLibs.pdfjsDisplayDOMUtils.isValidUrl;
+  exports.createValidAbsoluteUrl = pdfjsLibs.pdfjsSharedUtil.createValidAbsoluteUrl;
+  exports.createObjectURL = pdfjsLibs.pdfjsSharedUtil.createObjectURL;
+  exports.removeNullCharacters = pdfjsLibs.pdfjsSharedUtil.removeNullCharacters;
+  exports.shadow = pdfjsLibs.pdfjsSharedUtil.shadow;
+  exports.createBlob = pdfjsLibs.pdfjsSharedUtil.createBlob;
+  exports.getFilenameFromUrl = pdfjsLibs.pdfjsDisplayDOMUtils.getFilenameFromUrl;
+  exports.addLinkAttributes = pdfjsLibs.pdfjsDisplayDOMUtils.addLinkAttributes;
+}));
\ No newline at end of file
diff --git a/application/basilisk/extensions/pdfjs/content/build/pdf.worker.js b/application/basilisk/extensions/pdfjs/content/build/pdf.worker.js
new file mode 100644
index 000000000..6ce519940
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/build/pdf.worker.js
@@ -0,0 +1,52500 @@
+/* Copyright 2012 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 (root, factory) {
+  'use strict';
+  if (typeof define === 'function' && define.amd) {
+    define('pdfjs-dist/build/pdf.worker', ['exports'], factory);
+  } else if (typeof exports !== 'undefined') {
+    factory(exports);
+  } else {
+    factory(root['pdfjsDistBuildPdfWorker'] = {});
+  }
+}(this, function (exports) {
+  // Use strict in our context only - users might not want it
+  'use strict';
+  var pdfjsVersion = '1.6.315';
+  var pdfjsBuild = 'a139c75';
+  var pdfjsFilePath = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : null;
+  var pdfjsLibs = {};
+  (function pdfjsWrapper() {
+    (function (root, factory) {
+      factory(root.pdfjsCoreArithmeticDecoder = {});
+    }(this, function (exports) {
+      /* This class implements the QM Coder decoding as defined in
+       *   JPEG 2000 Part I Final Committee Draft Version 1.0
+       *   Annex C.3 Arithmetic decoding procedure
+       * available at http://www.jpeg.org/public/fcd15444-1.pdf
+       *
+       * The arithmetic decoder is used in conjunction with context models to decode
+       * JPEG2000 and JBIG2 streams.
+       */
+      var ArithmeticDecoder = function ArithmeticDecoderClosure() {
+        // Table C-2
+        var QeTable = [
+          {
+            qe: 0x5601,
+            nmps: 1,
+            nlps: 1,
+            switchFlag: 1
+          },
+          {
+            qe: 0x3401,
+            nmps: 2,
+            nlps: 6,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1801,
+            nmps: 3,
+            nlps: 9,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0AC1,
+            nmps: 4,
+            nlps: 12,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0521,
+            nmps: 5,
+            nlps: 29,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0221,
+            nmps: 38,
+            nlps: 33,
+            switchFlag: 0
+          },
+          {
+            qe: 0x5601,
+            nmps: 7,
+            nlps: 6,
+            switchFlag: 1
+          },
+          {
+            qe: 0x5401,
+            nmps: 8,
+            nlps: 14,
+            switchFlag: 0
+          },
+          {
+            qe: 0x4801,
+            nmps: 9,
+            nlps: 14,
+            switchFlag: 0
+          },
+          {
+            qe: 0x3801,
+            nmps: 10,
+            nlps: 14,
+            switchFlag: 0
+          },
+          {
+            qe: 0x3001,
+            nmps: 11,
+            nlps: 17,
+            switchFlag: 0
+          },
+          {
+            qe: 0x2401,
+            nmps: 12,
+            nlps: 18,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1C01,
+            nmps: 13,
+            nlps: 20,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1601,
+            nmps: 29,
+            nlps: 21,
+            switchFlag: 0
+          },
+          {
+            qe: 0x5601,
+            nmps: 15,
+            nlps: 14,
+            switchFlag: 1
+          },
+          {
+            qe: 0x5401,
+            nmps: 16,
+            nlps: 14,
+            switchFlag: 0
+          },
+          {
+            qe: 0x5101,
+            nmps: 17,
+            nlps: 15,
+            switchFlag: 0
+          },
+          {
+            qe: 0x4801,
+            nmps: 18,
+            nlps: 16,
+            switchFlag: 0
+          },
+          {
+            qe: 0x3801,
+            nmps: 19,
+            nlps: 17,
+            switchFlag: 0
+          },
+          {
+            qe: 0x3401,
+            nmps: 20,
+            nlps: 18,
+            switchFlag: 0
+          },
+          {
+            qe: 0x3001,
+            nmps: 21,
+            nlps: 19,
+            switchFlag: 0
+          },
+          {
+            qe: 0x2801,
+            nmps: 22,
+            nlps: 19,
+            switchFlag: 0
+          },
+          {
+            qe: 0x2401,
+            nmps: 23,
+            nlps: 20,
+            switchFlag: 0
+          },
+          {
+            qe: 0x2201,
+            nmps: 24,
+            nlps: 21,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1C01,
+            nmps: 25,
+            nlps: 22,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1801,
+            nmps: 26,
+            nlps: 23,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1601,
+            nmps: 27,
+            nlps: 24,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1401,
+            nmps: 28,
+            nlps: 25,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1201,
+            nmps: 29,
+            nlps: 26,
+            switchFlag: 0
+          },
+          {
+            qe: 0x1101,
+            nmps: 30,
+            nlps: 27,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0AC1,
+            nmps: 31,
+            nlps: 28,
+            switchFlag: 0
+          },
+          {
+            qe: 0x09C1,
+            nmps: 32,
+            nlps: 29,
+            switchFlag: 0
+          },
+          {
+            qe: 0x08A1,
+            nmps: 33,
+            nlps: 30,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0521,
+            nmps: 34,
+            nlps: 31,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0441,
+            nmps: 35,
+            nlps: 32,
+            switchFlag: 0
+          },
+          {
+            qe: 0x02A1,
+            nmps: 36,
+            nlps: 33,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0221,
+            nmps: 37,
+            nlps: 34,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0141,
+            nmps: 38,
+            nlps: 35,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0111,
+            nmps: 39,
+            nlps: 36,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0085,
+            nmps: 40,
+            nlps: 37,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0049,
+            nmps: 41,
+            nlps: 38,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0025,
+            nmps: 42,
+            nlps: 39,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0015,
+            nmps: 43,
+            nlps: 40,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0009,
+            nmps: 44,
+            nlps: 41,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0005,
+            nmps: 45,
+            nlps: 42,
+            switchFlag: 0
+          },
+          {
+            qe: 0x0001,
+            nmps: 45,
+            nlps: 43,
+            switchFlag: 0
+          },
+          {
+            qe: 0x5601,
+            nmps: 46,
+            nlps: 46,
+            switchFlag: 0
+          }
+        ];
+        // C.3.5 Initialisation of the decoder (INITDEC)
+        function ArithmeticDecoder(data, start, end) {
+          this.data = data;
+          this.bp = start;
+          this.dataEnd = end;
+          this.chigh = data[start];
+          this.clow = 0;
+          this.byteIn();
+          this.chigh = this.chigh << 7 & 0xFFFF | this.clow >> 9 & 0x7F;
+          this.clow = this.clow << 7 & 0xFFFF;
+          this.ct -= 7;
+          this.a = 0x8000;
+        }
+        ArithmeticDecoder.prototype = {
+          // C.3.4 Compressed data input (BYTEIN)
+          byteIn: function ArithmeticDecoder_byteIn() {
+            var data = this.data;
+            var bp = this.bp;
+            if (data[bp] === 0xFF) {
+              var b1 = data[bp + 1];
+              if (b1 > 0x8F) {
+                this.clow += 0xFF00;
+                this.ct = 8;
+              } else {
+                bp++;
+                this.clow += data[bp] << 9;
+                this.ct = 7;
+                this.bp = bp;
+              }
+            } else {
+              bp++;
+              this.clow += bp < this.dataEnd ? data[bp] << 8 : 0xFF00;
+              this.ct = 8;
+              this.bp = bp;
+            }
+            if (this.clow > 0xFFFF) {
+              this.chigh += this.clow >> 16;
+              this.clow &= 0xFFFF;
+            }
+          },
+          // C.3.2 Decoding a decision (DECODE)
+          readBit: function ArithmeticDecoder_readBit(contexts, pos) {
+            // contexts are packed into 1 byte:
+            // highest 7 bits carry cx.index, lowest bit carries cx.mps
+            var cx_index = contexts[pos] >> 1, cx_mps = contexts[pos] & 1;
+            var qeTableIcx = QeTable[cx_index];
+            var qeIcx = qeTableIcx.qe;
+            var d;
+            var a = this.a - qeIcx;
+            if (this.chigh < qeIcx) {
+              // exchangeLps
+              if (a < qeIcx) {
+                a = qeIcx;
+                d = cx_mps;
+                cx_index = qeTableIcx.nmps;
+              } else {
+                a = qeIcx;
+                d = 1 ^ cx_mps;
+                if (qeTableIcx.switchFlag === 1) {
+                  cx_mps = d;
+                }
+                cx_index = qeTableIcx.nlps;
+              }
+            } else {
+              this.chigh -= qeIcx;
+              if ((a & 0x8000) !== 0) {
+                this.a = a;
+                return cx_mps;
+              }
+              // exchangeMps
+              if (a < qeIcx) {
+                d = 1 ^ cx_mps;
+                if (qeTableIcx.switchFlag === 1) {
+                  cx_mps = d;
+                }
+                cx_index = qeTableIcx.nlps;
+              } else {
+                d = cx_mps;
+                cx_index = qeTableIcx.nmps;
+              }
+            }
+            // C.3.3 renormD;
+            do {
+              if (this.ct === 0) {
+                this.byteIn();
+              }
+              a <<= 1;
+              this.chigh = this.chigh << 1 & 0xFFFF | this.clow >> 15 & 1;
+              this.clow = this.clow << 1 & 0xFFFF;
+              this.ct--;
+            } while ((a & 0x8000) === 0);
+            this.a = a;
+            contexts[pos] = cx_index << 1 | cx_mps;
+            return d;
+          }
+        };
+        return ArithmeticDecoder;
+      }();
+      exports.ArithmeticDecoder = ArithmeticDecoder;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreBidi = {});
+    }(this, function (exports) {
+      // Character types for symbols from 0000 to 00FF.
+      var baseTypes = [
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'S',
+        'B',
+        'S',
+        'WS',
+        'B',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'B',
+        'B',
+        'B',
+        'S',
+        'WS',
+        'ON',
+        'ON',
+        'ET',
+        'ET',
+        'ET',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'CS',
+        'ON',
+        'CS',
+        'ON',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'EN',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'B',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'BN',
+        'CS',
+        'ON',
+        'ET',
+        'ET',
+        'ET',
+        'ET',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'L',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ET',
+        'ET',
+        'EN',
+        'EN',
+        'ON',
+        'L',
+        'ON',
+        'ON',
+        'ON',
+        'EN',
+        'L',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'ON',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'ON',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'ON',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L',
+        'L'
+      ];
+      // Character types for symbols from 0600 to 06FF
+      var arabicTypes = [
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'CS',
+        'AL',
+        'ON',
+        'ON',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'AN',
+        'ET',
+        'AN',
+        'AN',
+        'AL',
+        'AL',
+        'AL',
+        'NSM',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'ON',
+        'NSM',
+        'NSM',
+        'NSM',
+        'NSM',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL',
+        'AL'
+      ];
+      function isOdd(i) {
+        return (i & 1) !== 0;
+      }
+      function isEven(i) {
+        return (i & 1) === 0;
+      }
+      function findUnequal(arr, start, value) {
+        for (var j = start, jj = arr.length; j < jj; ++j) {
+          if (arr[j] !== value) {
+            return j;
+          }
+        }
+        return j;
+      }
+      function setValues(arr, start, end, value) {
+        for (var j = start; j < end; ++j) {
+          arr[j] = value;
+        }
+      }
+      function reverseValues(arr, start, end) {
+        for (var i = start, j = end - 1; i < j; ++i, --j) {
+          var temp = arr[i];
+          arr[i] = arr[j];
+          arr[j] = temp;
+        }
+      }
+      function createBidiText(str, isLTR, vertical) {
+        return {
+          str: str,
+          dir: vertical ? 'ttb' : isLTR ? 'ltr' : 'rtl'
+        };
+      }
+      // These are used in bidi(), which is called frequently. We re-use them on
+      // each call to avoid unnecessary allocations.
+      var chars = [];
+      var types = [];
+      function bidi(str, startLevel, vertical) {
+        var isLTR = true;
+        var strLength = str.length;
+        if (strLength === 0 || vertical) {
+          return createBidiText(str, isLTR, vertical);
+        }
+        // Get types and fill arrays
+        chars.length = strLength;
+        types.length = strLength;
+        var numBidi = 0;
+        var i, ii;
+        for (i = 0; i < strLength; ++i) {
+          chars[i] = str.charAt(i);
+          var charCode = str.charCodeAt(i);
+          var charType = 'L';
+          if (charCode <= 0x00ff) {
+            charType = baseTypes[charCode];
+          } else if (0x0590 <= charCode && charCode <= 0x05f4) {
+            charType = 'R';
+          } else if (0x0600 <= charCode && charCode <= 0x06ff) {
+            charType = arabicTypes[charCode & 0xff];
+          } else if (0x0700 <= charCode && charCode <= 0x08AC) {
+            charType = 'AL';
+          }
+          if (charType === 'R' || charType === 'AL' || charType === 'AN') {
+            numBidi++;
+          }
+          types[i] = charType;
+        }
+        // Detect the bidi method
+        // - If there are no rtl characters then no bidi needed
+        // - If less than 30% chars are rtl then string is primarily ltr
+        // - If more than 30% chars are rtl then string is primarily rtl
+        if (numBidi === 0) {
+          isLTR = true;
+          return createBidiText(str, isLTR);
+        }
+        if (startLevel === -1) {
+          if (strLength / numBidi < 0.3) {
+            isLTR = true;
+            startLevel = 0;
+          } else {
+            isLTR = false;
+            startLevel = 1;
+          }
+        }
+        var levels = [];
+        for (i = 0; i < strLength; ++i) {
+          levels[i] = startLevel;
+        }
+        /*
+         X1-X10: skip most of this, since we are NOT doing the embeddings.
+         */
+        var e = isOdd(startLevel) ? 'R' : 'L';
+        var sor = e;
+        var eor = sor;
+        /*
+         W1. Examine each non-spacing mark (NSM) in the level run, and change the
+         type of the NSM to the type of the previous character. If the NSM is at the
+         start of the level run, it will get the type of sor.
+         */
+        var lastType = sor;
+        for (i = 0; i < strLength; ++i) {
+          if (types[i] === 'NSM') {
+            types[i] = lastType;
+          } else {
+            lastType = types[i];
+          }
+        }
+        /*
+         W2. Search backwards from each instance of a European number until the
+         first strong type (R, L, AL, or sor) is found.  If an AL is found, change
+         the type of the European number to Arabic number.
+         */
+        lastType = sor;
+        var t;
+        for (i = 0; i < strLength; ++i) {
+          t = types[i];
+          if (t === 'EN') {
+            types[i] = lastType === 'AL' ? 'AN' : 'EN';
+          } else if (t === 'R' || t === 'L' || t === 'AL') {
+            lastType = t;
+          }
+        }
+        /*
+         W3. Change all ALs to R.
+         */
+        for (i = 0; i < strLength; ++i) {
+          t = types[i];
+          if (t === 'AL') {
+            types[i] = 'R';
+          }
+        }
+        /*
+         W4. A single European separator between two European numbers changes to a
+         European number. A single common separator between two numbers of the same
+         type changes to that type:
+         */
+        for (i = 1; i < strLength - 1; ++i) {
+          if (types[i] === 'ES' && types[i - 1] === 'EN' && types[i + 1] === 'EN') {
+            types[i] = 'EN';
+          }
+          if (types[i] === 'CS' && (types[i - 1] === 'EN' || types[i - 1] === 'AN') && types[i + 1] === types[i - 1]) {
+            types[i] = types[i - 1];
+          }
+        }
+        /*
+         W5. A sequence of European terminators adjacent to European numbers changes
+         to all European numbers:
+         */
+        for (i = 0; i < strLength; ++i) {
+          if (types[i] === 'EN') {
+            // do before
+            var j;
+            for (j = i - 1; j >= 0; --j) {
+              if (types[j] !== 'ET') {
+                break;
+              }
+              types[j] = 'EN';
+            }
+            // do after
+            for (j = i + 1; j < strLength; ++j) {
+              if (types[j] !== 'ET') {
+                break;
+              }
+              types[j] = 'EN';
+            }
+          }
+        }
+        /*
+         W6. Otherwise, separators and terminators change to Other Neutral:
+         */
+        for (i = 0; i < strLength; ++i) {
+          t = types[i];
+          if (t === 'WS' || t === 'ES' || t === 'ET' || t === 'CS') {
+            types[i] = 'ON';
+          }
+        }
+        /*
+         W7. Search backwards from each instance of a European number until the
+         first strong type (R, L, or sor) is found. If an L is found,  then change
+         the type of the European number to L.
+         */
+        lastType = sor;
+        for (i = 0; i < strLength; ++i) {
+          t = types[i];
+          if (t === 'EN') {
+            types[i] = lastType === 'L' ? 'L' : 'EN';
+          } else if (t === 'R' || t === 'L') {
+            lastType = t;
+          }
+        }
+        /*
+         N1. A sequence of neutrals takes the direction of the surrounding strong
+         text if the text on both sides has the same direction. European and Arabic
+         numbers are treated as though they were R. Start-of-level-run (sor) and
+         end-of-level-run (eor) are used at level run boundaries.
+         */
+        for (i = 0; i < strLength; ++i) {
+          if (types[i] === 'ON') {
+            var end = findUnequal(types, i + 1, 'ON');
+            var before = sor;
+            if (i > 0) {
+              before = types[i - 1];
+            }
+            var after = eor;
+            if (end + 1 < strLength) {
+              after = types[end + 1];
+            }
+            if (before !== 'L') {
+              before = 'R';
+            }
+            if (after !== 'L') {
+              after = 'R';
+            }
+            if (before === after) {
+              setValues(types, i, end, before);
+            }
+            i = end - 1;
+          }
+        }
+        // reset to end (-1 so next iteration is ok)
+        /*
+         N2. Any remaining neutrals take the embedding direction.
+         */
+        for (i = 0; i < strLength; ++i) {
+          if (types[i] === 'ON') {
+            types[i] = e;
+          }
+        }
+        /*
+         I1. For all characters with an even (left-to-right) embedding direction,
+         those of type R go up one level and those of type AN or EN go up two
+         levels.
+         I2. For all characters with an odd (right-to-left) embedding direction,
+         those of type L, EN or AN go up one level.
+         */
+        for (i = 0; i < strLength; ++i) {
+          t = types[i];
+          if (isEven(levels[i])) {
+            if (t === 'R') {
+              levels[i] += 1;
+            } else if (t === 'AN' || t === 'EN') {
+              levels[i] += 2;
+            }
+          } else {
+            // isOdd
+            if (t === 'L' || t === 'AN' || t === 'EN') {
+              levels[i] += 1;
+            }
+          }
+        }
+        /*
+             L1. On each line, reset the embedding level of the following characters to
+             the paragraph embedding level:
+        
+             segment separators,
+             paragraph separators,
+             any sequence of whitespace characters preceding a segment separator or
+             paragraph separator, and any sequence of white space characters at the end
+             of the line.
+             */
+        // don't bother as text is only single line
+        /*
+         L2. From the highest level found in the text to the lowest odd level on
+         each line, reverse any contiguous sequence of characters that are at that
+         level or higher.
+         */
+        // find highest level & lowest odd level
+        var highestLevel = -1;
+        var lowestOddLevel = 99;
+        var level;
+        for (i = 0, ii = levels.length; i < ii; ++i) {
+          level = levels[i];
+          if (highestLevel < level) {
+            highestLevel = level;
+          }
+          if (lowestOddLevel > level && isOdd(level)) {
+            lowestOddLevel = level;
+          }
+        }
+        // now reverse between those limits
+        for (level = highestLevel; level >= lowestOddLevel; --level) {
+          // find segments to reverse
+          var start = -1;
+          for (i = 0, ii = levels.length; i < ii; ++i) {
+            if (levels[i] < level) {
+              if (start >= 0) {
+                reverseValues(chars, start, i);
+                start = -1;
+              }
+            } else if (start < 0) {
+              start = i;
+            }
+          }
+          if (start >= 0) {
+            reverseValues(chars, start, levels.length);
+          }
+        }
+        /*
+         L3. Combining marks applied to a right-to-left base character will at this
+         point precede their base character. If the rendering engine expects them to
+         follow the base characters in the final display process, then the ordering
+         of the marks and the base character must be reversed.
+         */
+        // don't bother for now
+        /*
+         L4. A character that possesses the mirrored property as specified by
+         Section 4.7, Mirrored, must be depicted by a mirrored glyph if the resolved
+         directionality of that character is R.
+         */
+        // don't mirror as characters are already mirrored in the pdf
+        // Finally, return string
+        for (i = 0, ii = chars.length; i < ii; ++i) {
+          var ch = chars[i];
+          if (ch === '<' || ch === '>') {
+            chars[i] = '';
+          }
+        }
+        return createBidiText(chars.join(''), isLTR);
+      }
+      exports.bidi = bidi;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreCharsets = {});
+    }(this, function (exports) {
+      var ISOAdobeCharset = [
+        '.notdef',
+        'space',
+        'exclam',
+        'quotedbl',
+        'numbersign',
+        'dollar',
+        'percent',
+        'ampersand',
+        'quoteright',
+        'parenleft',
+        'parenright',
+        'asterisk',
+        'plus',
+        'comma',
+        'hyphen',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'at',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z',
+        'bracketleft',
+        'backslash',
+        'bracketright',
+        'asciicircum',
+        'underscore',
+        'quoteleft',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'braceleft',
+        'bar',
+        'braceright',
+        'asciitilde',
+        'exclamdown',
+        'cent',
+        'sterling',
+        'fraction',
+        'yen',
+        'florin',
+        'section',
+        'currency',
+        'quotesingle',
+        'quotedblleft',
+        'guillemotleft',
+        'guilsinglleft',
+        'guilsinglright',
+        'fi',
+        'fl',
+        'endash',
+        'dagger',
+        'daggerdbl',
+        'periodcentered',
+        'paragraph',
+        'bullet',
+        'quotesinglbase',
+        'quotedblbase',
+        'quotedblright',
+        'guillemotright',
+        'ellipsis',
+        'perthousand',
+        'questiondown',
+        'grave',
+        'acute',
+        'circumflex',
+        'tilde',
+        'macron',
+        'breve',
+        'dotaccent',
+        'dieresis',
+        'ring',
+        'cedilla',
+        'hungarumlaut',
+        'ogonek',
+        'caron',
+        'emdash',
+        'AE',
+        'ordfeminine',
+        'Lslash',
+        'Oslash',
+        'OE',
+        'ordmasculine',
+        'ae',
+        'dotlessi',
+        'lslash',
+        'oslash',
+        'oe',
+        'germandbls',
+        'onesuperior',
+        'logicalnot',
+        'mu',
+        'trademark',
+        'Eth',
+        'onehalf',
+        'plusminus',
+        'Thorn',
+        'onequarter',
+        'divide',
+        'brokenbar',
+        'degree',
+        'thorn',
+        'threequarters',
+        'twosuperior',
+        'registered',
+        'minus',
+        'eth',
+        'multiply',
+        'threesuperior',
+        'copyright',
+        'Aacute',
+        'Acircumflex',
+        'Adieresis',
+        'Agrave',
+        'Aring',
+        'Atilde',
+        'Ccedilla',
+        'Eacute',
+        'Ecircumflex',
+        'Edieresis',
+        'Egrave',
+        'Iacute',
+        'Icircumflex',
+        'Idieresis',
+        'Igrave',
+        'Ntilde',
+        'Oacute',
+        'Ocircumflex',
+        'Odieresis',
+        'Ograve',
+        'Otilde',
+        'Scaron',
+        'Uacute',
+        'Ucircumflex',
+        'Udieresis',
+        'Ugrave',
+        'Yacute',
+        'Ydieresis',
+        'Zcaron',
+        'aacute',
+        'acircumflex',
+        'adieresis',
+        'agrave',
+        'aring',
+        'atilde',
+        'ccedilla',
+        'eacute',
+        'ecircumflex',
+        'edieresis',
+        'egrave',
+        'iacute',
+        'icircumflex',
+        'idieresis',
+        'igrave',
+        'ntilde',
+        'oacute',
+        'ocircumflex',
+        'odieresis',
+        'ograve',
+        'otilde',
+        'scaron',
+        'uacute',
+        'ucircumflex',
+        'udieresis',
+        'ugrave',
+        'yacute',
+        'ydieresis',
+        'zcaron'
+      ];
+      var ExpertCharset = [
+        '.notdef',
+        'space',
+        'exclamsmall',
+        'Hungarumlautsmall',
+        'dollaroldstyle',
+        'dollarsuperior',
+        'ampersandsmall',
+        'Acutesmall',
+        'parenleftsuperior',
+        'parenrightsuperior',
+        'twodotenleader',
+        'onedotenleader',
+        'comma',
+        'hyphen',
+        'period',
+        'fraction',
+        'zerooldstyle',
+        'oneoldstyle',
+        'twooldstyle',
+        'threeoldstyle',
+        'fouroldstyle',
+        'fiveoldstyle',
+        'sixoldstyle',
+        'sevenoldstyle',
+        'eightoldstyle',
+        'nineoldstyle',
+        'colon',
+        'semicolon',
+        'commasuperior',
+        'threequartersemdash',
+        'periodsuperior',
+        'questionsmall',
+        'asuperior',
+        'bsuperior',
+        'centsuperior',
+        'dsuperior',
+        'esuperior',
+        'isuperior',
+        'lsuperior',
+        'msuperior',
+        'nsuperior',
+        'osuperior',
+        'rsuperior',
+        'ssuperior',
+        'tsuperior',
+        'ff',
+        'fi',
+        'fl',
+        'ffi',
+        'ffl',
+        'parenleftinferior',
+        'parenrightinferior',
+        'Circumflexsmall',
+        'hyphensuperior',
+        'Gravesmall',
+        'Asmall',
+        'Bsmall',
+        'Csmall',
+        'Dsmall',
+        'Esmall',
+        'Fsmall',
+        'Gsmall',
+        'Hsmall',
+        'Ismall',
+        'Jsmall',
+        'Ksmall',
+        'Lsmall',
+        'Msmall',
+        'Nsmall',
+        'Osmall',
+        'Psmall',
+        'Qsmall',
+        'Rsmall',
+        'Ssmall',
+        'Tsmall',
+        'Usmall',
+        'Vsmall',
+        'Wsmall',
+        'Xsmall',
+        'Ysmall',
+        'Zsmall',
+        'colonmonetary',
+        'onefitted',
+        'rupiah',
+        'Tildesmall',
+        'exclamdownsmall',
+        'centoldstyle',
+        'Lslashsmall',
+        'Scaronsmall',
+        'Zcaronsmall',
+        'Dieresissmall',
+        'Brevesmall',
+        'Caronsmall',
+        'Dotaccentsmall',
+        'Macronsmall',
+        'figuredash',
+        'hypheninferior',
+        'Ogoneksmall',
+        'Ringsmall',
+        'Cedillasmall',
+        'onequarter',
+        'onehalf',
+        'threequarters',
+        'questiondownsmall',
+        'oneeighth',
+        'threeeighths',
+        'fiveeighths',
+        'seveneighths',
+        'onethird',
+        'twothirds',
+        'zerosuperior',
+        'onesuperior',
+        'twosuperior',
+        'threesuperior',
+        'foursuperior',
+        'fivesuperior',
+        'sixsuperior',
+        'sevensuperior',
+        'eightsuperior',
+        'ninesuperior',
+        'zeroinferior',
+        'oneinferior',
+        'twoinferior',
+        'threeinferior',
+        'fourinferior',
+        'fiveinferior',
+        'sixinferior',
+        'seveninferior',
+        'eightinferior',
+        'nineinferior',
+        'centinferior',
+        'dollarinferior',
+        'periodinferior',
+        'commainferior',
+        'Agravesmall',
+        'Aacutesmall',
+        'Acircumflexsmall',
+        'Atildesmall',
+        'Adieresissmall',
+        'Aringsmall',
+        'AEsmall',
+        'Ccedillasmall',
+        'Egravesmall',
+        'Eacutesmall',
+        'Ecircumflexsmall',
+        'Edieresissmall',
+        'Igravesmall',
+        'Iacutesmall',
+        'Icircumflexsmall',
+        'Idieresissmall',
+        'Ethsmall',
+        'Ntildesmall',
+        'Ogravesmall',
+        'Oacutesmall',
+        'Ocircumflexsmall',
+        'Otildesmall',
+        'Odieresissmall',
+        'OEsmall',
+        'Oslashsmall',
+        'Ugravesmall',
+        'Uacutesmall',
+        'Ucircumflexsmall',
+        'Udieresissmall',
+        'Yacutesmall',
+        'Thornsmall',
+        'Ydieresissmall'
+      ];
+      var ExpertSubsetCharset = [
+        '.notdef',
+        'space',
+        'dollaroldstyle',
+        'dollarsuperior',
+        'parenleftsuperior',
+        'parenrightsuperior',
+        'twodotenleader',
+        'onedotenleader',
+        'comma',
+        'hyphen',
+        'period',
+        'fraction',
+        'zerooldstyle',
+        'oneoldstyle',
+        'twooldstyle',
+        'threeoldstyle',
+        'fouroldstyle',
+        'fiveoldstyle',
+        'sixoldstyle',
+        'sevenoldstyle',
+        'eightoldstyle',
+        'nineoldstyle',
+        'colon',
+        'semicolon',
+        'commasuperior',
+        'threequartersemdash',
+        'periodsuperior',
+        'asuperior',
+        'bsuperior',
+        'centsuperior',
+        'dsuperior',
+        'esuperior',
+        'isuperior',
+        'lsuperior',
+        'msuperior',
+        'nsuperior',
+        'osuperior',
+        'rsuperior',
+        'ssuperior',
+        'tsuperior',
+        'ff',
+        'fi',
+        'fl',
+        'ffi',
+        'ffl',
+        'parenleftinferior',
+        'parenrightinferior',
+        'hyphensuperior',
+        'colonmonetary',
+        'onefitted',
+        'rupiah',
+        'centoldstyle',
+        'figuredash',
+        'hypheninferior',
+        'onequarter',
+        'onehalf',
+        'threequarters',
+        'oneeighth',
+        'threeeighths',
+        'fiveeighths',
+        'seveneighths',
+        'onethird',
+        'twothirds',
+        'zerosuperior',
+        'onesuperior',
+        'twosuperior',
+        'threesuperior',
+        'foursuperior',
+        'fivesuperior',
+        'sixsuperior',
+        'sevensuperior',
+        'eightsuperior',
+        'ninesuperior',
+        'zeroinferior',
+        'oneinferior',
+        'twoinferior',
+        'threeinferior',
+        'fourinferior',
+        'fiveinferior',
+        'sixinferior',
+        'seveninferior',
+        'eightinferior',
+        'nineinferior',
+        'centinferior',
+        'dollarinferior',
+        'periodinferior',
+        'commainferior'
+      ];
+      exports.ISOAdobeCharset = ISOAdobeCharset;
+      exports.ExpertCharset = ExpertCharset;
+      exports.ExpertSubsetCharset = ExpertSubsetCharset;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreEncodings = {});
+    }(this, function (exports) {
+      var ExpertEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'exclamsmall',
+        'Hungarumlautsmall',
+        '',
+        'dollaroldstyle',
+        'dollarsuperior',
+        'ampersandsmall',
+        'Acutesmall',
+        'parenleftsuperior',
+        'parenrightsuperior',
+        'twodotenleader',
+        'onedotenleader',
+        'comma',
+        'hyphen',
+        'period',
+        'fraction',
+        'zerooldstyle',
+        'oneoldstyle',
+        'twooldstyle',
+        'threeoldstyle',
+        'fouroldstyle',
+        'fiveoldstyle',
+        'sixoldstyle',
+        'sevenoldstyle',
+        'eightoldstyle',
+        'nineoldstyle',
+        'colon',
+        'semicolon',
+        'commasuperior',
+        'threequartersemdash',
+        'periodsuperior',
+        'questionsmall',
+        '',
+        'asuperior',
+        'bsuperior',
+        'centsuperior',
+        'dsuperior',
+        'esuperior',
+        '',
+        '',
+        'isuperior',
+        '',
+        '',
+        'lsuperior',
+        'msuperior',
+        'nsuperior',
+        'osuperior',
+        '',
+        '',
+        'rsuperior',
+        'ssuperior',
+        'tsuperior',
+        '',
+        'ff',
+        'fi',
+        'fl',
+        'ffi',
+        'ffl',
+        'parenleftinferior',
+        '',
+        'parenrightinferior',
+        'Circumflexsmall',
+        'hyphensuperior',
+        'Gravesmall',
+        'Asmall',
+        'Bsmall',
+        'Csmall',
+        'Dsmall',
+        'Esmall',
+        'Fsmall',
+        'Gsmall',
+        'Hsmall',
+        'Ismall',
+        'Jsmall',
+        'Ksmall',
+        'Lsmall',
+        'Msmall',
+        'Nsmall',
+        'Osmall',
+        'Psmall',
+        'Qsmall',
+        'Rsmall',
+        'Ssmall',
+        'Tsmall',
+        'Usmall',
+        'Vsmall',
+        'Wsmall',
+        'Xsmall',
+        'Ysmall',
+        'Zsmall',
+        'colonmonetary',
+        'onefitted',
+        'rupiah',
+        'Tildesmall',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'exclamdownsmall',
+        'centoldstyle',
+        'Lslashsmall',
+        '',
+        '',
+        'Scaronsmall',
+        'Zcaronsmall',
+        'Dieresissmall',
+        'Brevesmall',
+        'Caronsmall',
+        '',
+        'Dotaccentsmall',
+        '',
+        '',
+        'Macronsmall',
+        '',
+        '',
+        'figuredash',
+        'hypheninferior',
+        '',
+        '',
+        'Ogoneksmall',
+        'Ringsmall',
+        'Cedillasmall',
+        '',
+        '',
+        '',
+        'onequarter',
+        'onehalf',
+        'threequarters',
+        'questiondownsmall',
+        'oneeighth',
+        'threeeighths',
+        'fiveeighths',
+        'seveneighths',
+        'onethird',
+        'twothirds',
+        '',
+        '',
+        'zerosuperior',
+        'onesuperior',
+        'twosuperior',
+        'threesuperior',
+        'foursuperior',
+        'fivesuperior',
+        'sixsuperior',
+        'sevensuperior',
+        'eightsuperior',
+        'ninesuperior',
+        'zeroinferior',
+        'oneinferior',
+        'twoinferior',
+        'threeinferior',
+        'fourinferior',
+        'fiveinferior',
+        'sixinferior',
+        'seveninferior',
+        'eightinferior',
+        'nineinferior',
+        'centinferior',
+        'dollarinferior',
+        'periodinferior',
+        'commainferior',
+        'Agravesmall',
+        'Aacutesmall',
+        'Acircumflexsmall',
+        'Atildesmall',
+        'Adieresissmall',
+        'Aringsmall',
+        'AEsmall',
+        'Ccedillasmall',
+        'Egravesmall',
+        'Eacutesmall',
+        'Ecircumflexsmall',
+        'Edieresissmall',
+        'Igravesmall',
+        'Iacutesmall',
+        'Icircumflexsmall',
+        'Idieresissmall',
+        'Ethsmall',
+        'Ntildesmall',
+        'Ogravesmall',
+        'Oacutesmall',
+        'Ocircumflexsmall',
+        'Otildesmall',
+        'Odieresissmall',
+        'OEsmall',
+        'Oslashsmall',
+        'Ugravesmall',
+        'Uacutesmall',
+        'Ucircumflexsmall',
+        'Udieresissmall',
+        'Yacutesmall',
+        'Thornsmall',
+        'Ydieresissmall'
+      ];
+      var MacExpertEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'exclamsmall',
+        'Hungarumlautsmall',
+        'centoldstyle',
+        'dollaroldstyle',
+        'dollarsuperior',
+        'ampersandsmall',
+        'Acutesmall',
+        'parenleftsuperior',
+        'parenrightsuperior',
+        'twodotenleader',
+        'onedotenleader',
+        'comma',
+        'hyphen',
+        'period',
+        'fraction',
+        'zerooldstyle',
+        'oneoldstyle',
+        'twooldstyle',
+        'threeoldstyle',
+        'fouroldstyle',
+        'fiveoldstyle',
+        'sixoldstyle',
+        'sevenoldstyle',
+        'eightoldstyle',
+        'nineoldstyle',
+        'colon',
+        'semicolon',
+        '',
+        'threequartersemdash',
+        '',
+        'questionsmall',
+        '',
+        '',
+        '',
+        '',
+        'Ethsmall',
+        '',
+        '',
+        'onequarter',
+        'onehalf',
+        'threequarters',
+        'oneeighth',
+        'threeeighths',
+        'fiveeighths',
+        'seveneighths',
+        'onethird',
+        'twothirds',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'ff',
+        'fi',
+        'fl',
+        'ffi',
+        'ffl',
+        'parenleftinferior',
+        '',
+        'parenrightinferior',
+        'Circumflexsmall',
+        'hypheninferior',
+        'Gravesmall',
+        'Asmall',
+        'Bsmall',
+        'Csmall',
+        'Dsmall',
+        'Esmall',
+        'Fsmall',
+        'Gsmall',
+        'Hsmall',
+        'Ismall',
+        'Jsmall',
+        'Ksmall',
+        'Lsmall',
+        'Msmall',
+        'Nsmall',
+        'Osmall',
+        'Psmall',
+        'Qsmall',
+        'Rsmall',
+        'Ssmall',
+        'Tsmall',
+        'Usmall',
+        'Vsmall',
+        'Wsmall',
+        'Xsmall',
+        'Ysmall',
+        'Zsmall',
+        'colonmonetary',
+        'onefitted',
+        'rupiah',
+        'Tildesmall',
+        '',
+        '',
+        'asuperior',
+        'centsuperior',
+        '',
+        '',
+        '',
+        '',
+        'Aacutesmall',
+        'Agravesmall',
+        'Acircumflexsmall',
+        'Adieresissmall',
+        'Atildesmall',
+        'Aringsmall',
+        'Ccedillasmall',
+        'Eacutesmall',
+        'Egravesmall',
+        'Ecircumflexsmall',
+        'Edieresissmall',
+        'Iacutesmall',
+        'Igravesmall',
+        'Icircumflexsmall',
+        'Idieresissmall',
+        'Ntildesmall',
+        'Oacutesmall',
+        'Ogravesmall',
+        'Ocircumflexsmall',
+        'Odieresissmall',
+        'Otildesmall',
+        'Uacutesmall',
+        'Ugravesmall',
+        'Ucircumflexsmall',
+        'Udieresissmall',
+        '',
+        'eightsuperior',
+        'fourinferior',
+        'threeinferior',
+        'sixinferior',
+        'eightinferior',
+        'seveninferior',
+        'Scaronsmall',
+        '',
+        'centinferior',
+        'twoinferior',
+        '',
+        'Dieresissmall',
+        '',
+        'Caronsmall',
+        'osuperior',
+        'fiveinferior',
+        '',
+        'commainferior',
+        'periodinferior',
+        'Yacutesmall',
+        '',
+        'dollarinferior',
+        '',
+        'Thornsmall',
+        '',
+        'nineinferior',
+        'zeroinferior',
+        'Zcaronsmall',
+        'AEsmall',
+        'Oslashsmall',
+        'questiondownsmall',
+        'oneinferior',
+        'Lslashsmall',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'Cedillasmall',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'OEsmall',
+        'figuredash',
+        'hyphensuperior',
+        '',
+        '',
+        '',
+        '',
+        'exclamdownsmall',
+        '',
+        'Ydieresissmall',
+        '',
+        'onesuperior',
+        'twosuperior',
+        'threesuperior',
+        'foursuperior',
+        'fivesuperior',
+        'sixsuperior',
+        'sevensuperior',
+        'ninesuperior',
+        'zerosuperior',
+        '',
+        'esuperior',
+        'rsuperior',
+        'tsuperior',
+        '',
+        '',
+        'isuperior',
+        'ssuperior',
+        'dsuperior',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'lsuperior',
+        'Ogoneksmall',
+        'Brevesmall',
+        'Macronsmall',
+        'bsuperior',
+        'nsuperior',
+        'msuperior',
+        'commasuperior',
+        'periodsuperior',
+        'Dotaccentsmall',
+        'Ringsmall'
+      ];
+      var MacRomanEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'exclam',
+        'quotedbl',
+        'numbersign',
+        'dollar',
+        'percent',
+        'ampersand',
+        'quotesingle',
+        'parenleft',
+        'parenright',
+        'asterisk',
+        'plus',
+        'comma',
+        'hyphen',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'at',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z',
+        'bracketleft',
+        'backslash',
+        'bracketright',
+        'asciicircum',
+        'underscore',
+        'grave',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'braceleft',
+        'bar',
+        'braceright',
+        'asciitilde',
+        '',
+        'Adieresis',
+        'Aring',
+        'Ccedilla',
+        'Eacute',
+        'Ntilde',
+        'Odieresis',
+        'Udieresis',
+        'aacute',
+        'agrave',
+        'acircumflex',
+        'adieresis',
+        'atilde',
+        'aring',
+        'ccedilla',
+        'eacute',
+        'egrave',
+        'ecircumflex',
+        'edieresis',
+        'iacute',
+        'igrave',
+        'icircumflex',
+        'idieresis',
+        'ntilde',
+        'oacute',
+        'ograve',
+        'ocircumflex',
+        'odieresis',
+        'otilde',
+        'uacute',
+        'ugrave',
+        'ucircumflex',
+        'udieresis',
+        'dagger',
+        'degree',
+        'cent',
+        'sterling',
+        'section',
+        'bullet',
+        'paragraph',
+        'germandbls',
+        'registered',
+        'copyright',
+        'trademark',
+        'acute',
+        'dieresis',
+        'notequal',
+        'AE',
+        'Oslash',
+        'infinity',
+        'plusminus',
+        'lessequal',
+        'greaterequal',
+        'yen',
+        'mu',
+        'partialdiff',
+        'summation',
+        'product',
+        'pi',
+        'integral',
+        'ordfeminine',
+        'ordmasculine',
+        'Omega',
+        'ae',
+        'oslash',
+        'questiondown',
+        'exclamdown',
+        'logicalnot',
+        'radical',
+        'florin',
+        'approxequal',
+        'Delta',
+        'guillemotleft',
+        'guillemotright',
+        'ellipsis',
+        'space',
+        'Agrave',
+        'Atilde',
+        'Otilde',
+        'OE',
+        'oe',
+        'endash',
+        'emdash',
+        'quotedblleft',
+        'quotedblright',
+        'quoteleft',
+        'quoteright',
+        'divide',
+        'lozenge',
+        'ydieresis',
+        'Ydieresis',
+        'fraction',
+        'currency',
+        'guilsinglleft',
+        'guilsinglright',
+        'fi',
+        'fl',
+        'daggerdbl',
+        'periodcentered',
+        'quotesinglbase',
+        'quotedblbase',
+        'perthousand',
+        'Acircumflex',
+        'Ecircumflex',
+        'Aacute',
+        'Edieresis',
+        'Egrave',
+        'Iacute',
+        'Icircumflex',
+        'Idieresis',
+        'Igrave',
+        'Oacute',
+        'Ocircumflex',
+        'apple',
+        'Ograve',
+        'Uacute',
+        'Ucircumflex',
+        'Ugrave',
+        'dotlessi',
+        'circumflex',
+        'tilde',
+        'macron',
+        'breve',
+        'dotaccent',
+        'ring',
+        'cedilla',
+        'hungarumlaut',
+        'ogonek',
+        'caron'
+      ];
+      var StandardEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'exclam',
+        'quotedbl',
+        'numbersign',
+        'dollar',
+        'percent',
+        'ampersand',
+        'quoteright',
+        'parenleft',
+        'parenright',
+        'asterisk',
+        'plus',
+        'comma',
+        'hyphen',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'at',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z',
+        'bracketleft',
+        'backslash',
+        'bracketright',
+        'asciicircum',
+        'underscore',
+        'quoteleft',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'braceleft',
+        'bar',
+        'braceright',
+        'asciitilde',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'exclamdown',
+        'cent',
+        'sterling',
+        'fraction',
+        'yen',
+        'florin',
+        'section',
+        'currency',
+        'quotesingle',
+        'quotedblleft',
+        'guillemotleft',
+        'guilsinglleft',
+        'guilsinglright',
+        'fi',
+        'fl',
+        '',
+        'endash',
+        'dagger',
+        'daggerdbl',
+        'periodcentered',
+        '',
+        'paragraph',
+        'bullet',
+        'quotesinglbase',
+        'quotedblbase',
+        'quotedblright',
+        'guillemotright',
+        'ellipsis',
+        'perthousand',
+        '',
+        'questiondown',
+        '',
+        'grave',
+        'acute',
+        'circumflex',
+        'tilde',
+        'macron',
+        'breve',
+        'dotaccent',
+        'dieresis',
+        '',
+        'ring',
+        'cedilla',
+        '',
+        'hungarumlaut',
+        'ogonek',
+        'caron',
+        'emdash',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'AE',
+        '',
+        'ordfeminine',
+        '',
+        '',
+        '',
+        '',
+        'Lslash',
+        'Oslash',
+        'OE',
+        'ordmasculine',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'ae',
+        '',
+        '',
+        '',
+        'dotlessi',
+        '',
+        '',
+        'lslash',
+        'oslash',
+        'oe',
+        'germandbls'
+      ];
+      var WinAnsiEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'exclam',
+        'quotedbl',
+        'numbersign',
+        'dollar',
+        'percent',
+        'ampersand',
+        'quotesingle',
+        'parenleft',
+        'parenright',
+        'asterisk',
+        'plus',
+        'comma',
+        'hyphen',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'at',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z',
+        'bracketleft',
+        'backslash',
+        'bracketright',
+        'asciicircum',
+        'underscore',
+        'grave',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'braceleft',
+        'bar',
+        'braceright',
+        'asciitilde',
+        'bullet',
+        'Euro',
+        'bullet',
+        'quotesinglbase',
+        'florin',
+        'quotedblbase',
+        'ellipsis',
+        'dagger',
+        'daggerdbl',
+        'circumflex',
+        'perthousand',
+        'Scaron',
+        'guilsinglleft',
+        'OE',
+        'bullet',
+        'Zcaron',
+        'bullet',
+        'bullet',
+        'quoteleft',
+        'quoteright',
+        'quotedblleft',
+        'quotedblright',
+        'bullet',
+        'endash',
+        'emdash',
+        'tilde',
+        'trademark',
+        'scaron',
+        'guilsinglright',
+        'oe',
+        'bullet',
+        'zcaron',
+        'Ydieresis',
+        'space',
+        'exclamdown',
+        'cent',
+        'sterling',
+        'currency',
+        'yen',
+        'brokenbar',
+        'section',
+        'dieresis',
+        'copyright',
+        'ordfeminine',
+        'guillemotleft',
+        'logicalnot',
+        'hyphen',
+        'registered',
+        'macron',
+        'degree',
+        'plusminus',
+        'twosuperior',
+        'threesuperior',
+        'acute',
+        'mu',
+        'paragraph',
+        'periodcentered',
+        'cedilla',
+        'onesuperior',
+        'ordmasculine',
+        'guillemotright',
+        'onequarter',
+        'onehalf',
+        'threequarters',
+        'questiondown',
+        'Agrave',
+        'Aacute',
+        'Acircumflex',
+        'Atilde',
+        'Adieresis',
+        'Aring',
+        'AE',
+        'Ccedilla',
+        'Egrave',
+        'Eacute',
+        'Ecircumflex',
+        'Edieresis',
+        'Igrave',
+        'Iacute',
+        'Icircumflex',
+        'Idieresis',
+        'Eth',
+        'Ntilde',
+        'Ograve',
+        'Oacute',
+        'Ocircumflex',
+        'Otilde',
+        'Odieresis',
+        'multiply',
+        'Oslash',
+        'Ugrave',
+        'Uacute',
+        'Ucircumflex',
+        'Udieresis',
+        'Yacute',
+        'Thorn',
+        'germandbls',
+        'agrave',
+        'aacute',
+        'acircumflex',
+        'atilde',
+        'adieresis',
+        'aring',
+        'ae',
+        'ccedilla',
+        'egrave',
+        'eacute',
+        'ecircumflex',
+        'edieresis',
+        'igrave',
+        'iacute',
+        'icircumflex',
+        'idieresis',
+        'eth',
+        'ntilde',
+        'ograve',
+        'oacute',
+        'ocircumflex',
+        'otilde',
+        'odieresis',
+        'divide',
+        'oslash',
+        'ugrave',
+        'uacute',
+        'ucircumflex',
+        'udieresis',
+        'yacute',
+        'thorn',
+        'ydieresis'
+      ];
+      var SymbolSetEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'exclam',
+        'universal',
+        'numbersign',
+        'existential',
+        'percent',
+        'ampersand',
+        'suchthat',
+        'parenleft',
+        'parenright',
+        'asteriskmath',
+        'plus',
+        'comma',
+        'minus',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'congruent',
+        'Alpha',
+        'Beta',
+        'Chi',
+        'Delta',
+        'Epsilon',
+        'Phi',
+        'Gamma',
+        'Eta',
+        'Iota',
+        'theta1',
+        'Kappa',
+        'Lambda',
+        'Mu',
+        'Nu',
+        'Omicron',
+        'Pi',
+        'Theta',
+        'Rho',
+        'Sigma',
+        'Tau',
+        'Upsilon',
+        'sigma1',
+        'Omega',
+        'Xi',
+        'Psi',
+        'Zeta',
+        'bracketleft',
+        'therefore',
+        'bracketright',
+        'perpendicular',
+        'underscore',
+        'radicalex',
+        'alpha',
+        'beta',
+        'chi',
+        'delta',
+        'epsilon',
+        'phi',
+        'gamma',
+        'eta',
+        'iota',
+        'phi1',
+        'kappa',
+        'lambda',
+        'mu',
+        'nu',
+        'omicron',
+        'pi',
+        'theta',
+        'rho',
+        'sigma',
+        'tau',
+        'upsilon',
+        'omega1',
+        'omega',
+        'xi',
+        'psi',
+        'zeta',
+        'braceleft',
+        'bar',
+        'braceright',
+        'similar',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'Euro',
+        'Upsilon1',
+        'minute',
+        'lessequal',
+        'fraction',
+        'infinity',
+        'florin',
+        'club',
+        'diamond',
+        'heart',
+        'spade',
+        'arrowboth',
+        'arrowleft',
+        'arrowup',
+        'arrowright',
+        'arrowdown',
+        'degree',
+        'plusminus',
+        'second',
+        'greaterequal',
+        'multiply',
+        'proportional',
+        'partialdiff',
+        'bullet',
+        'divide',
+        'notequal',
+        'equivalence',
+        'approxequal',
+        'ellipsis',
+        'arrowvertex',
+        'arrowhorizex',
+        'carriagereturn',
+        'aleph',
+        'Ifraktur',
+        'Rfraktur',
+        'weierstrass',
+        'circlemultiply',
+        'circleplus',
+        'emptyset',
+        'intersection',
+        'union',
+        'propersuperset',
+        'reflexsuperset',
+        'notsubset',
+        'propersubset',
+        'reflexsubset',
+        'element',
+        'notelement',
+        'angle',
+        'gradient',
+        'registerserif',
+        'copyrightserif',
+        'trademarkserif',
+        'product',
+        'radical',
+        'dotmath',
+        'logicalnot',
+        'logicaland',
+        'logicalor',
+        'arrowdblboth',
+        'arrowdblleft',
+        'arrowdblup',
+        'arrowdblright',
+        'arrowdbldown',
+        'lozenge',
+        'angleleft',
+        'registersans',
+        'copyrightsans',
+        'trademarksans',
+        'summation',
+        'parenlefttp',
+        'parenleftex',
+        'parenleftbt',
+        'bracketlefttp',
+        'bracketleftex',
+        'bracketleftbt',
+        'bracelefttp',
+        'braceleftmid',
+        'braceleftbt',
+        'braceex',
+        '',
+        'angleright',
+        'integral',
+        'integraltp',
+        'integralex',
+        'integralbt',
+        'parenrighttp',
+        'parenrightex',
+        'parenrightbt',
+        'bracketrighttp',
+        'bracketrightex',
+        'bracketrightbt',
+        'bracerighttp',
+        'bracerightmid',
+        'bracerightbt'
+      ];
+      var ZapfDingbatsEncoding = [
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'space',
+        'a1',
+        'a2',
+        'a202',
+        'a3',
+        'a4',
+        'a5',
+        'a119',
+        'a118',
+        'a117',
+        'a11',
+        'a12',
+        'a13',
+        'a14',
+        'a15',
+        'a16',
+        'a105',
+        'a17',
+        'a18',
+        'a19',
+        'a20',
+        'a21',
+        'a22',
+        'a23',
+        'a24',
+        'a25',
+        'a26',
+        'a27',
+        'a28',
+        'a6',
+        'a7',
+        'a8',
+        'a9',
+        'a10',
+        'a29',
+        'a30',
+        'a31',
+        'a32',
+        'a33',
+        'a34',
+        'a35',
+        'a36',
+        'a37',
+        'a38',
+        'a39',
+        'a40',
+        'a41',
+        'a42',
+        'a43',
+        'a44',
+        'a45',
+        'a46',
+        'a47',
+        'a48',
+        'a49',
+        'a50',
+        'a51',
+        'a52',
+        'a53',
+        'a54',
+        'a55',
+        'a56',
+        'a57',
+        'a58',
+        'a59',
+        'a60',
+        'a61',
+        'a62',
+        'a63',
+        'a64',
+        'a65',
+        'a66',
+        'a67',
+        'a68',
+        'a69',
+        'a70',
+        'a71',
+        'a72',
+        'a73',
+        'a74',
+        'a203',
+        'a75',
+        'a204',
+        'a76',
+        'a77',
+        'a78',
+        'a79',
+        'a81',
+        'a82',
+        'a83',
+        'a84',
+        'a97',
+        'a98',
+        'a99',
+        'a100',
+        '',
+        'a89',
+        'a90',
+        'a93',
+        'a94',
+        'a91',
+        'a92',
+        'a205',
+        'a85',
+        'a206',
+        'a86',
+        'a87',
+        'a88',
+        'a95',
+        'a96',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        'a101',
+        'a102',
+        'a103',
+        'a104',
+        'a106',
+        'a107',
+        'a108',
+        'a112',
+        'a111',
+        'a110',
+        'a109',
+        'a120',
+        'a121',
+        'a122',
+        'a123',
+        'a124',
+        'a125',
+        'a126',
+        'a127',
+        'a128',
+        'a129',
+        'a130',
+        'a131',
+        'a132',
+        'a133',
+        'a134',
+        'a135',
+        'a136',
+        'a137',
+        'a138',
+        'a139',
+        'a140',
+        'a141',
+        'a142',
+        'a143',
+        'a144',
+        'a145',
+        'a146',
+        'a147',
+        'a148',
+        'a149',
+        'a150',
+        'a151',
+        'a152',
+        'a153',
+        'a154',
+        'a155',
+        'a156',
+        'a157',
+        'a158',
+        'a159',
+        'a160',
+        'a161',
+        'a163',
+        'a164',
+        'a196',
+        'a165',
+        'a192',
+        'a166',
+        'a167',
+        'a168',
+        'a169',
+        'a170',
+        'a171',
+        'a172',
+        'a173',
+        'a162',
+        'a174',
+        'a175',
+        'a176',
+        'a177',
+        'a178',
+        'a179',
+        'a193',
+        'a180',
+        'a199',
+        'a181',
+        'a200',
+        'a182',
+        '',
+        'a201',
+        'a183',
+        'a184',
+        'a197',
+        'a185',
+        'a194',
+        'a198',
+        'a186',
+        'a195',
+        'a187',
+        'a188',
+        'a189',
+        'a190',
+        'a191'
+      ];
+      function getEncoding(encodingName) {
+        switch (encodingName) {
+        case 'WinAnsiEncoding':
+          return WinAnsiEncoding;
+        case 'StandardEncoding':
+          return StandardEncoding;
+        case 'MacRomanEncoding':
+          return MacRomanEncoding;
+        case 'SymbolSetEncoding':
+          return SymbolSetEncoding;
+        case 'ZapfDingbatsEncoding':
+          return ZapfDingbatsEncoding;
+        case 'ExpertEncoding':
+          return ExpertEncoding;
+        case 'MacExpertEncoding':
+          return MacExpertEncoding;
+        default:
+          return null;
+        }
+      }
+      exports.WinAnsiEncoding = WinAnsiEncoding;
+      exports.StandardEncoding = StandardEncoding;
+      exports.MacRomanEncoding = MacRomanEncoding;
+      exports.SymbolSetEncoding = SymbolSetEncoding;
+      exports.ZapfDingbatsEncoding = ZapfDingbatsEncoding;
+      exports.ExpertEncoding = ExpertEncoding;
+      exports.getEncoding = getEncoding;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsSharedUtil = {});
+    }(this, function (exports) {
+      var globalScope = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this;
+      var FONT_IDENTITY_MATRIX = [
+        0.001,
+        0,
+        0,
+        0.001,
+        0,
+        0
+      ];
+      var TextRenderingMode = {
+        FILL: 0,
+        STROKE: 1,
+        FILL_STROKE: 2,
+        INVISIBLE: 3,
+        FILL_ADD_TO_PATH: 4,
+        STROKE_ADD_TO_PATH: 5,
+        FILL_STROKE_ADD_TO_PATH: 6,
+        ADD_TO_PATH: 7,
+        FILL_STROKE_MASK: 3,
+        ADD_TO_PATH_FLAG: 4
+      };
+      var ImageKind = {
+        GRAYSCALE_1BPP: 1,
+        RGB_24BPP: 2,
+        RGBA_32BPP: 3
+      };
+      var AnnotationType = {
+        TEXT: 1,
+        LINK: 2,
+        FREETEXT: 3,
+        LINE: 4,
+        SQUARE: 5,
+        CIRCLE: 6,
+        POLYGON: 7,
+        POLYLINE: 8,
+        HIGHLIGHT: 9,
+        UNDERLINE: 10,
+        SQUIGGLY: 11,
+        STRIKEOUT: 12,
+        STAMP: 13,
+        CARET: 14,
+        INK: 15,
+        POPUP: 16,
+        FILEATTACHMENT: 17,
+        SOUND: 18,
+        MOVIE: 19,
+        WIDGET: 20,
+        SCREEN: 21,
+        PRINTERMARK: 22,
+        TRAPNET: 23,
+        WATERMARK: 24,
+        THREED: 25,
+        REDACT: 26
+      };
+      var AnnotationFlag = {
+        INVISIBLE: 0x01,
+        HIDDEN: 0x02,
+        PRINT: 0x04,
+        NOZOOM: 0x08,
+        NOROTATE: 0x10,
+        NOVIEW: 0x20,
+        READONLY: 0x40,
+        LOCKED: 0x80,
+        TOGGLENOVIEW: 0x100,
+        LOCKEDCONTENTS: 0x200
+      };
+      var AnnotationFieldFlag = {
+        READONLY: 0x0000001,
+        REQUIRED: 0x0000002,
+        NOEXPORT: 0x0000004,
+        MULTILINE: 0x0001000,
+        PASSWORD: 0x0002000,
+        NOTOGGLETOOFF: 0x0004000,
+        RADIO: 0x0008000,
+        PUSHBUTTON: 0x0010000,
+        COMBO: 0x0020000,
+        EDIT: 0x0040000,
+        SORT: 0x0080000,
+        FILESELECT: 0x0100000,
+        MULTISELECT: 0x0200000,
+        DONOTSPELLCHECK: 0x0400000,
+        DONOTSCROLL: 0x0800000,
+        COMB: 0x1000000,
+        RICHTEXT: 0x2000000,
+        RADIOSINUNISON: 0x2000000,
+        COMMITONSELCHANGE: 0x4000000
+      };
+      var AnnotationBorderStyleType = {
+        SOLID: 1,
+        DASHED: 2,
+        BEVELED: 3,
+        INSET: 4,
+        UNDERLINE: 5
+      };
+      var StreamType = {
+        UNKNOWN: 0,
+        FLATE: 1,
+        LZW: 2,
+        DCT: 3,
+        JPX: 4,
+        JBIG: 5,
+        A85: 6,
+        AHX: 7,
+        CCF: 8,
+        RL: 9
+      };
+      var FontType = {
+        UNKNOWN: 0,
+        TYPE1: 1,
+        TYPE1C: 2,
+        CIDFONTTYPE0: 3,
+        CIDFONTTYPE0C: 4,
+        TRUETYPE: 5,
+        CIDFONTTYPE2: 6,
+        TYPE3: 7,
+        OPENTYPE: 8,
+        TYPE0: 9,
+        MMTYPE1: 10
+      };
+      var VERBOSITY_LEVELS = {
+        errors: 0,
+        warnings: 1,
+        infos: 5
+      };
+      // All the possible operations for an operator list.
+      var OPS = {
+        // Intentionally start from 1 so it is easy to spot bad operators that will be
+        // 0's.
+        dependency: 1,
+        setLineWidth: 2,
+        setLineCap: 3,
+        setLineJoin: 4,
+        setMiterLimit: 5,
+        setDash: 6,
+        setRenderingIntent: 7,
+        setFlatness: 8,
+        setGState: 9,
+        save: 10,
+        restore: 11,
+        transform: 12,
+        moveTo: 13,
+        lineTo: 14,
+        curveTo: 15,
+        curveTo2: 16,
+        curveTo3: 17,
+        closePath: 18,
+        rectangle: 19,
+        stroke: 20,
+        closeStroke: 21,
+        fill: 22,
+        eoFill: 23,
+        fillStroke: 24,
+        eoFillStroke: 25,
+        closeFillStroke: 26,
+        closeEOFillStroke: 27,
+        endPath: 28,
+        clip: 29,
+        eoClip: 30,
+        beginText: 31,
+        endText: 32,
+        setCharSpacing: 33,
+        setWordSpacing: 34,
+        setHScale: 35,
+        setLeading: 36,
+        setFont: 37,
+        setTextRenderingMode: 38,
+        setTextRise: 39,
+        moveText: 40,
+        setLeadingMoveText: 41,
+        setTextMatrix: 42,
+        nextLine: 43,
+        showText: 44,
+        showSpacedText: 45,
+        nextLineShowText: 46,
+        nextLineSetSpacingShowText: 47,
+        setCharWidth: 48,
+        setCharWidthAndBounds: 49,
+        setStrokeColorSpace: 50,
+        setFillColorSpace: 51,
+        setStrokeColor: 52,
+        setStrokeColorN: 53,
+        setFillColor: 54,
+        setFillColorN: 55,
+        setStrokeGray: 56,
+        setFillGray: 57,
+        setStrokeRGBColor: 58,
+        setFillRGBColor: 59,
+        setStrokeCMYKColor: 60,
+        setFillCMYKColor: 61,
+        shadingFill: 62,
+        beginInlineImage: 63,
+        beginImageData: 64,
+        endInlineImage: 65,
+        paintXObject: 66,
+        markPoint: 67,
+        markPointProps: 68,
+        beginMarkedContent: 69,
+        beginMarkedContentProps: 70,
+        endMarkedContent: 71,
+        beginCompat: 72,
+        endCompat: 73,
+        paintFormXObjectBegin: 74,
+        paintFormXObjectEnd: 75,
+        beginGroup: 76,
+        endGroup: 77,
+        beginAnnotations: 78,
+        endAnnotations: 79,
+        beginAnnotation: 80,
+        endAnnotation: 81,
+        paintJpegXObject: 82,
+        paintImageMaskXObject: 83,
+        paintImageMaskXObjectGroup: 84,
+        paintImageXObject: 85,
+        paintInlineImageXObject: 86,
+        paintInlineImageXObjectGroup: 87,
+        paintImageXObjectRepeat: 88,
+        paintImageMaskXObjectRepeat: 89,
+        paintSolidColorImageMask: 90,
+        constructPath: 91
+      };
+      var verbosity = VERBOSITY_LEVELS.warnings;
+      function setVerbosityLevel(level) {
+        verbosity = level;
+      }
+      function getVerbosityLevel() {
+        return verbosity;
+      }
+      // A notice for devs. These are good for things that are helpful to devs, such
+      // as warning that Workers were disabled, which is important to devs but not
+      // end users.
+      function info(msg) {
+        if (verbosity >= VERBOSITY_LEVELS.infos) {
+          console.log('Info: ' + msg);
+        }
+      }
+      // Non-fatal warnings.
+      function warn(msg) {
+        if (verbosity >= VERBOSITY_LEVELS.warnings) {
+          console.log('Warning: ' + msg);
+        }
+      }
+      // Deprecated API function -- display regardless of the PDFJS.verbosity setting.
+      function deprecated(details) {
+        console.log('Deprecated API usage: ' + details);
+      }
+      // Fatal errors that should trigger the fallback UI and halt execution by
+      // throwing an exception.
+      function error(msg) {
+        if (verbosity >= VERBOSITY_LEVELS.errors) {
+          console.log('Error: ' + msg);
+          console.log(backtrace());
+        }
+        throw new Error(msg);
+      }
+      function backtrace() {
+        try {
+          throw new Error();
+        } catch (e) {
+          return e.stack ? e.stack.split('\n').slice(2).join('\n') : '';
+        }
+      }
+      function assert(cond, msg) {
+        if (!cond) {
+          error(msg);
+        }
+      }
+      var UNSUPPORTED_FEATURES = {
+        unknown: 'unknown',
+        forms: 'forms',
+        javaScript: 'javaScript',
+        smask: 'smask',
+        shadingPattern: 'shadingPattern',
+        font: 'font'
+      };
+      // Checks if URLs have the same origin. For non-HTTP based URLs, returns false.
+      function isSameOrigin(baseUrl, otherUrl) {
+        try {
+          var base = new URL(baseUrl);
+          if (!base.origin || base.origin === 'null') {
+            return false;
+          }
+        } // non-HTTP url
+        catch (e) {
+          return false;
+        }
+        var other = new URL(otherUrl, base);
+        return base.origin === other.origin;
+      }
+      // Checks if URLs use one of the whitelisted protocols, e.g. to avoid XSS.
+      function isValidProtocol(url) {
+        if (!url) {
+          return false;
+        }
+        switch (url.protocol) {
+        case 'http:':
+        case 'https:':
+        case 'ftp:':
+        case 'mailto:':
+        case 'tel:':
+          return true;
+        default:
+          return false;
+        }
+      }
+      /**
+       * Attempts to create a valid absolute URL (utilizing `isValidProtocol`).
+       * @param {URL|string} url - An absolute, or relative, URL.
+       * @param {URL|string} baseUrl - An absolute URL.
+       * @returns Either a valid {URL}, or `null` otherwise.
+       */
+      function createValidAbsoluteUrl(url, baseUrl) {
+        if (!url) {
+          return null;
+        }
+        try {
+          var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
+          if (isValidProtocol(absoluteUrl)) {
+            return absoluteUrl;
+          }
+        } catch (ex) {
+        }
+        return null;
+      }
+      function shadow(obj, prop, value) {
+        Object.defineProperty(obj, prop, {
+          value: value,
+          enumerable: true,
+          configurable: true,
+          writable: false
+        });
+        return value;
+      }
+      function getLookupTableFactory(initializer) {
+        var lookup;
+        return function () {
+          if (initializer) {
+            lookup = Object.create(null);
+            initializer(lookup);
+            initializer = null;
+          }
+          return lookup;
+        };
+      }
+      var PasswordResponses = {
+        NEED_PASSWORD: 1,
+        INCORRECT_PASSWORD: 2
+      };
+      var PasswordException = function PasswordExceptionClosure() {
+        function PasswordException(msg, code) {
+          this.name = 'PasswordException';
+          this.message = msg;
+          this.code = code;
+        }
+        PasswordException.prototype = new Error();
+        PasswordException.constructor = PasswordException;
+        return PasswordException;
+      }();
+      var UnknownErrorException = function UnknownErrorExceptionClosure() {
+        function UnknownErrorException(msg, details) {
+          this.name = 'UnknownErrorException';
+          this.message = msg;
+          this.details = details;
+        }
+        UnknownErrorException.prototype = new Error();
+        UnknownErrorException.constructor = UnknownErrorException;
+        return UnknownErrorException;
+      }();
+      var InvalidPDFException = function InvalidPDFExceptionClosure() {
+        function InvalidPDFException(msg) {
+          this.name = 'InvalidPDFException';
+          this.message = msg;
+        }
+        InvalidPDFException.prototype = new Error();
+        InvalidPDFException.constructor = InvalidPDFException;
+        return InvalidPDFException;
+      }();
+      var MissingPDFException = function MissingPDFExceptionClosure() {
+        function MissingPDFException(msg) {
+          this.name = 'MissingPDFException';
+          this.message = msg;
+        }
+        MissingPDFException.prototype = new Error();
+        MissingPDFException.constructor = MissingPDFException;
+        return MissingPDFException;
+      }();
+      var UnexpectedResponseException = function UnexpectedResponseExceptionClosure() {
+        function UnexpectedResponseException(msg, status) {
+          this.name = 'UnexpectedResponseException';
+          this.message = msg;
+          this.status = status;
+        }
+        UnexpectedResponseException.prototype = new Error();
+        UnexpectedResponseException.constructor = UnexpectedResponseException;
+        return UnexpectedResponseException;
+      }();
+      var NotImplementedException = function NotImplementedExceptionClosure() {
+        function NotImplementedException(msg) {
+          this.message = msg;
+        }
+        NotImplementedException.prototype = new Error();
+        NotImplementedException.prototype.name = 'NotImplementedException';
+        NotImplementedException.constructor = NotImplementedException;
+        return NotImplementedException;
+      }();
+      var MissingDataException = function MissingDataExceptionClosure() {
+        function MissingDataException(begin, end) {
+          this.begin = begin;
+          this.end = end;
+          this.message = 'Missing data [' + begin + ', ' + end + ')';
+        }
+        MissingDataException.prototype = new Error();
+        MissingDataException.prototype.name = 'MissingDataException';
+        MissingDataException.constructor = MissingDataException;
+        return MissingDataException;
+      }();
+      var XRefParseException = function XRefParseExceptionClosure() {
+        function XRefParseException(msg) {
+          this.message = msg;
+        }
+        XRefParseException.prototype = new Error();
+        XRefParseException.prototype.name = 'XRefParseException';
+        XRefParseException.constructor = XRefParseException;
+        return XRefParseException;
+      }();
+      var NullCharactersRegExp = /\x00/g;
+      function removeNullCharacters(str) {
+        if (typeof str !== 'string') {
+          warn('The argument for removeNullCharacters must be a string.');
+          return str;
+        }
+        return str.replace(NullCharactersRegExp, '');
+      }
+      function bytesToString(bytes) {
+        assert(bytes !== null && typeof bytes === 'object' && bytes.length !== undefined, 'Invalid argument for bytesToString');
+        var length = bytes.length;
+        var MAX_ARGUMENT_COUNT = 8192;
+        if (length < MAX_ARGUMENT_COUNT) {
+          return String.fromCharCode.apply(null, bytes);
+        }
+        var strBuf = [];
+        for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
+          var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
+          var chunk = bytes.subarray(i, chunkEnd);
+          strBuf.push(String.fromCharCode.apply(null, chunk));
+        }
+        return strBuf.join('');
+      }
+      function stringToBytes(str) {
+        assert(typeof str === 'string', 'Invalid argument for stringToBytes');
+        var length = str.length;
+        var bytes = new Uint8Array(length);
+        for (var i = 0; i < length; ++i) {
+          bytes[i] = str.charCodeAt(i) & 0xFF;
+        }
+        return bytes;
+      }
+      /**
+       * Gets length of the array (Array, Uint8Array, or string) in bytes.
+       * @param {Array|Uint8Array|string} arr
+       * @returns {number}
+       */
+      function arrayByteLength(arr) {
+        if (arr.length !== undefined) {
+          return arr.length;
+        }
+        assert(arr.byteLength !== undefined);
+        return arr.byteLength;
+      }
+      /**
+       * Combines array items (arrays) into single Uint8Array object.
+       * @param {Array} arr - the array of the arrays (Array, Uint8Array, or string).
+       * @returns {Uint8Array}
+       */
+      function arraysToBytes(arr) {
+        // Shortcut: if first and only item is Uint8Array, return it.
+        if (arr.length === 1 && arr[0] instanceof Uint8Array) {
+          return arr[0];
+        }
+        var resultLength = 0;
+        var i, ii = arr.length;
+        var item, itemLength;
+        for (i = 0; i < ii; i++) {
+          item = arr[i];
+          itemLength = arrayByteLength(item);
+          resultLength += itemLength;
+        }
+        var pos = 0;
+        var data = new Uint8Array(resultLength);
+        for (i = 0; i < ii; i++) {
+          item = arr[i];
+          if (!(item instanceof Uint8Array)) {
+            if (typeof item === 'string') {
+              item = stringToBytes(item);
+            } else {
+              item = new Uint8Array(item);
+            }
+          }
+          itemLength = item.byteLength;
+          data.set(item, pos);
+          pos += itemLength;
+        }
+        return data;
+      }
+      function string32(value) {
+        return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
+      }
+      function log2(x) {
+        var n = 1, i = 0;
+        while (x > n) {
+          n <<= 1;
+          i++;
+        }
+        return i;
+      }
+      function readInt8(data, start) {
+        return data[start] << 24 >> 24;
+      }
+      function readUint16(data, offset) {
+        return data[offset] << 8 | data[offset + 1];
+      }
+      function readUint32(data, offset) {
+        return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+      }
+      // Lazy test the endianness of the platform
+      // NOTE: This will be 'true' for simulated TypedArrays
+      function isLittleEndian() {
+        var buffer8 = new Uint8Array(2);
+        buffer8[0] = 1;
+        var buffer16 = new Uint16Array(buffer8.buffer);
+        return buffer16[0] === 1;
+      }
+      // Checks if it's possible to eval JS expressions.
+      function isEvalSupported() {
+        try {
+          new Function('');
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      var IDENTITY_MATRIX = [
+        1,
+        0,
+        0,
+        1,
+        0,
+        0
+      ];
+      var Util = function UtilClosure() {
+        function Util() {
+        }
+        var rgbBuf = [
+          'rgb(',
+          0,
+          ',',
+          0,
+          ',',
+          0,
+          ')'
+        ];
+        // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids
+        // creating many intermediate strings.
+        Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
+          rgbBuf[1] = r;
+          rgbBuf[3] = g;
+          rgbBuf[5] = b;
+          return rgbBuf.join('');
+        };
+        // Concatenates two transformation matrices together and returns the result.
+        Util.transform = function Util_transform(m1, m2) {
+          return [
+            m1[0] * m2[0] + m1[2] * m2[1],
+            m1[1] * m2[0] + m1[3] * m2[1],
+            m1[0] * m2[2] + m1[2] * m2[3],
+            m1[1] * m2[2] + m1[3] * m2[3],
+            m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+            m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+          ];
+        };
+        // For 2d affine transforms
+        Util.applyTransform = function Util_applyTransform(p, m) {
+          var xt = p[0] * m[0] + p[1] * m[2] + m[4];
+          var yt = p[0] * m[1] + p[1] * m[3] + m[5];
+          return [
+            xt,
+            yt
+          ];
+        };
+        Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
+          var d = m[0] * m[3] - m[1] * m[2];
+          var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
+          var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
+          return [
+            xt,
+            yt
+          ];
+        };
+        // Applies the transform to the rectangle and finds the minimum axially
+        // aligned bounding box.
+        Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) {
+          var p1 = Util.applyTransform(r, m);
+          var p2 = Util.applyTransform(r.slice(2, 4), m);
+          var p3 = Util.applyTransform([
+            r[0],
+            r[3]
+          ], m);
+          var p4 = Util.applyTransform([
+            r[2],
+            r[1]
+          ], m);
+          return [
+            Math.min(p1[0], p2[0], p3[0], p4[0]),
+            Math.min(p1[1], p2[1], p3[1], p4[1]),
+            Math.max(p1[0], p2[0], p3[0], p4[0]),
+            Math.max(p1[1], p2[1], p3[1], p4[1])
+          ];
+        };
+        Util.inverseTransform = function Util_inverseTransform(m) {
+          var d = m[0] * m[3] - m[1] * m[2];
+          return [
+            m[3] / d,
+            -m[1] / d,
+            -m[2] / d,
+            m[0] / d,
+            (m[2] * m[5] - m[4] * m[3]) / d,
+            (m[4] * m[1] - m[5] * m[0]) / d
+          ];
+        };
+        // Apply a generic 3d matrix M on a 3-vector v:
+        //   | a b c |   | X |
+        //   | d e f | x | Y |
+        //   | g h i |   | Z |
+        // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],
+        // with v as [X,Y,Z]
+        Util.apply3dTransform = function Util_apply3dTransform(m, v) {
+          return [
+            m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+            m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
+            m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
+          ];
+        };
+        // This calculation uses Singular Value Decomposition.
+        // The SVD can be represented with formula A = USV. We are interested in the
+        // matrix S here because it represents the scale values.
+        Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) {
+          var transpose = [
+            m[0],
+            m[2],
+            m[1],
+            m[3]
+          ];
+          // Multiply matrix m with its transpose.
+          var a = m[0] * transpose[0] + m[1] * transpose[2];
+          var b = m[0] * transpose[1] + m[1] * transpose[3];
+          var c = m[2] * transpose[0] + m[3] * transpose[2];
+          var d = m[2] * transpose[1] + m[3] * transpose[3];
+          // Solve the second degree polynomial to get roots.
+          var first = (a + d) / 2;
+          var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
+          var sx = first + second || 1;
+          var sy = first - second || 1;
+          // Scale values are the square roots of the eigenvalues.
+          return [
+            Math.sqrt(sx),
+            Math.sqrt(sy)
+          ];
+        };
+        // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
+        // For coordinate systems whose origin lies in the bottom-left, this
+        // means normalization to (BL,TR) ordering. For systems with origin in the
+        // top-left, this means (TL,BR) ordering.
+        Util.normalizeRect = function Util_normalizeRect(rect) {
+          var r = rect.slice(0);
+          // clone rect
+          if (rect[0] > rect[2]) {
+            r[0] = rect[2];
+            r[2] = rect[0];
+          }
+          if (rect[1] > rect[3]) {
+            r[1] = rect[3];
+            r[3] = rect[1];
+          }
+          return r;
+        };
+        // Returns a rectangle [x1, y1, x2, y2] corresponding to the
+        // intersection of rect1 and rect2. If no intersection, returns 'false'
+        // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]
+        Util.intersect = function Util_intersect(rect1, rect2) {
+          function compare(a, b) {
+            return a - b;
+          }
+          // Order points along the axes
+          var orderedX = [
+              rect1[0],
+              rect1[2],
+              rect2[0],
+              rect2[2]
+            ].sort(compare), orderedY = [
+              rect1[1],
+              rect1[3],
+              rect2[1],
+              rect2[3]
+            ].sort(compare), result = [];
+          rect1 = Util.normalizeRect(rect1);
+          rect2 = Util.normalizeRect(rect2);
+          // X: first and second points belong to different rectangles?
+          if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
+            // Intersection must be between second and third points
+            result[0] = orderedX[1];
+            result[2] = orderedX[2];
+          } else {
+            return false;
+          }
+          // Y: first and second points belong to different rectangles?
+          if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
+            // Intersection must be between second and third points
+            result[1] = orderedY[1];
+            result[3] = orderedY[2];
+          } else {
+            return false;
+          }
+          return result;
+        };
+        Util.sign = function Util_sign(num) {
+          return num < 0 ? -1 : 1;
+        };
+        var ROMAN_NUMBER_MAP = [
+          '',
+          'C',
+          'CC',
+          'CCC',
+          'CD',
+          'D',
+          'DC',
+          'DCC',
+          'DCCC',
+          'CM',
+          '',
+          'X',
+          'XX',
+          'XXX',
+          'XL',
+          'L',
+          'LX',
+          'LXX',
+          'LXXX',
+          'XC',
+          '',
+          'I',
+          'II',
+          'III',
+          'IV',
+          'V',
+          'VI',
+          'VII',
+          'VIII',
+          'IX'
+        ];
+        /**
+         * Converts positive integers to (upper case) Roman numerals.
+         * @param {integer} number - The number that should be converted.
+         * @param {boolean} lowerCase - Indicates if the result should be converted
+         *   to lower case letters. The default is false.
+         * @return {string} The resulting Roman number.
+         */
+        Util.toRoman = function Util_toRoman(number, lowerCase) {
+          assert(isInt(number) && number > 0, 'The number should be a positive integer.');
+          var pos, romanBuf = [];
+          // Thousands
+          while (number >= 1000) {
+            number -= 1000;
+            romanBuf.push('M');
+          }
+          // Hundreds
+          pos = number / 100 | 0;
+          number %= 100;
+          romanBuf.push(ROMAN_NUMBER_MAP[pos]);
+          // Tens
+          pos = number / 10 | 0;
+          number %= 10;
+          romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
+          // Ones
+          romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
+          var romanStr = romanBuf.join('');
+          return lowerCase ? romanStr.toLowerCase() : romanStr;
+        };
+        Util.appendToArray = function Util_appendToArray(arr1, arr2) {
+          Array.prototype.push.apply(arr1, arr2);
+        };
+        Util.prependToArray = function Util_prependToArray(arr1, arr2) {
+          Array.prototype.unshift.apply(arr1, arr2);
+        };
+        Util.extendObj = function extendObj(obj1, obj2) {
+          for (var key in obj2) {
+            obj1[key] = obj2[key];
+          }
+        };
+        Util.getInheritableProperty = function Util_getInheritableProperty(dict, name, getArray) {
+          while (dict && !dict.has(name)) {
+            dict = dict.get('Parent');
+          }
+          if (!dict) {
+            return null;
+          }
+          return getArray ? dict.getArray(name) : dict.get(name);
+        };
+        Util.inherit = function Util_inherit(sub, base, prototype) {
+          sub.prototype = Object.create(base.prototype);
+          sub.prototype.constructor = sub;
+          for (var prop in prototype) {
+            sub.prototype[prop] = prototype[prop];
+          }
+        };
+        Util.loadScript = function Util_loadScript(src, callback) {
+          var script = document.createElement('script');
+          var loaded = false;
+          script.setAttribute('src', src);
+          if (callback) {
+            script.onload = function () {
+              if (!loaded) {
+                callback();
+              }
+              loaded = true;
+            };
+          }
+          document.getElementsByTagName('head')[0].appendChild(script);
+        };
+        return Util;
+      }();
+      /**
+       * PDF page viewport created based on scale, rotation and offset.
+       * @class
+       * @alias PageViewport
+       */
+      var PageViewport = function PageViewportClosure() {
+        /**
+         * @constructor
+         * @private
+         * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates.
+         * @param scale {number} scale of the viewport.
+         * @param rotation {number} rotations of the viewport in degrees.
+         * @param offsetX {number} offset X
+         * @param offsetY {number} offset Y
+         * @param dontFlip {boolean} if true, axis Y will not be flipped.
+         */
+        function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {
+          this.viewBox = viewBox;
+          this.scale = scale;
+          this.rotation = rotation;
+          this.offsetX = offsetX;
+          this.offsetY = offsetY;
+          // creating transform to convert pdf coordinate system to the normal
+          // canvas like coordinates taking in account scale and rotation
+          var centerX = (viewBox[2] + viewBox[0]) / 2;
+          var centerY = (viewBox[3] + viewBox[1]) / 2;
+          var rotateA, rotateB, rotateC, rotateD;
+          rotation = rotation % 360;
+          rotation = rotation < 0 ? rotation + 360 : rotation;
+          switch (rotation) {
+          case 180:
+            rotateA = -1;
+            rotateB = 0;
+            rotateC = 0;
+            rotateD = 1;
+            break;
+          case 90:
+            rotateA = 0;
+            rotateB = 1;
+            rotateC = 1;
+            rotateD = 0;
+            break;
+          case 270:
+            rotateA = 0;
+            rotateB = -1;
+            rotateC = -1;
+            rotateD = 0;
+            break;
+          //case 0:
+          default:
+            rotateA = 1;
+            rotateB = 0;
+            rotateC = 0;
+            rotateD = -1;
+            break;
+          }
+          if (dontFlip) {
+            rotateC = -rotateC;
+            rotateD = -rotateD;
+          }
+          var offsetCanvasX, offsetCanvasY;
+          var width, height;
+          if (rotateA === 0) {
+            offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
+            offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
+            width = Math.abs(viewBox[3] - viewBox[1]) * scale;
+            height = Math.abs(viewBox[2] - viewBox[0]) * scale;
+          } else {
+            offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
+            offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
+            width = Math.abs(viewBox[2] - viewBox[0]) * scale;
+            height = Math.abs(viewBox[3] - viewBox[1]) * scale;
+          }
+          // creating transform for the following operations:
+          // translate(-centerX, -centerY), rotate and flip vertically,
+          // scale, and translate(offsetCanvasX, offsetCanvasY)
+          this.transform = [
+            rotateA * scale,
+            rotateB * scale,
+            rotateC * scale,
+            rotateD * scale,
+            offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,
+            offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY
+          ];
+          this.width = width;
+          this.height = height;
+          this.fontScale = scale;
+        }
+        PageViewport.prototype = /** @lends PageViewport.prototype */
+        {
+          /**
+           * Clones viewport with additional properties.
+           * @param args {Object} (optional) If specified, may contain the 'scale' or
+           * 'rotation' properties to override the corresponding properties in
+           * the cloned viewport.
+           * @returns {PageViewport} Cloned viewport.
+           */
+          clone: function PageViewPort_clone(args) {
+            args = args || {};
+            var scale = 'scale' in args ? args.scale : this.scale;
+            var rotation = 'rotation' in args ? args.rotation : this.rotation;
+            return new PageViewport(this.viewBox.slice(), scale, rotation, this.offsetX, this.offsetY, args.dontFlip);
+          },
+          /**
+           * Converts PDF point to the viewport coordinates. For examples, useful for
+           * converting PDF location into canvas pixel coordinates.
+           * @param x {number} X coordinate.
+           * @param y {number} Y coordinate.
+           * @returns {Object} Object that contains 'x' and 'y' properties of the
+           * point in the viewport coordinate space.
+           * @see {@link convertToPdfPoint}
+           * @see {@link convertToViewportRectangle}
+           */
+          convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {
+            return Util.applyTransform([
+              x,
+              y
+            ], this.transform);
+          },
+          /**
+           * Converts PDF rectangle to the viewport coordinates.
+           * @param rect {Array} xMin, yMin, xMax and yMax coordinates.
+           * @returns {Array} Contains corresponding coordinates of the rectangle
+           * in the viewport coordinate space.
+           * @see {@link convertToViewportPoint}
+           */
+          convertToViewportRectangle: function PageViewport_convertToViewportRectangle(rect) {
+            var tl = Util.applyTransform([
+              rect[0],
+              rect[1]
+            ], this.transform);
+            var br = Util.applyTransform([
+              rect[2],
+              rect[3]
+            ], this.transform);
+            return [
+              tl[0],
+              tl[1],
+              br[0],
+              br[1]
+            ];
+          },
+          /**
+           * Converts viewport coordinates to the PDF location. For examples, useful
+           * for converting canvas pixel location into PDF one.
+           * @param x {number} X coordinate.
+           * @param y {number} Y coordinate.
+           * @returns {Object} Object that contains 'x' and 'y' properties of the
+           * point in the PDF coordinate space.
+           * @see {@link convertToViewportPoint}
+           */
+          convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {
+            return Util.applyInverseTransform([
+              x,
+              y
+            ], this.transform);
+          }
+        };
+        return PageViewport;
+      }();
+      var PDFStringTranslateTable = [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0x2D8,
+        0x2C7,
+        0x2C6,
+        0x2D9,
+        0x2DD,
+        0x2DB,
+        0x2DA,
+        0x2DC,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0x2022,
+        0x2020,
+        0x2021,
+        0x2026,
+        0x2014,
+        0x2013,
+        0x192,
+        0x2044,
+        0x2039,
+        0x203A,
+        0x2212,
+        0x2030,
+        0x201E,
+        0x201C,
+        0x201D,
+        0x2018,
+        0x2019,
+        0x201A,
+        0x2122,
+        0xFB01,
+        0xFB02,
+        0x141,
+        0x152,
+        0x160,
+        0x178,
+        0x17D,
+        0x131,
+        0x142,
+        0x153,
+        0x161,
+        0x17E,
+        0,
+        0x20AC
+      ];
+      function stringToPDFString(str) {
+        var i, n = str.length, strBuf = [];
+        if (str[0] === '\xFE' && str[1] === '\xFF') {
+          // UTF16BE BOM
+          for (i = 2; i < n; i += 2) {
+            strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
+          }
+        } else {
+          for (i = 0; i < n; ++i) {
+            var code = PDFStringTranslateTable[str.charCodeAt(i)];
+            strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
+          }
+        }
+        return strBuf.join('');
+      }
+      function stringToUTF8String(str) {
+        return decodeURIComponent(escape(str));
+      }
+      function utf8StringToString(str) {
+        return unescape(encodeURIComponent(str));
+      }
+      function isEmptyObj(obj) {
+        for (var key in obj) {
+          return false;
+        }
+        return true;
+      }
+      function isBool(v) {
+        return typeof v === 'boolean';
+      }
+      function isInt(v) {
+        return typeof v === 'number' && (v | 0) === v;
+      }
+      function isNum(v) {
+        return typeof v === 'number';
+      }
+      function isString(v) {
+        return typeof v === 'string';
+      }
+      function isArray(v) {
+        return v instanceof Array;
+      }
+      function isArrayBuffer(v) {
+        return typeof v === 'object' && v !== null && v.byteLength !== undefined;
+      }
+      // Checks if ch is one of the following characters: SPACE, TAB, CR or LF.
+      function isSpace(ch) {
+        return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
+      }
+      /**
+       * Promise Capability object.
+       *
+       * @typedef {Object} PromiseCapability
+       * @property {Promise} promise - A promise object.
+       * @property {function} resolve - Fulfills the promise.
+       * @property {function} reject - Rejects the promise.
+       */
+      /**
+       * Creates a promise capability object.
+       * @alias createPromiseCapability
+       *
+       * @return {PromiseCapability} A capability object contains:
+       * - a Promise, resolve and reject methods.
+       */
+      function createPromiseCapability() {
+        var capability = {};
+        capability.promise = new Promise(function (resolve, reject) {
+          capability.resolve = resolve;
+          capability.reject = reject;
+        });
+        return capability;
+      }
+      /**
+       * Polyfill for Promises:
+       * The following promise implementation tries to generally implement the
+       * Promise/A+ spec. Some notable differences from other promise libraries are:
+       * - There currently isn't a separate deferred and promise object.
+       * - Unhandled rejections eventually show an error if they aren't handled.
+       *
+       * Based off of the work in:
+       * https://bugzilla.mozilla.org/show_bug.cgi?id=810490
+       */
+      (function PromiseClosure() {
+        if (globalScope.Promise) {
+          // Promises existing in the DOM/Worker, checking presence of all/resolve
+          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;
+        }
+        throw new Error('DOM Promise is not present');
+      }());
+      var StatTimer = function StatTimerClosure() {
+        function rpad(str, pad, length) {
+          while (str.length < length) {
+            str += pad;
+          }
+          return str;
+        }
+        function StatTimer() {
+          this.started = Object.create(null);
+          this.times = [];
+          this.enabled = true;
+        }
+        StatTimer.prototype = {
+          time: function StatTimer_time(name) {
+            if (!this.enabled) {
+              return;
+            }
+            if (name in this.started) {
+              warn('Timer is already running for ' + name);
+            }
+            this.started[name] = Date.now();
+          },
+          timeEnd: function StatTimer_timeEnd(name) {
+            if (!this.enabled) {
+              return;
+            }
+            if (!(name in this.started)) {
+              warn('Timer has not been started for ' + name);
+            }
+            this.times.push({
+              'name': name,
+              'start': this.started[name],
+              'end': Date.now()
+            });
+            // Remove timer from started so it can be called again.
+            delete this.started[name];
+          },
+          toString: function StatTimer_toString() {
+            var i, ii;
+            var times = this.times;
+            var out = '';
+            // Find the longest name for padding purposes.
+            var longest = 0;
+            for (i = 0, ii = times.length; i < ii; ++i) {
+              var name = times[i]['name'];
+              if (name.length > longest) {
+                longest = name.length;
+              }
+            }
+            for (i = 0, ii = times.length; i < ii; ++i) {
+              var span = times[i];
+              var duration = span.end - span.start;
+              out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n';
+            }
+            return out;
+          }
+        };
+        return StatTimer;
+      }();
+      var createBlob = function createBlob(data, contentType) {
+        if (typeof Blob !== 'undefined') {
+          return new Blob([data], { type: contentType });
+        }
+        warn('The "Blob" constructor is not supported.');
+      };
+      var createObjectURL = function createObjectURLClosure() {
+        // Blob/createObjectURL is not available, falling back to data schema.
+        var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        return function createObjectURL(data, contentType, forceDataSchema) {
+          if (!forceDataSchema && typeof URL !== 'undefined' && URL.createObjectURL) {
+            var blob = createBlob(data, contentType);
+            return URL.createObjectURL(blob);
+          }
+          var buffer = 'data:' + contentType + ';base64,';
+          for (var i = 0, ii = data.length; i < ii; i += 3) {
+            var b1 = data[i] & 0xFF;
+            var b2 = data[i + 1] & 0xFF;
+            var b3 = data[i + 2] & 0xFF;
+            var d1 = b1 >> 2, d2 = (b1 & 3) << 4 | b2 >> 4;
+            var d3 = i + 1 < ii ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
+            var d4 = i + 2 < ii ? b3 & 0x3F : 64;
+            buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
+          }
+          return buffer;
+        };
+      }();
+      function MessageHandler(sourceName, targetName, comObj) {
+        this.sourceName = sourceName;
+        this.targetName = targetName;
+        this.comObj = comObj;
+        this.callbackIndex = 1;
+        this.postMessageTransfers = true;
+        var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
+        var ah = this.actionHandler = Object.create(null);
+        this._onComObjOnMessage = function messageHandlerComObjOnMessage(event) {
+          var data = event.data;
+          if (data.targetName !== this.sourceName) {
+            return;
+          }
+          if (data.isReply) {
+            var callbackId = data.callbackId;
+            if (data.callbackId in callbacksCapabilities) {
+              var callback = callbacksCapabilities[callbackId];
+              delete callbacksCapabilities[callbackId];
+              if ('error' in data) {
+                callback.reject(data.error);
+              } else {
+                callback.resolve(data.data);
+              }
+            } else {
+              error('Cannot resolve callback ' + callbackId);
+            }
+          } else if (data.action in ah) {
+            var action = ah[data.action];
+            if (data.callbackId) {
+              var sourceName = this.sourceName;
+              var targetName = data.sourceName;
+              Promise.resolve().then(function () {
+                return action[0].call(action[1], data.data);
+              }).then(function (result) {
+                comObj.postMessage({
+                  sourceName: sourceName,
+                  targetName: targetName,
+                  isReply: true,
+                  callbackId: data.callbackId,
+                  data: result
+                });
+              }, function (reason) {
+                if (reason instanceof Error) {
+                  // Serialize error to avoid "DataCloneError"
+                  reason = reason + '';
+                }
+                comObj.postMessage({
+                  sourceName: sourceName,
+                  targetName: targetName,
+                  isReply: true,
+                  callbackId: data.callbackId,
+                  error: reason
+                });
+              });
+            } else {
+              action[0].call(action[1], data.data);
+            }
+          } else {
+            error('Unknown action from worker: ' + data.action);
+          }
+        }.bind(this);
+        comObj.addEventListener('message', this._onComObjOnMessage);
+      }
+      MessageHandler.prototype = {
+        on: function messageHandlerOn(actionName, handler, scope) {
+          var ah = this.actionHandler;
+          if (ah[actionName]) {
+            error('There is already an actionName called "' + actionName + '"');
+          }
+          ah[actionName] = [
+            handler,
+            scope
+          ];
+        },
+        /**
+         * Sends a message to the comObj to invoke the action with the supplied data.
+         * @param {String} actionName Action to call.
+         * @param {JSON} data JSON data to send.
+         * @param {Array} [transfers] Optional list of transfers/ArrayBuffers
+         */
+        send: function messageHandlerSend(actionName, data, transfers) {
+          var message = {
+            sourceName: this.sourceName,
+            targetName: this.targetName,
+            action: actionName,
+            data: data
+          };
+          this.postMessage(message, transfers);
+        },
+        /**
+         * Sends a message to the comObj to invoke the action with the supplied data.
+         * Expects that other side will callback with the response.
+         * @param {String} actionName Action to call.
+         * @param {JSON} data JSON data to send.
+         * @param {Array} [transfers] Optional list of transfers/ArrayBuffers.
+         * @returns {Promise} Promise to be resolved with response data.
+         */
+        sendWithPromise: function messageHandlerSendWithPromise(actionName, data, transfers) {
+          var callbackId = this.callbackIndex++;
+          var message = {
+            sourceName: this.sourceName,
+            targetName: this.targetName,
+            action: actionName,
+            data: data,
+            callbackId: callbackId
+          };
+          var capability = createPromiseCapability();
+          this.callbacksCapabilities[callbackId] = capability;
+          try {
+            this.postMessage(message, transfers);
+          } catch (e) {
+            capability.reject(e);
+          }
+          return capability.promise;
+        },
+        /**
+         * Sends raw message to the comObj.
+         * @private
+         * @param message {Object} Raw message.
+         * @param transfers List of transfers/ArrayBuffers, or undefined.
+         */
+        postMessage: function (message, transfers) {
+          if (transfers && this.postMessageTransfers) {
+            this.comObj.postMessage(message, transfers);
+          } else {
+            this.comObj.postMessage(message);
+          }
+        },
+        destroy: function () {
+          this.comObj.removeEventListener('message', this._onComObjOnMessage);
+        }
+      };
+      function loadJpegStream(id, imageUrl, objs) {
+        var img = new Image();
+        img.onload = function loadJpegStream_onloadClosure() {
+          objs.resolve(id, img);
+        };
+        img.onerror = function loadJpegStream_onerrorClosure() {
+          objs.resolve(id, null);
+          warn('Error during JPEG image loading');
+        };
+        img.src = imageUrl;
+      }
+      exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
+      exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
+      exports.OPS = OPS;
+      exports.VERBOSITY_LEVELS = VERBOSITY_LEVELS;
+      exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
+      exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
+      exports.AnnotationFieldFlag = AnnotationFieldFlag;
+      exports.AnnotationFlag = AnnotationFlag;
+      exports.AnnotationType = AnnotationType;
+      exports.FontType = FontType;
+      exports.ImageKind = ImageKind;
+      exports.InvalidPDFException = InvalidPDFException;
+      exports.MessageHandler = MessageHandler;
+      exports.MissingDataException = MissingDataException;
+      exports.MissingPDFException = MissingPDFException;
+      exports.NotImplementedException = NotImplementedException;
+      exports.PageViewport = PageViewport;
+      exports.PasswordException = PasswordException;
+      exports.PasswordResponses = PasswordResponses;
+      exports.StatTimer = StatTimer;
+      exports.StreamType = StreamType;
+      exports.TextRenderingMode = TextRenderingMode;
+      exports.UnexpectedResponseException = UnexpectedResponseException;
+      exports.UnknownErrorException = UnknownErrorException;
+      exports.Util = Util;
+      exports.XRefParseException = XRefParseException;
+      exports.arrayByteLength = arrayByteLength;
+      exports.arraysToBytes = arraysToBytes;
+      exports.assert = assert;
+      exports.bytesToString = bytesToString;
+      exports.createBlob = createBlob;
+      exports.createPromiseCapability = createPromiseCapability;
+      exports.createObjectURL = createObjectURL;
+      exports.deprecated = deprecated;
+      exports.error = error;
+      exports.getLookupTableFactory = getLookupTableFactory;
+      exports.getVerbosityLevel = getVerbosityLevel;
+      exports.globalScope = globalScope;
+      exports.info = info;
+      exports.isArray = isArray;
+      exports.isArrayBuffer = isArrayBuffer;
+      exports.isBool = isBool;
+      exports.isEmptyObj = isEmptyObj;
+      exports.isInt = isInt;
+      exports.isNum = isNum;
+      exports.isString = isString;
+      exports.isSpace = isSpace;
+      exports.isSameOrigin = isSameOrigin;
+      exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
+      exports.isLittleEndian = isLittleEndian;
+      exports.isEvalSupported = isEvalSupported;
+      exports.loadJpegStream = loadJpegStream;
+      exports.log2 = log2;
+      exports.readInt8 = readInt8;
+      exports.readUint16 = readUint16;
+      exports.readUint32 = readUint32;
+      exports.removeNullCharacters = removeNullCharacters;
+      exports.setVerbosityLevel = setVerbosityLevel;
+      exports.shadow = shadow;
+      exports.string32 = string32;
+      exports.stringToBytes = stringToBytes;
+      exports.stringToPDFString = stringToPDFString;
+      exports.stringToUTF8String = stringToUTF8String;
+      exports.utf8StringToString = utf8StringToString;
+      exports.warn = warn;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreCFFParser = {}, root.pdfjsSharedUtil, root.pdfjsCoreCharsets, root.pdfjsCoreEncodings);
+    }(this, function (exports, sharedUtil, coreCharsets, coreEncodings) {
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var bytesToString = sharedUtil.bytesToString;
+      var warn = sharedUtil.warn;
+      var isArray = sharedUtil.isArray;
+      var Util = sharedUtil.Util;
+      var stringToBytes = sharedUtil.stringToBytes;
+      var assert = sharedUtil.assert;
+      var ISOAdobeCharset = coreCharsets.ISOAdobeCharset;
+      var ExpertCharset = coreCharsets.ExpertCharset;
+      var ExpertSubsetCharset = coreCharsets.ExpertSubsetCharset;
+      var StandardEncoding = coreEncodings.StandardEncoding;
+      var ExpertEncoding = coreEncodings.ExpertEncoding;
+      // Maximum subroutine call depth of type 2 chartrings. Matches OTS.
+      var MAX_SUBR_NESTING = 10;
+      /**
+       * The CFF class takes a Type1 file and wrap it into a
+       * 'Compact Font Format' which itself embed Type2 charstrings.
+       */
+      var CFFStandardStrings = [
+        '.notdef',
+        'space',
+        'exclam',
+        'quotedbl',
+        'numbersign',
+        'dollar',
+        'percent',
+        'ampersand',
+        'quoteright',
+        'parenleft',
+        'parenright',
+        'asterisk',
+        'plus',
+        'comma',
+        'hyphen',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'at',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z',
+        'bracketleft',
+        'backslash',
+        'bracketright',
+        'asciicircum',
+        'underscore',
+        'quoteleft',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'braceleft',
+        'bar',
+        'braceright',
+        'asciitilde',
+        'exclamdown',
+        'cent',
+        'sterling',
+        'fraction',
+        'yen',
+        'florin',
+        'section',
+        'currency',
+        'quotesingle',
+        'quotedblleft',
+        'guillemotleft',
+        'guilsinglleft',
+        'guilsinglright',
+        'fi',
+        'fl',
+        'endash',
+        'dagger',
+        'daggerdbl',
+        'periodcentered',
+        'paragraph',
+        'bullet',
+        'quotesinglbase',
+        'quotedblbase',
+        'quotedblright',
+        'guillemotright',
+        'ellipsis',
+        'perthousand',
+        'questiondown',
+        'grave',
+        'acute',
+        'circumflex',
+        'tilde',
+        'macron',
+        'breve',
+        'dotaccent',
+        'dieresis',
+        'ring',
+        'cedilla',
+        'hungarumlaut',
+        'ogonek',
+        'caron',
+        'emdash',
+        'AE',
+        'ordfeminine',
+        'Lslash',
+        'Oslash',
+        'OE',
+        'ordmasculine',
+        'ae',
+        'dotlessi',
+        'lslash',
+        'oslash',
+        'oe',
+        'germandbls',
+        'onesuperior',
+        'logicalnot',
+        'mu',
+        'trademark',
+        'Eth',
+        'onehalf',
+        'plusminus',
+        'Thorn',
+        'onequarter',
+        'divide',
+        'brokenbar',
+        'degree',
+        'thorn',
+        'threequarters',
+        'twosuperior',
+        'registered',
+        'minus',
+        'eth',
+        'multiply',
+        'threesuperior',
+        'copyright',
+        'Aacute',
+        'Acircumflex',
+        'Adieresis',
+        'Agrave',
+        'Aring',
+        'Atilde',
+        'Ccedilla',
+        'Eacute',
+        'Ecircumflex',
+        'Edieresis',
+        'Egrave',
+        'Iacute',
+        'Icircumflex',
+        'Idieresis',
+        'Igrave',
+        'Ntilde',
+        'Oacute',
+        'Ocircumflex',
+        'Odieresis',
+        'Ograve',
+        'Otilde',
+        'Scaron',
+        'Uacute',
+        'Ucircumflex',
+        'Udieresis',
+        'Ugrave',
+        'Yacute',
+        'Ydieresis',
+        'Zcaron',
+        'aacute',
+        'acircumflex',
+        'adieresis',
+        'agrave',
+        'aring',
+        'atilde',
+        'ccedilla',
+        'eacute',
+        'ecircumflex',
+        'edieresis',
+        'egrave',
+        'iacute',
+        'icircumflex',
+        'idieresis',
+        'igrave',
+        'ntilde',
+        'oacute',
+        'ocircumflex',
+        'odieresis',
+        'ograve',
+        'otilde',
+        'scaron',
+        'uacute',
+        'ucircumflex',
+        'udieresis',
+        'ugrave',
+        'yacute',
+        'ydieresis',
+        'zcaron',
+        'exclamsmall',
+        'Hungarumlautsmall',
+        'dollaroldstyle',
+        'dollarsuperior',
+        'ampersandsmall',
+        'Acutesmall',
+        'parenleftsuperior',
+        'parenrightsuperior',
+        'twodotenleader',
+        'onedotenleader',
+        'zerooldstyle',
+        'oneoldstyle',
+        'twooldstyle',
+        'threeoldstyle',
+        'fouroldstyle',
+        'fiveoldstyle',
+        'sixoldstyle',
+        'sevenoldstyle',
+        'eightoldstyle',
+        'nineoldstyle',
+        'commasuperior',
+        'threequartersemdash',
+        'periodsuperior',
+        'questionsmall',
+        'asuperior',
+        'bsuperior',
+        'centsuperior',
+        'dsuperior',
+        'esuperior',
+        'isuperior',
+        'lsuperior',
+        'msuperior',
+        'nsuperior',
+        'osuperior',
+        'rsuperior',
+        'ssuperior',
+        'tsuperior',
+        'ff',
+        'ffi',
+        'ffl',
+        'parenleftinferior',
+        'parenrightinferior',
+        'Circumflexsmall',
+        'hyphensuperior',
+        'Gravesmall',
+        'Asmall',
+        'Bsmall',
+        'Csmall',
+        'Dsmall',
+        'Esmall',
+        'Fsmall',
+        'Gsmall',
+        'Hsmall',
+        'Ismall',
+        'Jsmall',
+        'Ksmall',
+        'Lsmall',
+        'Msmall',
+        'Nsmall',
+        'Osmall',
+        'Psmall',
+        'Qsmall',
+        'Rsmall',
+        'Ssmall',
+        'Tsmall',
+        'Usmall',
+        'Vsmall',
+        'Wsmall',
+        'Xsmall',
+        'Ysmall',
+        'Zsmall',
+        'colonmonetary',
+        'onefitted',
+        'rupiah',
+        'Tildesmall',
+        'exclamdownsmall',
+        'centoldstyle',
+        'Lslashsmall',
+        'Scaronsmall',
+        'Zcaronsmall',
+        'Dieresissmall',
+        'Brevesmall',
+        'Caronsmall',
+        'Dotaccentsmall',
+        'Macronsmall',
+        'figuredash',
+        'hypheninferior',
+        'Ogoneksmall',
+        'Ringsmall',
+        'Cedillasmall',
+        'questiondownsmall',
+        'oneeighth',
+        'threeeighths',
+        'fiveeighths',
+        'seveneighths',
+        'onethird',
+        'twothirds',
+        'zerosuperior',
+        'foursuperior',
+        'fivesuperior',
+        'sixsuperior',
+        'sevensuperior',
+        'eightsuperior',
+        'ninesuperior',
+        'zeroinferior',
+        'oneinferior',
+        'twoinferior',
+        'threeinferior',
+        'fourinferior',
+        'fiveinferior',
+        'sixinferior',
+        'seveninferior',
+        'eightinferior',
+        'nineinferior',
+        'centinferior',
+        'dollarinferior',
+        'periodinferior',
+        'commainferior',
+        'Agravesmall',
+        'Aacutesmall',
+        'Acircumflexsmall',
+        'Atildesmall',
+        'Adieresissmall',
+        'Aringsmall',
+        'AEsmall',
+        'Ccedillasmall',
+        'Egravesmall',
+        'Eacutesmall',
+        'Ecircumflexsmall',
+        'Edieresissmall',
+        'Igravesmall',
+        'Iacutesmall',
+        'Icircumflexsmall',
+        'Idieresissmall',
+        'Ethsmall',
+        'Ntildesmall',
+        'Ogravesmall',
+        'Oacutesmall',
+        'Ocircumflexsmall',
+        'Otildesmall',
+        'Odieresissmall',
+        'OEsmall',
+        'Oslashsmall',
+        'Ugravesmall',
+        'Uacutesmall',
+        'Ucircumflexsmall',
+        'Udieresissmall',
+        'Yacutesmall',
+        'Thornsmall',
+        'Ydieresissmall',
+        '001.000',
+        '001.001',
+        '001.002',
+        '001.003',
+        'Black',
+        'Bold',
+        'Book',
+        'Light',
+        'Medium',
+        'Regular',
+        'Roman',
+        'Semibold'
+      ];
+      var CFFParser = function CFFParserClosure() {
+        var CharstringValidationData = [
+          null,
+          {
+            id: 'hstem',
+            min: 2,
+            stackClearing: true,
+            stem: true
+          },
+          null,
+          {
+            id: 'vstem',
+            min: 2,
+            stackClearing: true,
+            stem: true
+          },
+          {
+            id: 'vmoveto',
+            min: 1,
+            stackClearing: true
+          },
+          {
+            id: 'rlineto',
+            min: 2,
+            resetStack: true
+          },
+          {
+            id: 'hlineto',
+            min: 1,
+            resetStack: true
+          },
+          {
+            id: 'vlineto',
+            min: 1,
+            resetStack: true
+          },
+          {
+            id: 'rrcurveto',
+            min: 6,
+            resetStack: true
+          },
+          null,
+          {
+            id: 'callsubr',
+            min: 1,
+            undefStack: true
+          },
+          {
+            id: 'return',
+            min: 0,
+            undefStack: true
+          },
+          null,
+          // 12
+          null,
+          {
+            id: 'endchar',
+            min: 0,
+            stackClearing: true
+          },
+          null,
+          null,
+          null,
+          {
+            id: 'hstemhm',
+            min: 2,
+            stackClearing: true,
+            stem: true
+          },
+          {
+            id: 'hintmask',
+            min: 0,
+            stackClearing: true
+          },
+          {
+            id: 'cntrmask',
+            min: 0,
+            stackClearing: true
+          },
+          {
+            id: 'rmoveto',
+            min: 2,
+            stackClearing: true
+          },
+          {
+            id: 'hmoveto',
+            min: 1,
+            stackClearing: true
+          },
+          {
+            id: 'vstemhm',
+            min: 2,
+            stackClearing: true,
+            stem: true
+          },
+          {
+            id: 'rcurveline',
+            min: 8,
+            resetStack: true
+          },
+          {
+            id: 'rlinecurve',
+            min: 8,
+            resetStack: true
+          },
+          {
+            id: 'vvcurveto',
+            min: 4,
+            resetStack: true
+          },
+          {
+            id: 'hhcurveto',
+            min: 4,
+            resetStack: true
+          },
+          null,
+          // shortint
+          {
+            id: 'callgsubr',
+            min: 1,
+            undefStack: true
+          },
+          {
+            id: 'vhcurveto',
+            min: 4,
+            resetStack: true
+          },
+          {
+            id: 'hvcurveto',
+            min: 4,
+            resetStack: true
+          }
+        ];
+        var CharstringValidationData12 = [
+          null,
+          null,
+          null,
+          {
+            id: 'and',
+            min: 2,
+            stackDelta: -1
+          },
+          {
+            id: 'or',
+            min: 2,
+            stackDelta: -1
+          },
+          {
+            id: 'not',
+            min: 1,
+            stackDelta: 0
+          },
+          null,
+          null,
+          null,
+          {
+            id: 'abs',
+            min: 1,
+            stackDelta: 0
+          },
+          {
+            id: 'add',
+            min: 2,
+            stackDelta: -1,
+            stackFn: function stack_div(stack, index) {
+              stack[index - 2] = stack[index - 2] + stack[index - 1];
+            }
+          },
+          {
+            id: 'sub',
+            min: 2,
+            stackDelta: -1,
+            stackFn: function stack_div(stack, index) {
+              stack[index - 2] = stack[index - 2] - stack[index - 1];
+            }
+          },
+          {
+            id: 'div',
+            min: 2,
+            stackDelta: -1,
+            stackFn: function stack_div(stack, index) {
+              stack[index - 2] = stack[index - 2] / stack[index - 1];
+            }
+          },
+          null,
+          {
+            id: 'neg',
+            min: 1,
+            stackDelta: 0,
+            stackFn: function stack_div(stack, index) {
+              stack[index - 1] = -stack[index - 1];
+            }
+          },
+          {
+            id: 'eq',
+            min: 2,
+            stackDelta: -1
+          },
+          null,
+          null,
+          {
+            id: 'drop',
+            min: 1,
+            stackDelta: -1
+          },
+          null,
+          {
+            id: 'put',
+            min: 2,
+            stackDelta: -2
+          },
+          {
+            id: 'get',
+            min: 1,
+            stackDelta: 0
+          },
+          {
+            id: 'ifelse',
+            min: 4,
+            stackDelta: -3
+          },
+          {
+            id: 'random',
+            min: 0,
+            stackDelta: 1
+          },
+          {
+            id: 'mul',
+            min: 2,
+            stackDelta: -1,
+            stackFn: function stack_div(stack, index) {
+              stack[index - 2] = stack[index - 2] * stack[index - 1];
+            }
+          },
+          null,
+          {
+            id: 'sqrt',
+            min: 1,
+            stackDelta: 0
+          },
+          {
+            id: 'dup',
+            min: 1,
+            stackDelta: 1
+          },
+          {
+            id: 'exch',
+            min: 2,
+            stackDelta: 0
+          },
+          {
+            id: 'index',
+            min: 2,
+            stackDelta: 0
+          },
+          {
+            id: 'roll',
+            min: 3,
+            stackDelta: -2
+          },
+          null,
+          null,
+          null,
+          {
+            id: 'hflex',
+            min: 7,
+            resetStack: true
+          },
+          {
+            id: 'flex',
+            min: 13,
+            resetStack: true
+          },
+          {
+            id: 'hflex1',
+            min: 9,
+            resetStack: true
+          },
+          {
+            id: 'flex1',
+            min: 11,
+            resetStack: true
+          }
+        ];
+        function CFFParser(file, properties, seacAnalysisEnabled) {
+          this.bytes = file.getBytes();
+          this.properties = properties;
+          this.seacAnalysisEnabled = !!seacAnalysisEnabled;
+        }
+        CFFParser.prototype = {
+          parse: function CFFParser_parse() {
+            var properties = this.properties;
+            var cff = new CFF();
+            this.cff = cff;
+            // The first five sections must be in order, all the others are reached
+            // via offsets contained in one of the below.
+            var header = this.parseHeader();
+            var nameIndex = this.parseIndex(header.endPos);
+            var topDictIndex = this.parseIndex(nameIndex.endPos);
+            var stringIndex = this.parseIndex(topDictIndex.endPos);
+            var globalSubrIndex = this.parseIndex(stringIndex.endPos);
+            var topDictParsed = this.parseDict(topDictIndex.obj.get(0));
+            var topDict = this.createDict(CFFTopDict, topDictParsed, cff.strings);
+            cff.header = header.obj;
+            cff.names = this.parseNameIndex(nameIndex.obj);
+            cff.strings = this.parseStringIndex(stringIndex.obj);
+            cff.topDict = topDict;
+            cff.globalSubrIndex = globalSubrIndex.obj;
+            this.parsePrivateDict(cff.topDict);
+            cff.isCIDFont = topDict.hasName('ROS');
+            var charStringOffset = topDict.getByName('CharStrings');
+            var charStringIndex = this.parseIndex(charStringOffset).obj;
+            var fontMatrix = topDict.getByName('FontMatrix');
+            if (fontMatrix) {
+              properties.fontMatrix = fontMatrix;
+            }
+            var fontBBox = topDict.getByName('FontBBox');
+            if (fontBBox) {
+              // adjusting ascent/descent
+              properties.ascent = fontBBox[3];
+              properties.descent = fontBBox[1];
+              properties.ascentScaled = true;
+            }
+            var charset, encoding;
+            if (cff.isCIDFont) {
+              var fdArrayIndex = this.parseIndex(topDict.getByName('FDArray')).obj;
+              for (var i = 0, ii = fdArrayIndex.count; i < ii; ++i) {
+                var dictRaw = fdArrayIndex.get(i);
+                var fontDict = this.createDict(CFFTopDict, this.parseDict(dictRaw), cff.strings);
+                this.parsePrivateDict(fontDict);
+                cff.fdArray.push(fontDict);
+              }
+              // cid fonts don't have an encoding
+              encoding = null;
+              charset = this.parseCharsets(topDict.getByName('charset'), charStringIndex.count, cff.strings, true);
+              cff.fdSelect = this.parseFDSelect(topDict.getByName('FDSelect'), charStringIndex.count);
+            } else {
+              charset = this.parseCharsets(topDict.getByName('charset'), charStringIndex.count, cff.strings, false);
+              encoding = this.parseEncoding(topDict.getByName('Encoding'), properties, cff.strings, charset.charset);
+            }
+            cff.charset = charset;
+            cff.encoding = encoding;
+            var charStringsAndSeacs = this.parseCharStrings(charStringIndex, topDict.privateDict.subrsIndex, globalSubrIndex.obj, cff.fdSelect, cff.fdArray);
+            cff.charStrings = charStringsAndSeacs.charStrings;
+            cff.seacs = charStringsAndSeacs.seacs;
+            cff.widths = charStringsAndSeacs.widths;
+            return cff;
+          },
+          parseHeader: function CFFParser_parseHeader() {
+            var bytes = this.bytes;
+            var bytesLength = bytes.length;
+            var offset = 0;
+            // Prevent an infinite loop, by checking that the offset is within the
+            // bounds of the bytes array. Necessary in empty, or invalid, font files.
+            while (offset < bytesLength && bytes[offset] !== 1) {
+              ++offset;
+            }
+            if (offset >= bytesLength) {
+              error('Invalid CFF header');
+            } else if (offset !== 0) {
+              info('cff data is shifted');
+              bytes = bytes.subarray(offset);
+              this.bytes = bytes;
+            }
+            var major = bytes[0];
+            var minor = bytes[1];
+            var hdrSize = bytes[2];
+            var offSize = bytes[3];
+            var header = new CFFHeader(major, minor, hdrSize, offSize);
+            return {
+              obj: header,
+              endPos: hdrSize
+            };
+          },
+          parseDict: function CFFParser_parseDict(dict) {
+            var pos = 0;
+            function parseOperand() {
+              var value = dict[pos++];
+              if (value === 30) {
+                return parseFloatOperand();
+              } else if (value === 28) {
+                value = dict[pos++];
+                value = (value << 24 | dict[pos++] << 16) >> 16;
+                return value;
+              } else if (value === 29) {
+                value = dict[pos++];
+                value = value << 8 | dict[pos++];
+                value = value << 8 | dict[pos++];
+                value = value << 8 | dict[pos++];
+                return value;
+              } else if (value >= 32 && value <= 246) {
+                return value - 139;
+              } else if (value >= 247 && value <= 250) {
+                return (value - 247) * 256 + dict[pos++] + 108;
+              } else if (value >= 251 && value <= 254) {
+                return -((value - 251) * 256) - dict[pos++] - 108;
+              } else {
+                warn('CFFParser_parseDict: "' + value + '" is a reserved command.');
+                return NaN;
+              }
+            }
+            function parseFloatOperand() {
+              var str = '';
+              var eof = 15;
+              var lookup = [
+                '0',
+                '1',
+                '2',
+                '3',
+                '4',
+                '5',
+                '6',
+                '7',
+                '8',
+                '9',
+                '.',
+                'E',
+                'E-',
+                null,
+                '-'
+              ];
+              var length = dict.length;
+              while (pos < length) {
+                var b = dict[pos++];
+                var b1 = b >> 4;
+                var b2 = b & 15;
+                if (b1 === eof) {
+                  break;
+                }
+                str += lookup[b1];
+                if (b2 === eof) {
+                  break;
+                }
+                str += lookup[b2];
+              }
+              return parseFloat(str);
+            }
+            var operands = [];
+            var entries = [];
+            pos = 0;
+            var end = dict.length;
+            while (pos < end) {
+              var b = dict[pos];
+              if (b <= 21) {
+                if (b === 12) {
+                  b = b << 8 | dict[++pos];
+                }
+                entries.push([
+                  b,
+                  operands
+                ]);
+                operands = [];
+                ++pos;
+              } else {
+                operands.push(parseOperand());
+              }
+            }
+            return entries;
+          },
+          parseIndex: function CFFParser_parseIndex(pos) {
+            var cffIndex = new CFFIndex();
+            var bytes = this.bytes;
+            var count = bytes[pos++] << 8 | bytes[pos++];
+            var offsets = [];
+            var end = pos;
+            var i, ii;
+            if (count !== 0) {
+              var offsetSize = bytes[pos++];
+              // add 1 for offset to determine size of last object
+              var startPos = pos + (count + 1) * offsetSize - 1;
+              for (i = 0, ii = count + 1; i < ii; ++i) {
+                var offset = 0;
+                for (var j = 0; j < offsetSize; ++j) {
+                  offset <<= 8;
+                  offset += bytes[pos++];
+                }
+                offsets.push(startPos + offset);
+              }
+              end = offsets[count];
+            }
+            for (i = 0, ii = offsets.length - 1; i < ii; ++i) {
+              var offsetStart = offsets[i];
+              var offsetEnd = offsets[i + 1];
+              cffIndex.add(bytes.subarray(offsetStart, offsetEnd));
+            }
+            return {
+              obj: cffIndex,
+              endPos: end
+            };
+          },
+          parseNameIndex: function CFFParser_parseNameIndex(index) {
+            var names = [];
+            for (var i = 0, ii = index.count; i < ii; ++i) {
+              var name = index.get(i);
+              // OTS doesn't allow names to be over 127 characters.
+              var length = Math.min(name.length, 127);
+              var data = [];
+              // OTS also only permits certain characters in the name.
+              for (var j = 0; j < length; ++j) {
+                var c = name[j];
+                if (j === 0 && c === 0) {
+                  data[j] = c;
+                  continue;
+                }
+                if (c < 33 || c > 126 || c === 91 || /* [ */
+                  c === 93 || /* ] */
+                  c === 40 || /* ( */
+                  c === 41 || /* ) */
+                  c === 123 || /* { */
+                  c === 125 || /* } */
+                  c === 60 || /* < */
+                  c === 62 || /* > */
+                  c === 47 || /* / */
+                  c === 37 || /* % */
+                  c === 35)
+                  /* # */
+                  {
+                    data[j] = 95;
+                    continue;
+                  }
+                data[j] = c;
+              }
+              names.push(bytesToString(data));
+            }
+            return names;
+          },
+          parseStringIndex: function CFFParser_parseStringIndex(index) {
+            var strings = new CFFStrings();
+            for (var i = 0, ii = index.count; i < ii; ++i) {
+              var data = index.get(i);
+              strings.add(bytesToString(data));
+            }
+            return strings;
+          },
+          createDict: function CFFParser_createDict(Type, dict, strings) {
+            var cffDict = new Type(strings);
+            for (var i = 0, ii = dict.length; i < ii; ++i) {
+              var pair = dict[i];
+              var key = pair[0];
+              var value = pair[1];
+              cffDict.setByKey(key, value);
+            }
+            return cffDict;
+          },
+          parseCharString: function CFFParser_parseCharString(state, data, localSubrIndex, globalSubrIndex) {
+            if (state.callDepth > MAX_SUBR_NESTING) {
+              return false;
+            }
+            var stackSize = state.stackSize;
+            var stack = state.stack;
+            var length = data.length;
+            for (var j = 0; j < length;) {
+              var value = data[j++];
+              var validationCommand = null;
+              if (value === 12) {
+                var q = data[j++];
+                if (q === 0) {
+                  // The CFF specification state that the 'dotsection' command
+                  // (12, 0) is deprecated and treated as a no-op, but all Type2
+                  // charstrings processors should support them. Unfortunately
+                  // the font sanitizer don't. As a workaround the sequence (12, 0)
+                  // is replaced by a useless (0, hmoveto).
+                  data[j - 2] = 139;
+                  data[j - 1] = 22;
+                  stackSize = 0;
+                } else {
+                  validationCommand = CharstringValidationData12[q];
+                }
+              } else if (value === 28) {
+                // number (16 bit)
+                stack[stackSize] = (data[j] << 24 | data[j + 1] << 16) >> 16;
+                j += 2;
+                stackSize++;
+              } else if (value === 14) {
+                if (stackSize >= 4) {
+                  stackSize -= 4;
+                  if (this.seacAnalysisEnabled) {
+                    state.seac = stack.slice(stackSize, stackSize + 4);
+                    return false;
+                  }
+                }
+                validationCommand = CharstringValidationData[value];
+              } else if (value >= 32 && value <= 246) {
+                // number
+                stack[stackSize] = value - 139;
+                stackSize++;
+              } else if (value >= 247 && value <= 254) {
+                // number (+1 bytes)
+                stack[stackSize] = value < 251 ? (value - 247 << 8) + data[j] + 108 : -(value - 251 << 8) - data[j] - 108;
+                j++;
+                stackSize++;
+              } else if (value === 255) {
+                // number (32 bit)
+                stack[stackSize] = (data[j] << 24 | data[j + 1] << 16 | data[j + 2] << 8 | data[j + 3]) / 65536;
+                j += 4;
+                stackSize++;
+              } else if (value === 19 || value === 20) {
+                state.hints += stackSize >> 1;
+                // skipping right amount of hints flag data
+                j += state.hints + 7 >> 3;
+                stackSize %= 2;
+                validationCommand = CharstringValidationData[value];
+              } else if (value === 10 || value === 29) {
+                var subrsIndex;
+                if (value === 10) {
+                  subrsIndex = localSubrIndex;
+                } else {
+                  subrsIndex = globalSubrIndex;
+                }
+                if (!subrsIndex) {
+                  validationCommand = CharstringValidationData[value];
+                  warn('Missing subrsIndex for ' + validationCommand.id);
+                  return false;
+                }
+                var bias = 32768;
+                if (subrsIndex.count < 1240) {
+                  bias = 107;
+                } else if (subrsIndex.count < 33900) {
+                  bias = 1131;
+                }
+                var subrNumber = stack[--stackSize] + bias;
+                if (subrNumber < 0 || subrNumber >= subrsIndex.count) {
+                  validationCommand = CharstringValidationData[value];
+                  warn('Out of bounds subrIndex for ' + validationCommand.id);
+                  return false;
+                }
+                state.stackSize = stackSize;
+                state.callDepth++;
+                var valid = this.parseCharString(state, subrsIndex.get(subrNumber), localSubrIndex, globalSubrIndex);
+                if (!valid) {
+                  return false;
+                }
+                state.callDepth--;
+                stackSize = state.stackSize;
+                continue;
+              } else if (value === 11) {
+                state.stackSize = stackSize;
+                return true;
+              } else {
+                validationCommand = CharstringValidationData[value];
+              }
+              if (validationCommand) {
+                if (validationCommand.stem) {
+                  state.hints += stackSize >> 1;
+                }
+                if ('min' in validationCommand) {
+                  if (!state.undefStack && stackSize < validationCommand.min) {
+                    warn('Not enough parameters for ' + validationCommand.id + '; actual: ' + stackSize + ', expected: ' + validationCommand.min);
+                    return false;
+                  }
+                }
+                if (state.firstStackClearing && validationCommand.stackClearing) {
+                  state.firstStackClearing = false;
+                  // the optional character width can be found before the first
+                  // stack-clearing command arguments
+                  stackSize -= validationCommand.min;
+                  if (stackSize >= 2 && validationCommand.stem) {
+                    // there are even amount of arguments for stem commands
+                    stackSize %= 2;
+                  } else if (stackSize > 1) {
+                    warn('Found too many parameters for stack-clearing command');
+                  }
+                  if (stackSize > 0 && stack[stackSize - 1] >= 0) {
+                    state.width = stack[stackSize - 1];
+                  }
+                }
+                if ('stackDelta' in validationCommand) {
+                  if ('stackFn' in validationCommand) {
+                    validationCommand.stackFn(stack, stackSize);
+                  }
+                  stackSize += validationCommand.stackDelta;
+                } else if (validationCommand.stackClearing) {
+                  stackSize = 0;
+                } else if (validationCommand.resetStack) {
+                  stackSize = 0;
+                  state.undefStack = false;
+                } else if (validationCommand.undefStack) {
+                  stackSize = 0;
+                  state.undefStack = true;
+                  state.firstStackClearing = false;
+                }
+              }
+            }
+            state.stackSize = stackSize;
+            return true;
+          },
+          parseCharStrings: function CFFParser_parseCharStrings(charStrings, localSubrIndex, globalSubrIndex, fdSelect, fdArray) {
+            var seacs = [];
+            var widths = [];
+            var count = charStrings.count;
+            for (var i = 0; i < count; i++) {
+              var charstring = charStrings.get(i);
+              var state = {
+                callDepth: 0,
+                stackSize: 0,
+                stack: [],
+                undefStack: true,
+                hints: 0,
+                firstStackClearing: true,
+                seac: null,
+                width: null
+              };
+              var valid = true;
+              var localSubrToUse = null;
+              if (fdSelect && fdArray.length) {
+                var fdIndex = fdSelect.getFDIndex(i);
+                if (fdIndex === -1) {
+                  warn('Glyph index is not in fd select.');
+                  valid = false;
+                }
+                if (fdIndex >= fdArray.length) {
+                  warn('Invalid fd index for glyph index.');
+                  valid = false;
+                }
+                if (valid) {
+                  localSubrToUse = fdArray[fdIndex].privateDict.subrsIndex;
+                }
+              } else if (localSubrIndex) {
+                localSubrToUse = localSubrIndex;
+              }
+              if (valid) {
+                valid = this.parseCharString(state, charstring, localSubrToUse, globalSubrIndex);
+              }
+              if (state.width !== null) {
+                widths[i] = state.width;
+              }
+              if (state.seac !== null) {
+                seacs[i] = state.seac;
+              }
+              if (!valid) {
+                // resetting invalid charstring to single 'endchar'
+                charStrings.set(i, new Uint8Array([14]));
+              }
+            }
+            return {
+              charStrings: charStrings,
+              seacs: seacs,
+              widths: widths
+            };
+          },
+          emptyPrivateDictionary: function CFFParser_emptyPrivateDictionary(parentDict) {
+            var privateDict = this.createDict(CFFPrivateDict, [], parentDict.strings);
+            parentDict.setByKey(18, [
+              0,
+              0
+            ]);
+            parentDict.privateDict = privateDict;
+          },
+          parsePrivateDict: function CFFParser_parsePrivateDict(parentDict) {
+            // no private dict, do nothing
+            if (!parentDict.hasName('Private')) {
+              this.emptyPrivateDictionary(parentDict);
+              return;
+            }
+            var privateOffset = parentDict.getByName('Private');
+            // make sure the params are formatted correctly
+            if (!isArray(privateOffset) || privateOffset.length !== 2) {
+              parentDict.removeByName('Private');
+              return;
+            }
+            var size = privateOffset[0];
+            var offset = privateOffset[1];
+            // remove empty dicts or ones that refer to invalid location
+            if (size === 0 || offset >= this.bytes.length) {
+              this.emptyPrivateDictionary(parentDict);
+              return;
+            }
+            var privateDictEnd = offset + size;
+            var dictData = this.bytes.subarray(offset, privateDictEnd);
+            var dict = this.parseDict(dictData);
+            var privateDict = this.createDict(CFFPrivateDict, dict, parentDict.strings);
+            parentDict.privateDict = privateDict;
+            // Parse the Subrs index also since it's relative to the private dict.
+            if (!privateDict.getByName('Subrs')) {
+              return;
+            }
+            var subrsOffset = privateDict.getByName('Subrs');
+            var relativeOffset = offset + subrsOffset;
+            // Validate the offset.
+            if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {
+              this.emptyPrivateDictionary(parentDict);
+              return;
+            }
+            var subrsIndex = this.parseIndex(relativeOffset);
+            privateDict.subrsIndex = subrsIndex.obj;
+          },
+          parseCharsets: function CFFParser_parseCharsets(pos, length, strings, cid) {
+            if (pos === 0) {
+              return new CFFCharset(true, CFFCharsetPredefinedTypes.ISO_ADOBE, ISOAdobeCharset);
+            } else if (pos === 1) {
+              return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT, ExpertCharset);
+            } else if (pos === 2) {
+              return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT_SUBSET, ExpertSubsetCharset);
+            }
+            var bytes = this.bytes;
+            var start = pos;
+            var format = bytes[pos++];
+            var charset = ['.notdef'];
+            var id, count, i;
+            // subtract 1 for the .notdef glyph
+            length -= 1;
+            switch (format) {
+            case 0:
+              for (i = 0; i < length; i++) {
+                id = bytes[pos++] << 8 | bytes[pos++];
+                charset.push(cid ? id : strings.get(id));
+              }
+              break;
+            case 1:
+              while (charset.length <= length) {
+                id = bytes[pos++] << 8 | bytes[pos++];
+                count = bytes[pos++];
+                for (i = 0; i <= count; i++) {
+                  charset.push(cid ? id++ : strings.get(id++));
+                }
+              }
+              break;
+            case 2:
+              while (charset.length <= length) {
+                id = bytes[pos++] << 8 | bytes[pos++];
+                count = bytes[pos++] << 8 | bytes[pos++];
+                for (i = 0; i <= count; i++) {
+                  charset.push(cid ? id++ : strings.get(id++));
+                }
+              }
+              break;
+            default:
+              error('Unknown charset format');
+            }
+            // Raw won't be needed if we actually compile the charset.
+            var end = pos;
+            var raw = bytes.subarray(start, end);
+            return new CFFCharset(false, format, charset, raw);
+          },
+          parseEncoding: function CFFParser_parseEncoding(pos, properties, strings, charset) {
+            var encoding = Object.create(null);
+            var bytes = this.bytes;
+            var predefined = false;
+            var hasSupplement = false;
+            var format, i, ii;
+            var raw = null;
+            function readSupplement() {
+              var supplementsCount = bytes[pos++];
+              for (i = 0; i < supplementsCount; i++) {
+                var code = bytes[pos++];
+                var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
+                encoding[code] = charset.indexOf(strings.get(sid));
+              }
+            }
+            if (pos === 0 || pos === 1) {
+              predefined = true;
+              format = pos;
+              var baseEncoding = pos ? ExpertEncoding : StandardEncoding;
+              for (i = 0, ii = charset.length; i < ii; i++) {
+                var index = baseEncoding.indexOf(charset[i]);
+                if (index !== -1) {
+                  encoding[index] = i;
+                }
+              }
+            } else {
+              var dataStart = pos;
+              format = bytes[pos++];
+              switch (format & 0x7f) {
+              case 0:
+                var glyphsCount = bytes[pos++];
+                for (i = 1; i <= glyphsCount; i++) {
+                  encoding[bytes[pos++]] = i;
+                }
+                break;
+              case 1:
+                var rangesCount = bytes[pos++];
+                var gid = 1;
+                for (i = 0; i < rangesCount; i++) {
+                  var start = bytes[pos++];
+                  var left = bytes[pos++];
+                  for (var j = start; j <= start + left; j++) {
+                    encoding[j] = gid++;
+                  }
+                }
+                break;
+              default:
+                error('Unknown encoding format: ' + format + ' in CFF');
+                break;
+              }
+              var dataEnd = pos;
+              if (format & 0x80) {
+                // The font sanitizer does not support CFF encoding with a
+                // supplement, since the encoding is not really used to map
+                // between gid to glyph, let's overwrite what is declared in
+                // the top dictionary to let the sanitizer think the font use
+                // StandardEncoding, that's a lie but that's ok.
+                bytes[dataStart] &= 0x7f;
+                readSupplement();
+                hasSupplement = true;
+              }
+              raw = bytes.subarray(dataStart, dataEnd);
+            }
+            format = format & 0x7f;
+            return new CFFEncoding(predefined, format, encoding, raw);
+          },
+          parseFDSelect: function CFFParser_parseFDSelect(pos, length) {
+            var start = pos;
+            var bytes = this.bytes;
+            var format = bytes[pos++];
+            var fdSelect = [], rawBytes;
+            var i, invalidFirstGID = false;
+            switch (format) {
+            case 0:
+              for (i = 0; i < length; ++i) {
+                var id = bytes[pos++];
+                fdSelect.push(id);
+              }
+              rawBytes = bytes.subarray(start, pos);
+              break;
+            case 3:
+              var rangesCount = bytes[pos++] << 8 | bytes[pos++];
+              for (i = 0; i < rangesCount; ++i) {
+                var first = bytes[pos++] << 8 | bytes[pos++];
+                if (i === 0 && first !== 0) {
+                  warn('parseFDSelect: The first range must have a first GID of 0' + ' -- trying to recover.');
+                  invalidFirstGID = true;
+                  first = 0;
+                }
+                var fdIndex = bytes[pos++];
+                var next = bytes[pos] << 8 | bytes[pos + 1];
+                for (var j = first; j < next; ++j) {
+                  fdSelect.push(fdIndex);
+                }
+              }
+              // Advance past the sentinel(next).
+              pos += 2;
+              rawBytes = bytes.subarray(start, pos);
+              if (invalidFirstGID) {
+                rawBytes[3] = rawBytes[4] = 0;
+              }
+              // Adjust the first range, first GID.
+              break;
+            default:
+              error('parseFDSelect: Unknown format "' + format + '".');
+              break;
+            }
+            assert(fdSelect.length === length, 'parseFDSelect: Invalid font data.');
+            return new CFFFDSelect(fdSelect, rawBytes);
+          }
+        };
+        return CFFParser;
+      }();
+      // Compact Font Format
+      var CFF = function CFFClosure() {
+        function CFF() {
+          this.header = null;
+          this.names = [];
+          this.topDict = null;
+          this.strings = new CFFStrings();
+          this.globalSubrIndex = null;
+          // The following could really be per font, but since we only have one font
+          // store them here.
+          this.encoding = null;
+          this.charset = null;
+          this.charStrings = null;
+          this.fdArray = [];
+          this.fdSelect = null;
+          this.isCIDFont = false;
+        }
+        return CFF;
+      }();
+      var CFFHeader = function CFFHeaderClosure() {
+        function CFFHeader(major, minor, hdrSize, offSize) {
+          this.major = major;
+          this.minor = minor;
+          this.hdrSize = hdrSize;
+          this.offSize = offSize;
+        }
+        return CFFHeader;
+      }();
+      var CFFStrings = function CFFStringsClosure() {
+        function CFFStrings() {
+          this.strings = [];
+        }
+        CFFStrings.prototype = {
+          get: function CFFStrings_get(index) {
+            if (index >= 0 && index <= 390) {
+              return CFFStandardStrings[index];
+            }
+            if (index - 391 <= this.strings.length) {
+              return this.strings[index - 391];
+            }
+            return CFFStandardStrings[0];
+          },
+          add: function CFFStrings_add(value) {
+            this.strings.push(value);
+          },
+          get count() {
+            return this.strings.length;
+          }
+        };
+        return CFFStrings;
+      }();
+      var CFFIndex = function CFFIndexClosure() {
+        function CFFIndex() {
+          this.objects = [];
+          this.length = 0;
+        }
+        CFFIndex.prototype = {
+          add: function CFFIndex_add(data) {
+            this.length += data.length;
+            this.objects.push(data);
+          },
+          set: function CFFIndex_set(index, data) {
+            this.length += data.length - this.objects[index].length;
+            this.objects[index] = data;
+          },
+          get: function CFFIndex_get(index) {
+            return this.objects[index];
+          },
+          get count() {
+            return this.objects.length;
+          }
+        };
+        return CFFIndex;
+      }();
+      var CFFDict = function CFFDictClosure() {
+        function CFFDict(tables, strings) {
+          this.keyToNameMap = tables.keyToNameMap;
+          this.nameToKeyMap = tables.nameToKeyMap;
+          this.defaults = tables.defaults;
+          this.types = tables.types;
+          this.opcodes = tables.opcodes;
+          this.order = tables.order;
+          this.strings = strings;
+          this.values = Object.create(null);
+        }
+        CFFDict.prototype = {
+          // value should always be an array
+          setByKey: function CFFDict_setByKey(key, value) {
+            if (!(key in this.keyToNameMap)) {
+              return false;
+            }
+            var valueLength = value.length;
+            // ignore empty values
+            if (valueLength === 0) {
+              return true;
+            }
+            // Ignore invalid values (fixes bug1068432.pdf and bug1308536.pdf).
+            for (var i = 0; i < valueLength; i++) {
+              if (isNaN(value[i])) {
+                warn('Invalid CFFDict value: "' + value + '" for key "' + key + '".');
+                return true;
+              }
+            }
+            var type = this.types[key];
+            // remove the array wrapping these types of values
+            if (type === 'num' || type === 'sid' || type === 'offset') {
+              value = value[0];
+            }
+            this.values[key] = value;
+            return true;
+          },
+          setByName: function CFFDict_setByName(name, value) {
+            if (!(name in this.nameToKeyMap)) {
+              error('Invalid dictionary name "' + name + '"');
+            }
+            this.values[this.nameToKeyMap[name]] = value;
+          },
+          hasName: function CFFDict_hasName(name) {
+            return this.nameToKeyMap[name] in this.values;
+          },
+          getByName: function CFFDict_getByName(name) {
+            if (!(name in this.nameToKeyMap)) {
+              error('Invalid dictionary name "' + name + '"');
+            }
+            var key = this.nameToKeyMap[name];
+            if (!(key in this.values)) {
+              return this.defaults[key];
+            }
+            return this.values[key];
+          },
+          removeByName: function CFFDict_removeByName(name) {
+            delete this.values[this.nameToKeyMap[name]];
+          }
+        };
+        CFFDict.createTables = function CFFDict_createTables(layout) {
+          var tables = {
+            keyToNameMap: {},
+            nameToKeyMap: {},
+            defaults: {},
+            types: {},
+            opcodes: {},
+            order: []
+          };
+          for (var i = 0, ii = layout.length; i < ii; ++i) {
+            var entry = layout[i];
+            var key = isArray(entry[0]) ? (entry[0][0] << 8) + entry[0][1] : entry[0];
+            tables.keyToNameMap[key] = entry[1];
+            tables.nameToKeyMap[entry[1]] = key;
+            tables.types[key] = entry[2];
+            tables.defaults[key] = entry[3];
+            tables.opcodes[key] = isArray(entry[0]) ? entry[0] : [entry[0]];
+            tables.order.push(key);
+          }
+          return tables;
+        };
+        return CFFDict;
+      }();
+      var CFFTopDict = function CFFTopDictClosure() {
+        var layout = [
+          [
+            [
+              12,
+              30
+            ],
+            'ROS',
+            [
+              'sid',
+              'sid',
+              'num'
+            ],
+            null
+          ],
+          [
+            [
+              12,
+              20
+            ],
+            'SyntheticBase',
+            'num',
+            null
+          ],
+          [
+            0,
+            'version',
+            'sid',
+            null
+          ],
+          [
+            1,
+            'Notice',
+            'sid',
+            null
+          ],
+          [
+            [
+              12,
+              0
+            ],
+            'Copyright',
+            'sid',
+            null
+          ],
+          [
+            2,
+            'FullName',
+            'sid',
+            null
+          ],
+          [
+            3,
+            'FamilyName',
+            'sid',
+            null
+          ],
+          [
+            4,
+            'Weight',
+            'sid',
+            null
+          ],
+          [
+            [
+              12,
+              1
+            ],
+            'isFixedPitch',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              2
+            ],
+            'ItalicAngle',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              3
+            ],
+            'UnderlinePosition',
+            'num',
+            -100
+          ],
+          [
+            [
+              12,
+              4
+            ],
+            'UnderlineThickness',
+            'num',
+            50
+          ],
+          [
+            [
+              12,
+              5
+            ],
+            'PaintType',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              6
+            ],
+            'CharstringType',
+            'num',
+            2
+          ],
+          [
+            [
+              12,
+              7
+            ],
+            'FontMatrix',
+            [
+              'num',
+              'num',
+              'num',
+              'num',
+              'num',
+              'num'
+            ],
+            [
+              0.001,
+              0,
+              0,
+              0.001,
+              0,
+              0
+            ]
+          ],
+          [
+            13,
+            'UniqueID',
+            'num',
+            null
+          ],
+          [
+            5,
+            'FontBBox',
+            [
+              'num',
+              'num',
+              'num',
+              'num'
+            ],
+            [
+              0,
+              0,
+              0,
+              0
+            ]
+          ],
+          [
+            [
+              12,
+              8
+            ],
+            'StrokeWidth',
+            'num',
+            0
+          ],
+          [
+            14,
+            'XUID',
+            'array',
+            null
+          ],
+          [
+            15,
+            'charset',
+            'offset',
+            0
+          ],
+          [
+            16,
+            'Encoding',
+            'offset',
+            0
+          ],
+          [
+            17,
+            'CharStrings',
+            'offset',
+            0
+          ],
+          [
+            18,
+            'Private',
+            [
+              'offset',
+              'offset'
+            ],
+            null
+          ],
+          [
+            [
+              12,
+              21
+            ],
+            'PostScript',
+            'sid',
+            null
+          ],
+          [
+            [
+              12,
+              22
+            ],
+            'BaseFontName',
+            'sid',
+            null
+          ],
+          [
+            [
+              12,
+              23
+            ],
+            'BaseFontBlend',
+            'delta',
+            null
+          ],
+          [
+            [
+              12,
+              31
+            ],
+            'CIDFontVersion',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              32
+            ],
+            'CIDFontRevision',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              33
+            ],
+            'CIDFontType',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              34
+            ],
+            'CIDCount',
+            'num',
+            8720
+          ],
+          [
+            [
+              12,
+              35
+            ],
+            'UIDBase',
+            'num',
+            null
+          ],
+          // XXX: CID Fonts on DirectWrite 6.1 only seem to work if FDSelect comes
+          // before FDArray.
+          [
+            [
+              12,
+              37
+            ],
+            'FDSelect',
+            'offset',
+            null
+          ],
+          [
+            [
+              12,
+              36
+            ],
+            'FDArray',
+            'offset',
+            null
+          ],
+          [
+            [
+              12,
+              38
+            ],
+            'FontName',
+            'sid',
+            null
+          ]
+        ];
+        var tables = null;
+        function CFFTopDict(strings) {
+          if (tables === null) {
+            tables = CFFDict.createTables(layout);
+          }
+          CFFDict.call(this, tables, strings);
+          this.privateDict = null;
+        }
+        CFFTopDict.prototype = Object.create(CFFDict.prototype);
+        return CFFTopDict;
+      }();
+      var CFFPrivateDict = function CFFPrivateDictClosure() {
+        var layout = [
+          [
+            6,
+            'BlueValues',
+            'delta',
+            null
+          ],
+          [
+            7,
+            'OtherBlues',
+            'delta',
+            null
+          ],
+          [
+            8,
+            'FamilyBlues',
+            'delta',
+            null
+          ],
+          [
+            9,
+            'FamilyOtherBlues',
+            'delta',
+            null
+          ],
+          [
+            [
+              12,
+              9
+            ],
+            'BlueScale',
+            'num',
+            0.039625
+          ],
+          [
+            [
+              12,
+              10
+            ],
+            'BlueShift',
+            'num',
+            7
+          ],
+          [
+            [
+              12,
+              11
+            ],
+            'BlueFuzz',
+            'num',
+            1
+          ],
+          [
+            10,
+            'StdHW',
+            'num',
+            null
+          ],
+          [
+            11,
+            'StdVW',
+            'num',
+            null
+          ],
+          [
+            [
+              12,
+              12
+            ],
+            'StemSnapH',
+            'delta',
+            null
+          ],
+          [
+            [
+              12,
+              13
+            ],
+            'StemSnapV',
+            'delta',
+            null
+          ],
+          [
+            [
+              12,
+              14
+            ],
+            'ForceBold',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              17
+            ],
+            'LanguageGroup',
+            'num',
+            0
+          ],
+          [
+            [
+              12,
+              18
+            ],
+            'ExpansionFactor',
+            'num',
+            0.06
+          ],
+          [
+            [
+              12,
+              19
+            ],
+            'initialRandomSeed',
+            'num',
+            0
+          ],
+          [
+            20,
+            'defaultWidthX',
+            'num',
+            0
+          ],
+          [
+            21,
+            'nominalWidthX',
+            'num',
+            0
+          ],
+          [
+            19,
+            'Subrs',
+            'offset',
+            null
+          ]
+        ];
+        var tables = null;
+        function CFFPrivateDict(strings) {
+          if (tables === null) {
+            tables = CFFDict.createTables(layout);
+          }
+          CFFDict.call(this, tables, strings);
+          this.subrsIndex = null;
+        }
+        CFFPrivateDict.prototype = Object.create(CFFDict.prototype);
+        return CFFPrivateDict;
+      }();
+      var CFFCharsetPredefinedTypes = {
+        ISO_ADOBE: 0,
+        EXPERT: 1,
+        EXPERT_SUBSET: 2
+      };
+      var CFFCharset = function CFFCharsetClosure() {
+        function CFFCharset(predefined, format, charset, raw) {
+          this.predefined = predefined;
+          this.format = format;
+          this.charset = charset;
+          this.raw = raw;
+        }
+        return CFFCharset;
+      }();
+      var CFFEncoding = function CFFEncodingClosure() {
+        function CFFEncoding(predefined, format, encoding, raw) {
+          this.predefined = predefined;
+          this.format = format;
+          this.encoding = encoding;
+          this.raw = raw;
+        }
+        return CFFEncoding;
+      }();
+      var CFFFDSelect = function CFFFDSelectClosure() {
+        function CFFFDSelect(fdSelect, raw) {
+          this.fdSelect = fdSelect;
+          this.raw = raw;
+        }
+        CFFFDSelect.prototype = {
+          getFDIndex: function CFFFDSelect_get(glyphIndex) {
+            if (glyphIndex < 0 || glyphIndex >= this.fdSelect.length) {
+              return -1;
+            }
+            return this.fdSelect[glyphIndex];
+          }
+        };
+        return CFFFDSelect;
+      }();
+      // Helper class to keep track of where an offset is within the data and helps
+      // filling in that offset once it's known.
+      var CFFOffsetTracker = function CFFOffsetTrackerClosure() {
+        function CFFOffsetTracker() {
+          this.offsets = Object.create(null);
+        }
+        CFFOffsetTracker.prototype = {
+          isTracking: function CFFOffsetTracker_isTracking(key) {
+            return key in this.offsets;
+          },
+          track: function CFFOffsetTracker_track(key, location) {
+            if (key in this.offsets) {
+              error('Already tracking location of ' + key);
+            }
+            this.offsets[key] = location;
+          },
+          offset: function CFFOffsetTracker_offset(value) {
+            for (var key in this.offsets) {
+              this.offsets[key] += value;
+            }
+          },
+          setEntryLocation: function CFFOffsetTracker_setEntryLocation(key, values, output) {
+            if (!(key in this.offsets)) {
+              error('Not tracking location of ' + key);
+            }
+            var data = output.data;
+            var dataOffset = this.offsets[key];
+            var size = 5;
+            for (var i = 0, ii = values.length; i < ii; ++i) {
+              var offset0 = i * size + dataOffset;
+              var offset1 = offset0 + 1;
+              var offset2 = offset0 + 2;
+              var offset3 = offset0 + 3;
+              var offset4 = offset0 + 4;
+              // It's easy to screw up offsets so perform this sanity check.
+              if (data[offset0] !== 0x1d || data[offset1] !== 0 || data[offset2] !== 0 || data[offset3] !== 0 || data[offset4] !== 0) {
+                error('writing to an offset that is not empty');
+              }
+              var value = values[i];
+              data[offset0] = 0x1d;
+              data[offset1] = value >> 24 & 0xFF;
+              data[offset2] = value >> 16 & 0xFF;
+              data[offset3] = value >> 8 & 0xFF;
+              data[offset4] = value & 0xFF;
+            }
+          }
+        };
+        return CFFOffsetTracker;
+      }();
+      // Takes a CFF and converts it to the binary representation.
+      var CFFCompiler = function CFFCompilerClosure() {
+        function CFFCompiler(cff) {
+          this.cff = cff;
+        }
+        CFFCompiler.prototype = {
+          compile: function CFFCompiler_compile() {
+            var cff = this.cff;
+            var output = {
+              data: [],
+              length: 0,
+              add: function CFFCompiler_add(data) {
+                this.data = this.data.concat(data);
+                this.length = this.data.length;
+              }
+            };
+            // Compile the five entries that must be in order.
+            var header = this.compileHeader(cff.header);
+            output.add(header);
+            var nameIndex = this.compileNameIndex(cff.names);
+            output.add(nameIndex);
+            if (cff.isCIDFont) {
+              // The spec is unclear on how font matrices should relate to each other
+              // when there is one in the main top dict and the sub top dicts.
+              // Windows handles this differently than linux and osx so we have to
+              // normalize to work on all.
+              // Rules based off of some mailing list discussions:
+              // - If main font has a matrix and subfont doesn't, use the main matrix.
+              // - If no main font matrix and there is a subfont matrix, use the
+              //   subfont matrix.
+              // - If both have matrices, concat together.
+              // - If neither have matrices, use default.
+              // To make this work on all platforms we move the top matrix into each
+              // sub top dict and concat if necessary.
+              if (cff.topDict.hasName('FontMatrix')) {
+                var base = cff.topDict.getByName('FontMatrix');
+                cff.topDict.removeByName('FontMatrix');
+                for (var i = 0, ii = cff.fdArray.length; i < ii; i++) {
+                  var subDict = cff.fdArray[i];
+                  var matrix = base.slice(0);
+                  if (subDict.hasName('FontMatrix')) {
+                    matrix = Util.transform(matrix, subDict.getByName('FontMatrix'));
+                  }
+                  subDict.setByName('FontMatrix', matrix);
+                }
+              }
+            }
+            var compiled = this.compileTopDicts([cff.topDict], output.length, cff.isCIDFont);
+            output.add(compiled.output);
+            var topDictTracker = compiled.trackers[0];
+            var stringIndex = this.compileStringIndex(cff.strings.strings);
+            output.add(stringIndex);
+            var globalSubrIndex = this.compileIndex(cff.globalSubrIndex);
+            output.add(globalSubrIndex);
+            // Now start on the other entries that have no specific order.
+            if (cff.encoding && cff.topDict.hasName('Encoding')) {
+              if (cff.encoding.predefined) {
+                topDictTracker.setEntryLocation('Encoding', [cff.encoding.format], output);
+              } else {
+                var encoding = this.compileEncoding(cff.encoding);
+                topDictTracker.setEntryLocation('Encoding', [output.length], output);
+                output.add(encoding);
+              }
+            }
+            if (cff.charset && cff.topDict.hasName('charset')) {
+              if (cff.charset.predefined) {
+                topDictTracker.setEntryLocation('charset', [cff.charset.format], output);
+              } else {
+                var charset = this.compileCharset(cff.charset);
+                topDictTracker.setEntryLocation('charset', [output.length], output);
+                output.add(charset);
+              }
+            }
+            var charStrings = this.compileCharStrings(cff.charStrings);
+            topDictTracker.setEntryLocation('CharStrings', [output.length], output);
+            output.add(charStrings);
+            if (cff.isCIDFont) {
+              // For some reason FDSelect must be in front of FDArray on windows. OSX
+              // and linux don't seem to care.
+              topDictTracker.setEntryLocation('FDSelect', [output.length], output);
+              var fdSelect = this.compileFDSelect(cff.fdSelect.raw);
+              output.add(fdSelect);
+              // It is unclear if the sub font dictionary can have CID related
+              // dictionary keys, but the sanitizer doesn't like them so remove them.
+              compiled = this.compileTopDicts(cff.fdArray, output.length, true);
+              topDictTracker.setEntryLocation('FDArray', [output.length], output);
+              output.add(compiled.output);
+              var fontDictTrackers = compiled.trackers;
+              this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output);
+            }
+            this.compilePrivateDicts([cff.topDict], [topDictTracker], output);
+            // If the font data ends with INDEX whose object data is zero-length,
+            // the sanitizer will bail out. Add a dummy byte to avoid that.
+            output.add([0]);
+            return output.data;
+          },
+          encodeNumber: function CFFCompiler_encodeNumber(value) {
+            if (parseFloat(value) === parseInt(value, 10) && !isNaN(value)) {
+              // isInt
+              return this.encodeInteger(value);
+            } else {
+              return this.encodeFloat(value);
+            }
+          },
+          encodeFloat: function CFFCompiler_encodeFloat(num) {
+            var value = num.toString();
+            // rounding inaccurate doubles
+            var m = /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(value);
+            if (m) {
+              var epsilon = parseFloat('1e' + ((m[2] ? +m[2] : 0) + m[1].length));
+              value = (Math.round(num * epsilon) / epsilon).toString();
+            }
+            var nibbles = '';
+            var i, ii;
+            for (i = 0, ii = value.length; i < ii; ++i) {
+              var a = value[i];
+              if (a === 'e') {
+                nibbles += value[++i] === '-' ? 'c' : 'b';
+              } else if (a === '.') {
+                nibbles += 'a';
+              } else if (a === '-') {
+                nibbles += 'e';
+              } else {
+                nibbles += a;
+              }
+            }
+            nibbles += nibbles.length & 1 ? 'f' : 'ff';
+            var out = [30];
+            for (i = 0, ii = nibbles.length; i < ii; i += 2) {
+              out.push(parseInt(nibbles.substr(i, 2), 16));
+            }
+            return out;
+          },
+          encodeInteger: function CFFCompiler_encodeInteger(value) {
+            var code;
+            if (value >= -107 && value <= 107) {
+              code = [value + 139];
+            } else if (value >= 108 && value <= 1131) {
+              value = value - 108;
+              code = [
+                (value >> 8) + 247,
+                value & 0xFF
+              ];
+            } else if (value >= -1131 && value <= -108) {
+              value = -value - 108;
+              code = [
+                (value >> 8) + 251,
+                value & 0xFF
+              ];
+            } else if (value >= -32768 && value <= 32767) {
+              code = [
+                0x1c,
+                value >> 8 & 0xFF,
+                value & 0xFF
+              ];
+            } else {
+              code = [
+                0x1d,
+                value >> 24 & 0xFF,
+                value >> 16 & 0xFF,
+                value >> 8 & 0xFF,
+                value & 0xFF
+              ];
+            }
+            return code;
+          },
+          compileHeader: function CFFCompiler_compileHeader(header) {
+            return [
+              header.major,
+              header.minor,
+              header.hdrSize,
+              header.offSize
+            ];
+          },
+          compileNameIndex: function CFFCompiler_compileNameIndex(names) {
+            var nameIndex = new CFFIndex();
+            for (var i = 0, ii = names.length; i < ii; ++i) {
+              nameIndex.add(stringToBytes(names[i]));
+            }
+            return this.compileIndex(nameIndex);
+          },
+          compileTopDicts: function CFFCompiler_compileTopDicts(dicts, length, removeCidKeys) {
+            var fontDictTrackers = [];
+            var fdArrayIndex = new CFFIndex();
+            for (var i = 0, ii = dicts.length; i < ii; ++i) {
+              var fontDict = dicts[i];
+              if (removeCidKeys) {
+                fontDict.removeByName('CIDFontVersion');
+                fontDict.removeByName('CIDFontRevision');
+                fontDict.removeByName('CIDFontType');
+                fontDict.removeByName('CIDCount');
+                fontDict.removeByName('UIDBase');
+              }
+              var fontDictTracker = new CFFOffsetTracker();
+              var fontDictData = this.compileDict(fontDict, fontDictTracker);
+              fontDictTrackers.push(fontDictTracker);
+              fdArrayIndex.add(fontDictData);
+              fontDictTracker.offset(length);
+            }
+            fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers);
+            return {
+              trackers: fontDictTrackers,
+              output: fdArrayIndex
+            };
+          },
+          compilePrivateDicts: function CFFCompiler_compilePrivateDicts(dicts, trackers, output) {
+            for (var i = 0, ii = dicts.length; i < ii; ++i) {
+              var fontDict = dicts[i];
+              assert(fontDict.privateDict && fontDict.hasName('Private'), 'There must be an private dictionary.');
+              var privateDict = fontDict.privateDict;
+              var privateDictTracker = new CFFOffsetTracker();
+              var privateDictData = this.compileDict(privateDict, privateDictTracker);
+              var outputLength = output.length;
+              privateDictTracker.offset(outputLength);
+              if (!privateDictData.length) {
+                // The private dictionary was empty, set the output length to zero to
+                // ensure the offset length isn't out of bounds in the eyes of the
+                // sanitizer.
+                outputLength = 0;
+              }
+              trackers[i].setEntryLocation('Private', [
+                privateDictData.length,
+                outputLength
+              ], output);
+              output.add(privateDictData);
+              if (privateDict.subrsIndex && privateDict.hasName('Subrs')) {
+                var subrs = this.compileIndex(privateDict.subrsIndex);
+                privateDictTracker.setEntryLocation('Subrs', [privateDictData.length], output);
+                output.add(subrs);
+              }
+            }
+          },
+          compileDict: function CFFCompiler_compileDict(dict, offsetTracker) {
+            var out = [];
+            // The dictionary keys must be in a certain order.
+            var order = dict.order;
+            for (var i = 0; i < order.length; ++i) {
+              var key = order[i];
+              if (!(key in dict.values)) {
+                continue;
+              }
+              var values = dict.values[key];
+              var types = dict.types[key];
+              if (!isArray(types)) {
+                types = [types];
+              }
+              if (!isArray(values)) {
+                values = [values];
+              }
+              // Remove any empty dict values.
+              if (values.length === 0) {
+                continue;
+              }
+              for (var j = 0, jj = types.length; j < jj; ++j) {
+                var type = types[j];
+                var value = values[j];
+                switch (type) {
+                case 'num':
+                case 'sid':
+                  out = out.concat(this.encodeNumber(value));
+                  break;
+                case 'offset':
+                  // For offsets we just insert a 32bit integer so we don't have to
+                  // deal with figuring out the length of the offset when it gets
+                  // replaced later on by the compiler.
+                  var name = dict.keyToNameMap[key];
+                  // Some offsets have the offset and the length, so just record the
+                  // position of the first one.
+                  if (!offsetTracker.isTracking(name)) {
+                    offsetTracker.track(name, out.length);
+                  }
+                  out = out.concat([
+                    0x1d,
+                    0,
+                    0,
+                    0,
+                    0
+                  ]);
+                  break;
+                case 'array':
+                case 'delta':
+                  out = out.concat(this.encodeNumber(value));
+                  for (var k = 1, kk = values.length; k < kk; ++k) {
+                    out = out.concat(this.encodeNumber(values[k]));
+                  }
+                  break;
+                default:
+                  error('Unknown data type of ' + type);
+                  break;
+                }
+              }
+              out = out.concat(dict.opcodes[key]);
+            }
+            return out;
+          },
+          compileStringIndex: function CFFCompiler_compileStringIndex(strings) {
+            var stringIndex = new CFFIndex();
+            for (var i = 0, ii = strings.length; i < ii; ++i) {
+              stringIndex.add(stringToBytes(strings[i]));
+            }
+            return this.compileIndex(stringIndex);
+          },
+          compileGlobalSubrIndex: function CFFCompiler_compileGlobalSubrIndex() {
+            var globalSubrIndex = this.cff.globalSubrIndex;
+            this.out.writeByteArray(this.compileIndex(globalSubrIndex));
+          },
+          compileCharStrings: function CFFCompiler_compileCharStrings(charStrings) {
+            return this.compileIndex(charStrings);
+          },
+          compileCharset: function CFFCompiler_compileCharset(charset) {
+            return this.compileTypedArray(charset.raw);
+          },
+          compileEncoding: function CFFCompiler_compileEncoding(encoding) {
+            return this.compileTypedArray(encoding.raw);
+          },
+          compileFDSelect: function CFFCompiler_compileFDSelect(fdSelect) {
+            return this.compileTypedArray(fdSelect);
+          },
+          compileTypedArray: function CFFCompiler_compileTypedArray(data) {
+            var out = [];
+            for (var i = 0, ii = data.length; i < ii; ++i) {
+              out[i] = data[i];
+            }
+            return out;
+          },
+          compileIndex: function CFFCompiler_compileIndex(index, trackers) {
+            trackers = trackers || [];
+            var objects = index.objects;
+            // First 2 bytes contains the number of objects contained into this index
+            var count = objects.length;
+            // If there is no object, just create an index. This technically
+            // should just be [0, 0] but OTS has an issue with that.
+            if (count === 0) {
+              return [
+                0,
+                0,
+                0
+              ];
+            }
+            var data = [
+              count >> 8 & 0xFF,
+              count & 0xff
+            ];
+            var lastOffset = 1, i;
+            for (i = 0; i < count; ++i) {
+              lastOffset += objects[i].length;
+            }
+            var offsetSize;
+            if (lastOffset < 0x100) {
+              offsetSize = 1;
+            } else if (lastOffset < 0x10000) {
+              offsetSize = 2;
+            } else if (lastOffset < 0x1000000) {
+              offsetSize = 3;
+            } else {
+              offsetSize = 4;
+            }
+            // Next byte contains the offset size use to reference object in the file
+            data.push(offsetSize);
+            // Add another offset after this one because we need a new offset
+            var relativeOffset = 1;
+            for (i = 0; i < count + 1; i++) {
+              if (offsetSize === 1) {
+                data.push(relativeOffset & 0xFF);
+              } else if (offsetSize === 2) {
+                data.push(relativeOffset >> 8 & 0xFF, relativeOffset & 0xFF);
+              } else if (offsetSize === 3) {
+                data.push(relativeOffset >> 16 & 0xFF, relativeOffset >> 8 & 0xFF, relativeOffset & 0xFF);
+              } else {
+                data.push(relativeOffset >>> 24 & 0xFF, relativeOffset >> 16 & 0xFF, relativeOffset >> 8 & 0xFF, relativeOffset & 0xFF);
+              }
+              if (objects[i]) {
+                relativeOffset += objects[i].length;
+              }
+            }
+            for (i = 0; i < count; i++) {
+              // Notify the tracker where the object will be offset in the data.
+              if (trackers[i]) {
+                trackers[i].offset(data.length);
+              }
+              for (var j = 0, jj = objects[i].length; j < jj; j++) {
+                data.push(objects[i][j]);
+              }
+            }
+            return data;
+          }
+        };
+        return CFFCompiler;
+      }();
+      exports.CFFStandardStrings = CFFStandardStrings;
+      exports.CFFParser = CFFParser;
+      exports.CFF = CFF;
+      exports.CFFHeader = CFFHeader;
+      exports.CFFStrings = CFFStrings;
+      exports.CFFIndex = CFFIndex;
+      exports.CFFCharset = CFFCharset;
+      exports.CFFTopDict = CFFTopDict;
+      exports.CFFPrivateDict = CFFPrivateDict;
+      exports.CFFCompiler = CFFCompiler;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreChunkedStream = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var MissingDataException = sharedUtil.MissingDataException;
+      var arrayByteLength = sharedUtil.arrayByteLength;
+      var arraysToBytes = sharedUtil.arraysToBytes;
+      var assert = sharedUtil.assert;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var isInt = sharedUtil.isInt;
+      var isEmptyObj = sharedUtil.isEmptyObj;
+      var ChunkedStream = function ChunkedStreamClosure() {
+        function ChunkedStream(length, chunkSize, manager) {
+          this.bytes = new Uint8Array(length);
+          this.start = 0;
+          this.pos = 0;
+          this.end = length;
+          this.chunkSize = chunkSize;
+          this.loadedChunks = [];
+          this.numChunksLoaded = 0;
+          this.numChunks = Math.ceil(length / chunkSize);
+          this.manager = manager;
+          this.progressiveDataLength = 0;
+          this.lastSuccessfulEnsureByteChunk = -1;
+        }
+        // a single-entry cache
+        // required methods for a stream. if a particular stream does not
+        // implement these, an error should be thrown
+        ChunkedStream.prototype = {
+          getMissingChunks: function ChunkedStream_getMissingChunks() {
+            var chunks = [];
+            for (var chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
+              if (!this.loadedChunks[chunk]) {
+                chunks.push(chunk);
+              }
+            }
+            return chunks;
+          },
+          getBaseStreams: function ChunkedStream_getBaseStreams() {
+            return [this];
+          },
+          allChunksLoaded: function ChunkedStream_allChunksLoaded() {
+            return this.numChunksLoaded === this.numChunks;
+          },
+          onReceiveData: function ChunkedStream_onReceiveData(begin, chunk) {
+            var end = begin + chunk.byteLength;
+            assert(begin % this.chunkSize === 0, 'Bad begin offset: ' + begin);
+            // Using this.length is inaccurate here since this.start can be moved
+            // See ChunkedStream.moveStart()
+            var length = this.bytes.length;
+            assert(end % this.chunkSize === 0 || end === length, 'Bad end offset: ' + end);
+            this.bytes.set(new Uint8Array(chunk), begin);
+            var chunkSize = this.chunkSize;
+            var beginChunk = Math.floor(begin / chunkSize);
+            var endChunk = Math.floor((end - 1) / chunkSize) + 1;
+            var curChunk;
+            for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
+              if (!this.loadedChunks[curChunk]) {
+                this.loadedChunks[curChunk] = true;
+                ++this.numChunksLoaded;
+              }
+            }
+          },
+          onReceiveProgressiveData: function ChunkedStream_onReceiveProgressiveData(data) {
+            var position = this.progressiveDataLength;
+            var beginChunk = Math.floor(position / this.chunkSize);
+            this.bytes.set(new Uint8Array(data), position);
+            position += data.byteLength;
+            this.progressiveDataLength = position;
+            var endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
+            var curChunk;
+            for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
+              if (!this.loadedChunks[curChunk]) {
+                this.loadedChunks[curChunk] = true;
+                ++this.numChunksLoaded;
+              }
+            }
+          },
+          ensureByte: function ChunkedStream_ensureByte(pos) {
+            var chunk = Math.floor(pos / this.chunkSize);
+            if (chunk === this.lastSuccessfulEnsureByteChunk) {
+              return;
+            }
+            if (!this.loadedChunks[chunk]) {
+              throw new MissingDataException(pos, pos + 1);
+            }
+            this.lastSuccessfulEnsureByteChunk = chunk;
+          },
+          ensureRange: function ChunkedStream_ensureRange(begin, end) {
+            if (begin >= end) {
+              return;
+            }
+            if (end <= this.progressiveDataLength) {
+              return;
+            }
+            var chunkSize = this.chunkSize;
+            var beginChunk = Math.floor(begin / chunkSize);
+            var endChunk = Math.floor((end - 1) / chunkSize) + 1;
+            for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
+              if (!this.loadedChunks[chunk]) {
+                throw new MissingDataException(begin, end);
+              }
+            }
+          },
+          nextEmptyChunk: function ChunkedStream_nextEmptyChunk(beginChunk) {
+            var chunk, numChunks = this.numChunks;
+            for (var i = 0; i < numChunks; ++i) {
+              chunk = (beginChunk + i) % numChunks;
+              // Wrap around to beginning
+              if (!this.loadedChunks[chunk]) {
+                return chunk;
+              }
+            }
+            return null;
+          },
+          hasChunk: function ChunkedStream_hasChunk(chunk) {
+            return !!this.loadedChunks[chunk];
+          },
+          get length() {
+            return this.end - this.start;
+          },
+          get isEmpty() {
+            return this.length === 0;
+          },
+          getByte: function ChunkedStream_getByte() {
+            var pos = this.pos;
+            if (pos >= this.end) {
+              return -1;
+            }
+            this.ensureByte(pos);
+            return this.bytes[this.pos++];
+          },
+          getUint16: function ChunkedStream_getUint16() {
+            var b0 = this.getByte();
+            var b1 = this.getByte();
+            if (b0 === -1 || b1 === -1) {
+              return -1;
+            }
+            return (b0 << 8) + b1;
+          },
+          getInt32: function ChunkedStream_getInt32() {
+            var b0 = this.getByte();
+            var b1 = this.getByte();
+            var b2 = this.getByte();
+            var b3 = this.getByte();
+            return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+          },
+          // returns subarray of original buffer
+          // should only be read
+          getBytes: function ChunkedStream_getBytes(length) {
+            var bytes = this.bytes;
+            var pos = this.pos;
+            var strEnd = this.end;
+            if (!length) {
+              this.ensureRange(pos, strEnd);
+              return bytes.subarray(pos, strEnd);
+            }
+            var end = pos + length;
+            if (end > strEnd) {
+              end = strEnd;
+            }
+            this.ensureRange(pos, end);
+            this.pos = end;
+            return bytes.subarray(pos, end);
+          },
+          peekByte: function ChunkedStream_peekByte() {
+            var peekedByte = this.getByte();
+            this.pos--;
+            return peekedByte;
+          },
+          peekBytes: function ChunkedStream_peekBytes(length) {
+            var bytes = this.getBytes(length);
+            this.pos -= bytes.length;
+            return bytes;
+          },
+          getByteRange: function ChunkedStream_getBytes(begin, end) {
+            this.ensureRange(begin, end);
+            return this.bytes.subarray(begin, end);
+          },
+          skip: function ChunkedStream_skip(n) {
+            if (!n) {
+              n = 1;
+            }
+            this.pos += n;
+          },
+          reset: function ChunkedStream_reset() {
+            this.pos = this.start;
+          },
+          moveStart: function ChunkedStream_moveStart() {
+            this.start = this.pos;
+          },
+          makeSubStream: function ChunkedStream_makeSubStream(start, length, dict) {
+            this.ensureRange(start, start + length);
+            function ChunkedStreamSubstream() {
+            }
+            ChunkedStreamSubstream.prototype = Object.create(this);
+            ChunkedStreamSubstream.prototype.getMissingChunks = function () {
+              var chunkSize = this.chunkSize;
+              var beginChunk = Math.floor(this.start / chunkSize);
+              var endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
+              var missingChunks = [];
+              for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
+                if (!this.loadedChunks[chunk]) {
+                  missingChunks.push(chunk);
+                }
+              }
+              return missingChunks;
+            };
+            var subStream = new ChunkedStreamSubstream();
+            subStream.pos = subStream.start = start;
+            subStream.end = start + length || this.end;
+            subStream.dict = dict;
+            return subStream;
+          },
+          isStream: true
+        };
+        return ChunkedStream;
+      }();
+      var ChunkedStreamManager = function ChunkedStreamManagerClosure() {
+        function ChunkedStreamManager(pdfNetworkStream, args) {
+          var chunkSize = args.rangeChunkSize;
+          var length = args.length;
+          this.stream = new ChunkedStream(length, chunkSize, this);
+          this.length = length;
+          this.chunkSize = chunkSize;
+          this.pdfNetworkStream = pdfNetworkStream;
+          this.url = args.url;
+          this.disableAutoFetch = args.disableAutoFetch;
+          this.msgHandler = args.msgHandler;
+          this.currRequestId = 0;
+          this.chunksNeededByRequest = Object.create(null);
+          this.requestsByChunk = Object.create(null);
+          this.promisesByRequest = Object.create(null);
+          this.progressiveDataLength = 0;
+          this.aborted = false;
+          this._loadedStreamCapability = createPromiseCapability();
+        }
+        ChunkedStreamManager.prototype = {
+          onLoadedStream: function ChunkedStreamManager_getLoadedStream() {
+            return this._loadedStreamCapability.promise;
+          },
+          sendRequest: function ChunkedStreamManager_sendRequest(begin, end) {
+            var rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
+            if (!rangeReader.isStreamingSupported) {
+              rangeReader.onProgress = this.onProgress.bind(this);
+            }
+            var chunks = [], loaded = 0;
+            var manager = this;
+            var promise = new Promise(function (resolve, reject) {
+              var readChunk = function (chunk) {
+                try {
+                  if (!chunk.done) {
+                    var data = chunk.value;
+                    chunks.push(data);
+                    loaded += arrayByteLength(data);
+                    if (rangeReader.isStreamingSupported) {
+                      manager.onProgress({ loaded: loaded });
+                    }
+                    rangeReader.read().then(readChunk, reject);
+                    return;
+                  }
+                  var chunkData = arraysToBytes(chunks);
+                  chunks = null;
+                  resolve(chunkData);
+                } catch (e) {
+                  reject(e);
+                }
+              };
+              rangeReader.read().then(readChunk, reject);
+            });
+            promise.then(function (data) {
+              if (this.aborted) {
+                return;
+              }
+              // ignoring any data after abort
+              this.onReceiveData({
+                chunk: data,
+                begin: begin
+              });
+            }.bind(this));
+          },
+          // TODO check errors
+          // Get all the chunks that are not yet loaded and groups them into
+          // contiguous ranges to load in as few requests as possible
+          requestAllChunks: function ChunkedStreamManager_requestAllChunks() {
+            var missingChunks = this.stream.getMissingChunks();
+            this._requestChunks(missingChunks);
+            return this._loadedStreamCapability.promise;
+          },
+          _requestChunks: function ChunkedStreamManager_requestChunks(chunks) {
+            var requestId = this.currRequestId++;
+            var i, ii;
+            var chunksNeeded = Object.create(null);
+            this.chunksNeededByRequest[requestId] = chunksNeeded;
+            for (i = 0, ii = chunks.length; i < ii; i++) {
+              if (!this.stream.hasChunk(chunks[i])) {
+                chunksNeeded[chunks[i]] = true;
+              }
+            }
+            if (isEmptyObj(chunksNeeded)) {
+              return Promise.resolve();
+            }
+            var capability = createPromiseCapability();
+            this.promisesByRequest[requestId] = capability;
+            var chunksToRequest = [];
+            for (var chunk in chunksNeeded) {
+              chunk = chunk | 0;
+              if (!(chunk in this.requestsByChunk)) {
+                this.requestsByChunk[chunk] = [];
+                chunksToRequest.push(chunk);
+              }
+              this.requestsByChunk[chunk].push(requestId);
+            }
+            if (!chunksToRequest.length) {
+              return capability.promise;
+            }
+            var groupedChunksToRequest = this.groupChunks(chunksToRequest);
+            for (i = 0; i < groupedChunksToRequest.length; ++i) {
+              var groupedChunk = groupedChunksToRequest[i];
+              var begin = groupedChunk.beginChunk * this.chunkSize;
+              var end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
+              this.sendRequest(begin, end);
+            }
+            return capability.promise;
+          },
+          getStream: function ChunkedStreamManager_getStream() {
+            return this.stream;
+          },
+          // Loads any chunks in the requested range that are not yet loaded
+          requestRange: function ChunkedStreamManager_requestRange(begin, end) {
+            end = Math.min(end, this.length);
+            var beginChunk = this.getBeginChunk(begin);
+            var endChunk = this.getEndChunk(end);
+            var chunks = [];
+            for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
+              chunks.push(chunk);
+            }
+            return this._requestChunks(chunks);
+          },
+          requestRanges: function ChunkedStreamManager_requestRanges(ranges) {
+            ranges = ranges || [];
+            var chunksToRequest = [];
+            for (var i = 0; i < ranges.length; i++) {
+              var beginChunk = this.getBeginChunk(ranges[i].begin);
+              var endChunk = this.getEndChunk(ranges[i].end);
+              for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
+                if (chunksToRequest.indexOf(chunk) < 0) {
+                  chunksToRequest.push(chunk);
+                }
+              }
+            }
+            chunksToRequest.sort(function (a, b) {
+              return a - b;
+            });
+            return this._requestChunks(chunksToRequest);
+          },
+          // Groups a sorted array of chunks into as few contiguous larger
+          // chunks as possible
+          groupChunks: function ChunkedStreamManager_groupChunks(chunks) {
+            var groupedChunks = [];
+            var beginChunk = -1;
+            var prevChunk = -1;
+            for (var i = 0; i < chunks.length; ++i) {
+              var chunk = chunks[i];
+              if (beginChunk < 0) {
+                beginChunk = chunk;
+              }
+              if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
+                groupedChunks.push({
+                  beginChunk: beginChunk,
+                  endChunk: prevChunk + 1
+                });
+                beginChunk = chunk;
+              }
+              if (i + 1 === chunks.length) {
+                groupedChunks.push({
+                  beginChunk: beginChunk,
+                  endChunk: chunk + 1
+                });
+              }
+              prevChunk = chunk;
+            }
+            return groupedChunks;
+          },
+          onProgress: function ChunkedStreamManager_onProgress(args) {
+            var bytesLoaded = this.stream.numChunksLoaded * this.chunkSize + args.loaded;
+            this.msgHandler.send('DocProgress', {
+              loaded: bytesLoaded,
+              total: this.length
+            });
+          },
+          onReceiveData: function ChunkedStreamManager_onReceiveData(args) {
+            var chunk = args.chunk;
+            var isProgressive = args.begin === undefined;
+            var begin = isProgressive ? this.progressiveDataLength : args.begin;
+            var end = begin + chunk.byteLength;
+            var beginChunk = Math.floor(begin / this.chunkSize);
+            var endChunk = end < this.length ? Math.floor(end / this.chunkSize) : Math.ceil(end / this.chunkSize);
+            if (isProgressive) {
+              this.stream.onReceiveProgressiveData(chunk);
+              this.progressiveDataLength = end;
+            } else {
+              this.stream.onReceiveData(begin, chunk);
+            }
+            if (this.stream.allChunksLoaded()) {
+              this._loadedStreamCapability.resolve(this.stream);
+            }
+            var loadedRequests = [];
+            var i, requestId;
+            for (chunk = beginChunk; chunk < endChunk; ++chunk) {
+              // The server might return more chunks than requested
+              var requestIds = this.requestsByChunk[chunk] || [];
+              delete this.requestsByChunk[chunk];
+              for (i = 0; i < requestIds.length; ++i) {
+                requestId = requestIds[i];
+                var chunksNeeded = this.chunksNeededByRequest[requestId];
+                if (chunk in chunksNeeded) {
+                  delete chunksNeeded[chunk];
+                }
+                if (!isEmptyObj(chunksNeeded)) {
+                  continue;
+                }
+                loadedRequests.push(requestId);
+              }
+            }
+            // If there are no pending requests, automatically fetch the next
+            // unfetched chunk of the PDF
+            if (!this.disableAutoFetch && isEmptyObj(this.requestsByChunk)) {
+              var nextEmptyChunk;
+              if (this.stream.numChunksLoaded === 1) {
+                // This is a special optimization so that after fetching the first
+                // chunk, rather than fetching the second chunk, we fetch the last
+                // chunk.
+                var lastChunk = this.stream.numChunks - 1;
+                if (!this.stream.hasChunk(lastChunk)) {
+                  nextEmptyChunk = lastChunk;
+                }
+              } else {
+                nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
+              }
+              if (isInt(nextEmptyChunk)) {
+                this._requestChunks([nextEmptyChunk]);
+              }
+            }
+            for (i = 0; i < loadedRequests.length; ++i) {
+              requestId = loadedRequests[i];
+              var capability = this.promisesByRequest[requestId];
+              delete this.promisesByRequest[requestId];
+              capability.resolve();
+            }
+            this.msgHandler.send('DocProgress', {
+              loaded: this.stream.numChunksLoaded * this.chunkSize,
+              total: this.length
+            });
+          },
+          onError: function ChunkedStreamManager_onError(err) {
+            this._loadedStreamCapability.reject(err);
+          },
+          getBeginChunk: function ChunkedStreamManager_getBeginChunk(begin) {
+            var chunk = Math.floor(begin / this.chunkSize);
+            return chunk;
+          },
+          getEndChunk: function ChunkedStreamManager_getEndChunk(end) {
+            var chunk = Math.floor((end - 1) / this.chunkSize) + 1;
+            return chunk;
+          },
+          abort: function ChunkedStreamManager_abort() {
+            this.aborted = true;
+            if (this.pdfNetworkStream) {
+              this.pdfNetworkStream.cancelAllRequests('abort');
+            }
+            for (var requestId in this.promisesByRequest) {
+              var capability = this.promisesByRequest[requestId];
+              capability.reject(new Error('Request was aborted'));
+            }
+          }
+        };
+        return ChunkedStreamManager;
+      }();
+      exports.ChunkedStream = ChunkedStream;
+      exports.ChunkedStreamManager = ChunkedStreamManager;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreGlyphList = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var getLookupTableFactory = sharedUtil.getLookupTableFactory;
+      var getGlyphsUnicode = getLookupTableFactory(function (t) {
+        t['A'] = 0x0041;
+        t['AE'] = 0x00C6;
+        t['AEacute'] = 0x01FC;
+        t['AEmacron'] = 0x01E2;
+        t['AEsmall'] = 0xF7E6;
+        t['Aacute'] = 0x00C1;
+        t['Aacutesmall'] = 0xF7E1;
+        t['Abreve'] = 0x0102;
+        t['Abreveacute'] = 0x1EAE;
+        t['Abrevecyrillic'] = 0x04D0;
+        t['Abrevedotbelow'] = 0x1EB6;
+        t['Abrevegrave'] = 0x1EB0;
+        t['Abrevehookabove'] = 0x1EB2;
+        t['Abrevetilde'] = 0x1EB4;
+        t['Acaron'] = 0x01CD;
+        t['Acircle'] = 0x24B6;
+        t['Acircumflex'] = 0x00C2;
+        t['Acircumflexacute'] = 0x1EA4;
+        t['Acircumflexdotbelow'] = 0x1EAC;
+        t['Acircumflexgrave'] = 0x1EA6;
+        t['Acircumflexhookabove'] = 0x1EA8;
+        t['Acircumflexsmall'] = 0xF7E2;
+        t['Acircumflextilde'] = 0x1EAA;
+        t['Acute'] = 0xF6C9;
+        t['Acutesmall'] = 0xF7B4;
+        t['Acyrillic'] = 0x0410;
+        t['Adblgrave'] = 0x0200;
+        t['Adieresis'] = 0x00C4;
+        t['Adieresiscyrillic'] = 0x04D2;
+        t['Adieresismacron'] = 0x01DE;
+        t['Adieresissmall'] = 0xF7E4;
+        t['Adotbelow'] = 0x1EA0;
+        t['Adotmacron'] = 0x01E0;
+        t['Agrave'] = 0x00C0;
+        t['Agravesmall'] = 0xF7E0;
+        t['Ahookabove'] = 0x1EA2;
+        t['Aiecyrillic'] = 0x04D4;
+        t['Ainvertedbreve'] = 0x0202;
+        t['Alpha'] = 0x0391;
+        t['Alphatonos'] = 0x0386;
+        t['Amacron'] = 0x0100;
+        t['Amonospace'] = 0xFF21;
+        t['Aogonek'] = 0x0104;
+        t['Aring'] = 0x00C5;
+        t['Aringacute'] = 0x01FA;
+        t['Aringbelow'] = 0x1E00;
+        t['Aringsmall'] = 0xF7E5;
+        t['Asmall'] = 0xF761;
+        t['Atilde'] = 0x00C3;
+        t['Atildesmall'] = 0xF7E3;
+        t['Aybarmenian'] = 0x0531;
+        t['B'] = 0x0042;
+        t['Bcircle'] = 0x24B7;
+        t['Bdotaccent'] = 0x1E02;
+        t['Bdotbelow'] = 0x1E04;
+        t['Becyrillic'] = 0x0411;
+        t['Benarmenian'] = 0x0532;
+        t['Beta'] = 0x0392;
+        t['Bhook'] = 0x0181;
+        t['Blinebelow'] = 0x1E06;
+        t['Bmonospace'] = 0xFF22;
+        t['Brevesmall'] = 0xF6F4;
+        t['Bsmall'] = 0xF762;
+        t['Btopbar'] = 0x0182;
+        t['C'] = 0x0043;
+        t['Caarmenian'] = 0x053E;
+        t['Cacute'] = 0x0106;
+        t['Caron'] = 0xF6CA;
+        t['Caronsmall'] = 0xF6F5;
+        t['Ccaron'] = 0x010C;
+        t['Ccedilla'] = 0x00C7;
+        t['Ccedillaacute'] = 0x1E08;
+        t['Ccedillasmall'] = 0xF7E7;
+        t['Ccircle'] = 0x24B8;
+        t['Ccircumflex'] = 0x0108;
+        t['Cdot'] = 0x010A;
+        t['Cdotaccent'] = 0x010A;
+        t['Cedillasmall'] = 0xF7B8;
+        t['Chaarmenian'] = 0x0549;
+        t['Cheabkhasiancyrillic'] = 0x04BC;
+        t['Checyrillic'] = 0x0427;
+        t['Chedescenderabkhasiancyrillic'] = 0x04BE;
+        t['Chedescendercyrillic'] = 0x04B6;
+        t['Chedieresiscyrillic'] = 0x04F4;
+        t['Cheharmenian'] = 0x0543;
+        t['Chekhakassiancyrillic'] = 0x04CB;
+        t['Cheverticalstrokecyrillic'] = 0x04B8;
+        t['Chi'] = 0x03A7;
+        t['Chook'] = 0x0187;
+        t['Circumflexsmall'] = 0xF6F6;
+        t['Cmonospace'] = 0xFF23;
+        t['Coarmenian'] = 0x0551;
+        t['Csmall'] = 0xF763;
+        t['D'] = 0x0044;
+        t['DZ'] = 0x01F1;
+        t['DZcaron'] = 0x01C4;
+        t['Daarmenian'] = 0x0534;
+        t['Dafrican'] = 0x0189;
+        t['Dcaron'] = 0x010E;
+        t['Dcedilla'] = 0x1E10;
+        t['Dcircle'] = 0x24B9;
+        t['Dcircumflexbelow'] = 0x1E12;
+        t['Dcroat'] = 0x0110;
+        t['Ddotaccent'] = 0x1E0A;
+        t['Ddotbelow'] = 0x1E0C;
+        t['Decyrillic'] = 0x0414;
+        t['Deicoptic'] = 0x03EE;
+        t['Delta'] = 0x2206;
+        t['Deltagreek'] = 0x0394;
+        t['Dhook'] = 0x018A;
+        t['Dieresis'] = 0xF6CB;
+        t['DieresisAcute'] = 0xF6CC;
+        t['DieresisGrave'] = 0xF6CD;
+        t['Dieresissmall'] = 0xF7A8;
+        t['Digammagreek'] = 0x03DC;
+        t['Djecyrillic'] = 0x0402;
+        t['Dlinebelow'] = 0x1E0E;
+        t['Dmonospace'] = 0xFF24;
+        t['Dotaccentsmall'] = 0xF6F7;
+        t['Dslash'] = 0x0110;
+        t['Dsmall'] = 0xF764;
+        t['Dtopbar'] = 0x018B;
+        t['Dz'] = 0x01F2;
+        t['Dzcaron'] = 0x01C5;
+        t['Dzeabkhasiancyrillic'] = 0x04E0;
+        t['Dzecyrillic'] = 0x0405;
+        t['Dzhecyrillic'] = 0x040F;
+        t['E'] = 0x0045;
+        t['Eacute'] = 0x00C9;
+        t['Eacutesmall'] = 0xF7E9;
+        t['Ebreve'] = 0x0114;
+        t['Ecaron'] = 0x011A;
+        t['Ecedillabreve'] = 0x1E1C;
+        t['Echarmenian'] = 0x0535;
+        t['Ecircle'] = 0x24BA;
+        t['Ecircumflex'] = 0x00CA;
+        t['Ecircumflexacute'] = 0x1EBE;
+        t['Ecircumflexbelow'] = 0x1E18;
+        t['Ecircumflexdotbelow'] = 0x1EC6;
+        t['Ecircumflexgrave'] = 0x1EC0;
+        t['Ecircumflexhookabove'] = 0x1EC2;
+        t['Ecircumflexsmall'] = 0xF7EA;
+        t['Ecircumflextilde'] = 0x1EC4;
+        t['Ecyrillic'] = 0x0404;
+        t['Edblgrave'] = 0x0204;
+        t['Edieresis'] = 0x00CB;
+        t['Edieresissmall'] = 0xF7EB;
+        t['Edot'] = 0x0116;
+        t['Edotaccent'] = 0x0116;
+        t['Edotbelow'] = 0x1EB8;
+        t['Efcyrillic'] = 0x0424;
+        t['Egrave'] = 0x00C8;
+        t['Egravesmall'] = 0xF7E8;
+        t['Eharmenian'] = 0x0537;
+        t['Ehookabove'] = 0x1EBA;
+        t['Eightroman'] = 0x2167;
+        t['Einvertedbreve'] = 0x0206;
+        t['Eiotifiedcyrillic'] = 0x0464;
+        t['Elcyrillic'] = 0x041B;
+        t['Elevenroman'] = 0x216A;
+        t['Emacron'] = 0x0112;
+        t['Emacronacute'] = 0x1E16;
+        t['Emacrongrave'] = 0x1E14;
+        t['Emcyrillic'] = 0x041C;
+        t['Emonospace'] = 0xFF25;
+        t['Encyrillic'] = 0x041D;
+        t['Endescendercyrillic'] = 0x04A2;
+        t['Eng'] = 0x014A;
+        t['Enghecyrillic'] = 0x04A4;
+        t['Enhookcyrillic'] = 0x04C7;
+        t['Eogonek'] = 0x0118;
+        t['Eopen'] = 0x0190;
+        t['Epsilon'] = 0x0395;
+        t['Epsilontonos'] = 0x0388;
+        t['Ercyrillic'] = 0x0420;
+        t['Ereversed'] = 0x018E;
+        t['Ereversedcyrillic'] = 0x042D;
+        t['Escyrillic'] = 0x0421;
+        t['Esdescendercyrillic'] = 0x04AA;
+        t['Esh'] = 0x01A9;
+        t['Esmall'] = 0xF765;
+        t['Eta'] = 0x0397;
+        t['Etarmenian'] = 0x0538;
+        t['Etatonos'] = 0x0389;
+        t['Eth'] = 0x00D0;
+        t['Ethsmall'] = 0xF7F0;
+        t['Etilde'] = 0x1EBC;
+        t['Etildebelow'] = 0x1E1A;
+        t['Euro'] = 0x20AC;
+        t['Ezh'] = 0x01B7;
+        t['Ezhcaron'] = 0x01EE;
+        t['Ezhreversed'] = 0x01B8;
+        t['F'] = 0x0046;
+        t['Fcircle'] = 0x24BB;
+        t['Fdotaccent'] = 0x1E1E;
+        t['Feharmenian'] = 0x0556;
+        t['Feicoptic'] = 0x03E4;
+        t['Fhook'] = 0x0191;
+        t['Fitacyrillic'] = 0x0472;
+        t['Fiveroman'] = 0x2164;
+        t['Fmonospace'] = 0xFF26;
+        t['Fourroman'] = 0x2163;
+        t['Fsmall'] = 0xF766;
+        t['G'] = 0x0047;
+        t['GBsquare'] = 0x3387;
+        t['Gacute'] = 0x01F4;
+        t['Gamma'] = 0x0393;
+        t['Gammaafrican'] = 0x0194;
+        t['Gangiacoptic'] = 0x03EA;
+        t['Gbreve'] = 0x011E;
+        t['Gcaron'] = 0x01E6;
+        t['Gcedilla'] = 0x0122;
+        t['Gcircle'] = 0x24BC;
+        t['Gcircumflex'] = 0x011C;
+        t['Gcommaaccent'] = 0x0122;
+        t['Gdot'] = 0x0120;
+        t['Gdotaccent'] = 0x0120;
+        t['Gecyrillic'] = 0x0413;
+        t['Ghadarmenian'] = 0x0542;
+        t['Ghemiddlehookcyrillic'] = 0x0494;
+        t['Ghestrokecyrillic'] = 0x0492;
+        t['Gheupturncyrillic'] = 0x0490;
+        t['Ghook'] = 0x0193;
+        t['Gimarmenian'] = 0x0533;
+        t['Gjecyrillic'] = 0x0403;
+        t['Gmacron'] = 0x1E20;
+        t['Gmonospace'] = 0xFF27;
+        t['Grave'] = 0xF6CE;
+        t['Gravesmall'] = 0xF760;
+        t['Gsmall'] = 0xF767;
+        t['Gsmallhook'] = 0x029B;
+        t['Gstroke'] = 0x01E4;
+        t['H'] = 0x0048;
+        t['H18533'] = 0x25CF;
+        t['H18543'] = 0x25AA;
+        t['H18551'] = 0x25AB;
+        t['H22073'] = 0x25A1;
+        t['HPsquare'] = 0x33CB;
+        t['Haabkhasiancyrillic'] = 0x04A8;
+        t['Hadescendercyrillic'] = 0x04B2;
+        t['Hardsigncyrillic'] = 0x042A;
+        t['Hbar'] = 0x0126;
+        t['Hbrevebelow'] = 0x1E2A;
+        t['Hcedilla'] = 0x1E28;
+        t['Hcircle'] = 0x24BD;
+        t['Hcircumflex'] = 0x0124;
+        t['Hdieresis'] = 0x1E26;
+        t['Hdotaccent'] = 0x1E22;
+        t['Hdotbelow'] = 0x1E24;
+        t['Hmonospace'] = 0xFF28;
+        t['Hoarmenian'] = 0x0540;
+        t['Horicoptic'] = 0x03E8;
+        t['Hsmall'] = 0xF768;
+        t['Hungarumlaut'] = 0xF6CF;
+        t['Hungarumlautsmall'] = 0xF6F8;
+        t['Hzsquare'] = 0x3390;
+        t['I'] = 0x0049;
+        t['IAcyrillic'] = 0x042F;
+        t['IJ'] = 0x0132;
+        t['IUcyrillic'] = 0x042E;
+        t['Iacute'] = 0x00CD;
+        t['Iacutesmall'] = 0xF7ED;
+        t['Ibreve'] = 0x012C;
+        t['Icaron'] = 0x01CF;
+        t['Icircle'] = 0x24BE;
+        t['Icircumflex'] = 0x00CE;
+        t['Icircumflexsmall'] = 0xF7EE;
+        t['Icyrillic'] = 0x0406;
+        t['Idblgrave'] = 0x0208;
+        t['Idieresis'] = 0x00CF;
+        t['Idieresisacute'] = 0x1E2E;
+        t['Idieresiscyrillic'] = 0x04E4;
+        t['Idieresissmall'] = 0xF7EF;
+        t['Idot'] = 0x0130;
+        t['Idotaccent'] = 0x0130;
+        t['Idotbelow'] = 0x1ECA;
+        t['Iebrevecyrillic'] = 0x04D6;
+        t['Iecyrillic'] = 0x0415;
+        t['Ifraktur'] = 0x2111;
+        t['Igrave'] = 0x00CC;
+        t['Igravesmall'] = 0xF7EC;
+        t['Ihookabove'] = 0x1EC8;
+        t['Iicyrillic'] = 0x0418;
+        t['Iinvertedbreve'] = 0x020A;
+        t['Iishortcyrillic'] = 0x0419;
+        t['Imacron'] = 0x012A;
+        t['Imacroncyrillic'] = 0x04E2;
+        t['Imonospace'] = 0xFF29;
+        t['Iniarmenian'] = 0x053B;
+        t['Iocyrillic'] = 0x0401;
+        t['Iogonek'] = 0x012E;
+        t['Iota'] = 0x0399;
+        t['Iotaafrican'] = 0x0196;
+        t['Iotadieresis'] = 0x03AA;
+        t['Iotatonos'] = 0x038A;
+        t['Ismall'] = 0xF769;
+        t['Istroke'] = 0x0197;
+        t['Itilde'] = 0x0128;
+        t['Itildebelow'] = 0x1E2C;
+        t['Izhitsacyrillic'] = 0x0474;
+        t['Izhitsadblgravecyrillic'] = 0x0476;
+        t['J'] = 0x004A;
+        t['Jaarmenian'] = 0x0541;
+        t['Jcircle'] = 0x24BF;
+        t['Jcircumflex'] = 0x0134;
+        t['Jecyrillic'] = 0x0408;
+        t['Jheharmenian'] = 0x054B;
+        t['Jmonospace'] = 0xFF2A;
+        t['Jsmall'] = 0xF76A;
+        t['K'] = 0x004B;
+        t['KBsquare'] = 0x3385;
+        t['KKsquare'] = 0x33CD;
+        t['Kabashkircyrillic'] = 0x04A0;
+        t['Kacute'] = 0x1E30;
+        t['Kacyrillic'] = 0x041A;
+        t['Kadescendercyrillic'] = 0x049A;
+        t['Kahookcyrillic'] = 0x04C3;
+        t['Kappa'] = 0x039A;
+        t['Kastrokecyrillic'] = 0x049E;
+        t['Kaverticalstrokecyrillic'] = 0x049C;
+        t['Kcaron'] = 0x01E8;
+        t['Kcedilla'] = 0x0136;
+        t['Kcircle'] = 0x24C0;
+        t['Kcommaaccent'] = 0x0136;
+        t['Kdotbelow'] = 0x1E32;
+        t['Keharmenian'] = 0x0554;
+        t['Kenarmenian'] = 0x053F;
+        t['Khacyrillic'] = 0x0425;
+        t['Kheicoptic'] = 0x03E6;
+        t['Khook'] = 0x0198;
+        t['Kjecyrillic'] = 0x040C;
+        t['Klinebelow'] = 0x1E34;
+        t['Kmonospace'] = 0xFF2B;
+        t['Koppacyrillic'] = 0x0480;
+        t['Koppagreek'] = 0x03DE;
+        t['Ksicyrillic'] = 0x046E;
+        t['Ksmall'] = 0xF76B;
+        t['L'] = 0x004C;
+        t['LJ'] = 0x01C7;
+        t['LL'] = 0xF6BF;
+        t['Lacute'] = 0x0139;
+        t['Lambda'] = 0x039B;
+        t['Lcaron'] = 0x013D;
+        t['Lcedilla'] = 0x013B;
+        t['Lcircle'] = 0x24C1;
+        t['Lcircumflexbelow'] = 0x1E3C;
+        t['Lcommaaccent'] = 0x013B;
+        t['Ldot'] = 0x013F;
+        t['Ldotaccent'] = 0x013F;
+        t['Ldotbelow'] = 0x1E36;
+        t['Ldotbelowmacron'] = 0x1E38;
+        t['Liwnarmenian'] = 0x053C;
+        t['Lj'] = 0x01C8;
+        t['Ljecyrillic'] = 0x0409;
+        t['Llinebelow'] = 0x1E3A;
+        t['Lmonospace'] = 0xFF2C;
+        t['Lslash'] = 0x0141;
+        t['Lslashsmall'] = 0xF6F9;
+        t['Lsmall'] = 0xF76C;
+        t['M'] = 0x004D;
+        t['MBsquare'] = 0x3386;
+        t['Macron'] = 0xF6D0;
+        t['Macronsmall'] = 0xF7AF;
+        t['Macute'] = 0x1E3E;
+        t['Mcircle'] = 0x24C2;
+        t['Mdotaccent'] = 0x1E40;
+        t['Mdotbelow'] = 0x1E42;
+        t['Menarmenian'] = 0x0544;
+        t['Mmonospace'] = 0xFF2D;
+        t['Msmall'] = 0xF76D;
+        t['Mturned'] = 0x019C;
+        t['Mu'] = 0x039C;
+        t['N'] = 0x004E;
+        t['NJ'] = 0x01CA;
+        t['Nacute'] = 0x0143;
+        t['Ncaron'] = 0x0147;
+        t['Ncedilla'] = 0x0145;
+        t['Ncircle'] = 0x24C3;
+        t['Ncircumflexbelow'] = 0x1E4A;
+        t['Ncommaaccent'] = 0x0145;
+        t['Ndotaccent'] = 0x1E44;
+        t['Ndotbelow'] = 0x1E46;
+        t['Nhookleft'] = 0x019D;
+        t['Nineroman'] = 0x2168;
+        t['Nj'] = 0x01CB;
+        t['Njecyrillic'] = 0x040A;
+        t['Nlinebelow'] = 0x1E48;
+        t['Nmonospace'] = 0xFF2E;
+        t['Nowarmenian'] = 0x0546;
+        t['Nsmall'] = 0xF76E;
+        t['Ntilde'] = 0x00D1;
+        t['Ntildesmall'] = 0xF7F1;
+        t['Nu'] = 0x039D;
+        t['O'] = 0x004F;
+        t['OE'] = 0x0152;
+        t['OEsmall'] = 0xF6FA;
+        t['Oacute'] = 0x00D3;
+        t['Oacutesmall'] = 0xF7F3;
+        t['Obarredcyrillic'] = 0x04E8;
+        t['Obarreddieresiscyrillic'] = 0x04EA;
+        t['Obreve'] = 0x014E;
+        t['Ocaron'] = 0x01D1;
+        t['Ocenteredtilde'] = 0x019F;
+        t['Ocircle'] = 0x24C4;
+        t['Ocircumflex'] = 0x00D4;
+        t['Ocircumflexacute'] = 0x1ED0;
+        t['Ocircumflexdotbelow'] = 0x1ED8;
+        t['Ocircumflexgrave'] = 0x1ED2;
+        t['Ocircumflexhookabove'] = 0x1ED4;
+        t['Ocircumflexsmall'] = 0xF7F4;
+        t['Ocircumflextilde'] = 0x1ED6;
+        t['Ocyrillic'] = 0x041E;
+        t['Odblacute'] = 0x0150;
+        t['Odblgrave'] = 0x020C;
+        t['Odieresis'] = 0x00D6;
+        t['Odieresiscyrillic'] = 0x04E6;
+        t['Odieresissmall'] = 0xF7F6;
+        t['Odotbelow'] = 0x1ECC;
+        t['Ogoneksmall'] = 0xF6FB;
+        t['Ograve'] = 0x00D2;
+        t['Ogravesmall'] = 0xF7F2;
+        t['Oharmenian'] = 0x0555;
+        t['Ohm'] = 0x2126;
+        t['Ohookabove'] = 0x1ECE;
+        t['Ohorn'] = 0x01A0;
+        t['Ohornacute'] = 0x1EDA;
+        t['Ohorndotbelow'] = 0x1EE2;
+        t['Ohorngrave'] = 0x1EDC;
+        t['Ohornhookabove'] = 0x1EDE;
+        t['Ohorntilde'] = 0x1EE0;
+        t['Ohungarumlaut'] = 0x0150;
+        t['Oi'] = 0x01A2;
+        t['Oinvertedbreve'] = 0x020E;
+        t['Omacron'] = 0x014C;
+        t['Omacronacute'] = 0x1E52;
+        t['Omacrongrave'] = 0x1E50;
+        t['Omega'] = 0x2126;
+        t['Omegacyrillic'] = 0x0460;
+        t['Omegagreek'] = 0x03A9;
+        t['Omegaroundcyrillic'] = 0x047A;
+        t['Omegatitlocyrillic'] = 0x047C;
+        t['Omegatonos'] = 0x038F;
+        t['Omicron'] = 0x039F;
+        t['Omicrontonos'] = 0x038C;
+        t['Omonospace'] = 0xFF2F;
+        t['Oneroman'] = 0x2160;
+        t['Oogonek'] = 0x01EA;
+        t['Oogonekmacron'] = 0x01EC;
+        t['Oopen'] = 0x0186;
+        t['Oslash'] = 0x00D8;
+        t['Oslashacute'] = 0x01FE;
+        t['Oslashsmall'] = 0xF7F8;
+        t['Osmall'] = 0xF76F;
+        t['Ostrokeacute'] = 0x01FE;
+        t['Otcyrillic'] = 0x047E;
+        t['Otilde'] = 0x00D5;
+        t['Otildeacute'] = 0x1E4C;
+        t['Otildedieresis'] = 0x1E4E;
+        t['Otildesmall'] = 0xF7F5;
+        t['P'] = 0x0050;
+        t['Pacute'] = 0x1E54;
+        t['Pcircle'] = 0x24C5;
+        t['Pdotaccent'] = 0x1E56;
+        t['Pecyrillic'] = 0x041F;
+        t['Peharmenian'] = 0x054A;
+        t['Pemiddlehookcyrillic'] = 0x04A6;
+        t['Phi'] = 0x03A6;
+        t['Phook'] = 0x01A4;
+        t['Pi'] = 0x03A0;
+        t['Piwrarmenian'] = 0x0553;
+        t['Pmonospace'] = 0xFF30;
+        t['Psi'] = 0x03A8;
+        t['Psicyrillic'] = 0x0470;
+        t['Psmall'] = 0xF770;
+        t['Q'] = 0x0051;
+        t['Qcircle'] = 0x24C6;
+        t['Qmonospace'] = 0xFF31;
+        t['Qsmall'] = 0xF771;
+        t['R'] = 0x0052;
+        t['Raarmenian'] = 0x054C;
+        t['Racute'] = 0x0154;
+        t['Rcaron'] = 0x0158;
+        t['Rcedilla'] = 0x0156;
+        t['Rcircle'] = 0x24C7;
+        t['Rcommaaccent'] = 0x0156;
+        t['Rdblgrave'] = 0x0210;
+        t['Rdotaccent'] = 0x1E58;
+        t['Rdotbelow'] = 0x1E5A;
+        t['Rdotbelowmacron'] = 0x1E5C;
+        t['Reharmenian'] = 0x0550;
+        t['Rfraktur'] = 0x211C;
+        t['Rho'] = 0x03A1;
+        t['Ringsmall'] = 0xF6FC;
+        t['Rinvertedbreve'] = 0x0212;
+        t['Rlinebelow'] = 0x1E5E;
+        t['Rmonospace'] = 0xFF32;
+        t['Rsmall'] = 0xF772;
+        t['Rsmallinverted'] = 0x0281;
+        t['Rsmallinvertedsuperior'] = 0x02B6;
+        t['S'] = 0x0053;
+        t['SF010000'] = 0x250C;
+        t['SF020000'] = 0x2514;
+        t['SF030000'] = 0x2510;
+        t['SF040000'] = 0x2518;
+        t['SF050000'] = 0x253C;
+        t['SF060000'] = 0x252C;
+        t['SF070000'] = 0x2534;
+        t['SF080000'] = 0x251C;
+        t['SF090000'] = 0x2524;
+        t['SF100000'] = 0x2500;
+        t['SF110000'] = 0x2502;
+        t['SF190000'] = 0x2561;
+        t['SF200000'] = 0x2562;
+        t['SF210000'] = 0x2556;
+        t['SF220000'] = 0x2555;
+        t['SF230000'] = 0x2563;
+        t['SF240000'] = 0x2551;
+        t['SF250000'] = 0x2557;
+        t['SF260000'] = 0x255D;
+        t['SF270000'] = 0x255C;
+        t['SF280000'] = 0x255B;
+        t['SF360000'] = 0x255E;
+        t['SF370000'] = 0x255F;
+        t['SF380000'] = 0x255A;
+        t['SF390000'] = 0x2554;
+        t['SF400000'] = 0x2569;
+        t['SF410000'] = 0x2566;
+        t['SF420000'] = 0x2560;
+        t['SF430000'] = 0x2550;
+        t['SF440000'] = 0x256C;
+        t['SF450000'] = 0x2567;
+        t['SF460000'] = 0x2568;
+        t['SF470000'] = 0x2564;
+        t['SF480000'] = 0x2565;
+        t['SF490000'] = 0x2559;
+        t['SF500000'] = 0x2558;
+        t['SF510000'] = 0x2552;
+        t['SF520000'] = 0x2553;
+        t['SF530000'] = 0x256B;
+        t['SF540000'] = 0x256A;
+        t['Sacute'] = 0x015A;
+        t['Sacutedotaccent'] = 0x1E64;
+        t['Sampigreek'] = 0x03E0;
+        t['Scaron'] = 0x0160;
+        t['Scarondotaccent'] = 0x1E66;
+        t['Scaronsmall'] = 0xF6FD;
+        t['Scedilla'] = 0x015E;
+        t['Schwa'] = 0x018F;
+        t['Schwacyrillic'] = 0x04D8;
+        t['Schwadieresiscyrillic'] = 0x04DA;
+        t['Scircle'] = 0x24C8;
+        t['Scircumflex'] = 0x015C;
+        t['Scommaaccent'] = 0x0218;
+        t['Sdotaccent'] = 0x1E60;
+        t['Sdotbelow'] = 0x1E62;
+        t['Sdotbelowdotaccent'] = 0x1E68;
+        t['Seharmenian'] = 0x054D;
+        t['Sevenroman'] = 0x2166;
+        t['Shaarmenian'] = 0x0547;
+        t['Shacyrillic'] = 0x0428;
+        t['Shchacyrillic'] = 0x0429;
+        t['Sheicoptic'] = 0x03E2;
+        t['Shhacyrillic'] = 0x04BA;
+        t['Shimacoptic'] = 0x03EC;
+        t['Sigma'] = 0x03A3;
+        t['Sixroman'] = 0x2165;
+        t['Smonospace'] = 0xFF33;
+        t['Softsigncyrillic'] = 0x042C;
+        t['Ssmall'] = 0xF773;
+        t['Stigmagreek'] = 0x03DA;
+        t['T'] = 0x0054;
+        t['Tau'] = 0x03A4;
+        t['Tbar'] = 0x0166;
+        t['Tcaron'] = 0x0164;
+        t['Tcedilla'] = 0x0162;
+        t['Tcircle'] = 0x24C9;
+        t['Tcircumflexbelow'] = 0x1E70;
+        t['Tcommaaccent'] = 0x0162;
+        t['Tdotaccent'] = 0x1E6A;
+        t['Tdotbelow'] = 0x1E6C;
+        t['Tecyrillic'] = 0x0422;
+        t['Tedescendercyrillic'] = 0x04AC;
+        t['Tenroman'] = 0x2169;
+        t['Tetsecyrillic'] = 0x04B4;
+        t['Theta'] = 0x0398;
+        t['Thook'] = 0x01AC;
+        t['Thorn'] = 0x00DE;
+        t['Thornsmall'] = 0xF7FE;
+        t['Threeroman'] = 0x2162;
+        t['Tildesmall'] = 0xF6FE;
+        t['Tiwnarmenian'] = 0x054F;
+        t['Tlinebelow'] = 0x1E6E;
+        t['Tmonospace'] = 0xFF34;
+        t['Toarmenian'] = 0x0539;
+        t['Tonefive'] = 0x01BC;
+        t['Tonesix'] = 0x0184;
+        t['Tonetwo'] = 0x01A7;
+        t['Tretroflexhook'] = 0x01AE;
+        t['Tsecyrillic'] = 0x0426;
+        t['Tshecyrillic'] = 0x040B;
+        t['Tsmall'] = 0xF774;
+        t['Twelveroman'] = 0x216B;
+        t['Tworoman'] = 0x2161;
+        t['U'] = 0x0055;
+        t['Uacute'] = 0x00DA;
+        t['Uacutesmall'] = 0xF7FA;
+        t['Ubreve'] = 0x016C;
+        t['Ucaron'] = 0x01D3;
+        t['Ucircle'] = 0x24CA;
+        t['Ucircumflex'] = 0x00DB;
+        t['Ucircumflexbelow'] = 0x1E76;
+        t['Ucircumflexsmall'] = 0xF7FB;
+        t['Ucyrillic'] = 0x0423;
+        t['Udblacute'] = 0x0170;
+        t['Udblgrave'] = 0x0214;
+        t['Udieresis'] = 0x00DC;
+        t['Udieresisacute'] = 0x01D7;
+        t['Udieresisbelow'] = 0x1E72;
+        t['Udieresiscaron'] = 0x01D9;
+        t['Udieresiscyrillic'] = 0x04F0;
+        t['Udieresisgrave'] = 0x01DB;
+        t['Udieresismacron'] = 0x01D5;
+        t['Udieresissmall'] = 0xF7FC;
+        t['Udotbelow'] = 0x1EE4;
+        t['Ugrave'] = 0x00D9;
+        t['Ugravesmall'] = 0xF7F9;
+        t['Uhookabove'] = 0x1EE6;
+        t['Uhorn'] = 0x01AF;
+        t['Uhornacute'] = 0x1EE8;
+        t['Uhorndotbelow'] = 0x1EF0;
+        t['Uhorngrave'] = 0x1EEA;
+        t['Uhornhookabove'] = 0x1EEC;
+        t['Uhorntilde'] = 0x1EEE;
+        t['Uhungarumlaut'] = 0x0170;
+        t['Uhungarumlautcyrillic'] = 0x04F2;
+        t['Uinvertedbreve'] = 0x0216;
+        t['Ukcyrillic'] = 0x0478;
+        t['Umacron'] = 0x016A;
+        t['Umacroncyrillic'] = 0x04EE;
+        t['Umacrondieresis'] = 0x1E7A;
+        t['Umonospace'] = 0xFF35;
+        t['Uogonek'] = 0x0172;
+        t['Upsilon'] = 0x03A5;
+        t['Upsilon1'] = 0x03D2;
+        t['Upsilonacutehooksymbolgreek'] = 0x03D3;
+        t['Upsilonafrican'] = 0x01B1;
+        t['Upsilondieresis'] = 0x03AB;
+        t['Upsilondieresishooksymbolgreek'] = 0x03D4;
+        t['Upsilonhooksymbol'] = 0x03D2;
+        t['Upsilontonos'] = 0x038E;
+        t['Uring'] = 0x016E;
+        t['Ushortcyrillic'] = 0x040E;
+        t['Usmall'] = 0xF775;
+        t['Ustraightcyrillic'] = 0x04AE;
+        t['Ustraightstrokecyrillic'] = 0x04B0;
+        t['Utilde'] = 0x0168;
+        t['Utildeacute'] = 0x1E78;
+        t['Utildebelow'] = 0x1E74;
+        t['V'] = 0x0056;
+        t['Vcircle'] = 0x24CB;
+        t['Vdotbelow'] = 0x1E7E;
+        t['Vecyrillic'] = 0x0412;
+        t['Vewarmenian'] = 0x054E;
+        t['Vhook'] = 0x01B2;
+        t['Vmonospace'] = 0xFF36;
+        t['Voarmenian'] = 0x0548;
+        t['Vsmall'] = 0xF776;
+        t['Vtilde'] = 0x1E7C;
+        t['W'] = 0x0057;
+        t['Wacute'] = 0x1E82;
+        t['Wcircle'] = 0x24CC;
+        t['Wcircumflex'] = 0x0174;
+        t['Wdieresis'] = 0x1E84;
+        t['Wdotaccent'] = 0x1E86;
+        t['Wdotbelow'] = 0x1E88;
+        t['Wgrave'] = 0x1E80;
+        t['Wmonospace'] = 0xFF37;
+        t['Wsmall'] = 0xF777;
+        t['X'] = 0x0058;
+        t['Xcircle'] = 0x24CD;
+        t['Xdieresis'] = 0x1E8C;
+        t['Xdotaccent'] = 0x1E8A;
+        t['Xeharmenian'] = 0x053D;
+        t['Xi'] = 0x039E;
+        t['Xmonospace'] = 0xFF38;
+        t['Xsmall'] = 0xF778;
+        t['Y'] = 0x0059;
+        t['Yacute'] = 0x00DD;
+        t['Yacutesmall'] = 0xF7FD;
+        t['Yatcyrillic'] = 0x0462;
+        t['Ycircle'] = 0x24CE;
+        t['Ycircumflex'] = 0x0176;
+        t['Ydieresis'] = 0x0178;
+        t['Ydieresissmall'] = 0xF7FF;
+        t['Ydotaccent'] = 0x1E8E;
+        t['Ydotbelow'] = 0x1EF4;
+        t['Yericyrillic'] = 0x042B;
+        t['Yerudieresiscyrillic'] = 0x04F8;
+        t['Ygrave'] = 0x1EF2;
+        t['Yhook'] = 0x01B3;
+        t['Yhookabove'] = 0x1EF6;
+        t['Yiarmenian'] = 0x0545;
+        t['Yicyrillic'] = 0x0407;
+        t['Yiwnarmenian'] = 0x0552;
+        t['Ymonospace'] = 0xFF39;
+        t['Ysmall'] = 0xF779;
+        t['Ytilde'] = 0x1EF8;
+        t['Yusbigcyrillic'] = 0x046A;
+        t['Yusbigiotifiedcyrillic'] = 0x046C;
+        t['Yuslittlecyrillic'] = 0x0466;
+        t['Yuslittleiotifiedcyrillic'] = 0x0468;
+        t['Z'] = 0x005A;
+        t['Zaarmenian'] = 0x0536;
+        t['Zacute'] = 0x0179;
+        t['Zcaron'] = 0x017D;
+        t['Zcaronsmall'] = 0xF6FF;
+        t['Zcircle'] = 0x24CF;
+        t['Zcircumflex'] = 0x1E90;
+        t['Zdot'] = 0x017B;
+        t['Zdotaccent'] = 0x017B;
+        t['Zdotbelow'] = 0x1E92;
+        t['Zecyrillic'] = 0x0417;
+        t['Zedescendercyrillic'] = 0x0498;
+        t['Zedieresiscyrillic'] = 0x04DE;
+        t['Zeta'] = 0x0396;
+        t['Zhearmenian'] = 0x053A;
+        t['Zhebrevecyrillic'] = 0x04C1;
+        t['Zhecyrillic'] = 0x0416;
+        t['Zhedescendercyrillic'] = 0x0496;
+        t['Zhedieresiscyrillic'] = 0x04DC;
+        t['Zlinebelow'] = 0x1E94;
+        t['Zmonospace'] = 0xFF3A;
+        t['Zsmall'] = 0xF77A;
+        t['Zstroke'] = 0x01B5;
+        t['a'] = 0x0061;
+        t['aabengali'] = 0x0986;
+        t['aacute'] = 0x00E1;
+        t['aadeva'] = 0x0906;
+        t['aagujarati'] = 0x0A86;
+        t['aagurmukhi'] = 0x0A06;
+        t['aamatragurmukhi'] = 0x0A3E;
+        t['aarusquare'] = 0x3303;
+        t['aavowelsignbengali'] = 0x09BE;
+        t['aavowelsigndeva'] = 0x093E;
+        t['aavowelsigngujarati'] = 0x0ABE;
+        t['abbreviationmarkarmenian'] = 0x055F;
+        t['abbreviationsigndeva'] = 0x0970;
+        t['abengali'] = 0x0985;
+        t['abopomofo'] = 0x311A;
+        t['abreve'] = 0x0103;
+        t['abreveacute'] = 0x1EAF;
+        t['abrevecyrillic'] = 0x04D1;
+        t['abrevedotbelow'] = 0x1EB7;
+        t['abrevegrave'] = 0x1EB1;
+        t['abrevehookabove'] = 0x1EB3;
+        t['abrevetilde'] = 0x1EB5;
+        t['acaron'] = 0x01CE;
+        t['acircle'] = 0x24D0;
+        t['acircumflex'] = 0x00E2;
+        t['acircumflexacute'] = 0x1EA5;
+        t['acircumflexdotbelow'] = 0x1EAD;
+        t['acircumflexgrave'] = 0x1EA7;
+        t['acircumflexhookabove'] = 0x1EA9;
+        t['acircumflextilde'] = 0x1EAB;
+        t['acute'] = 0x00B4;
+        t['acutebelowcmb'] = 0x0317;
+        t['acutecmb'] = 0x0301;
+        t['acutecomb'] = 0x0301;
+        t['acutedeva'] = 0x0954;
+        t['acutelowmod'] = 0x02CF;
+        t['acutetonecmb'] = 0x0341;
+        t['acyrillic'] = 0x0430;
+        t['adblgrave'] = 0x0201;
+        t['addakgurmukhi'] = 0x0A71;
+        t['adeva'] = 0x0905;
+        t['adieresis'] = 0x00E4;
+        t['adieresiscyrillic'] = 0x04D3;
+        t['adieresismacron'] = 0x01DF;
+        t['adotbelow'] = 0x1EA1;
+        t['adotmacron'] = 0x01E1;
+        t['ae'] = 0x00E6;
+        t['aeacute'] = 0x01FD;
+        t['aekorean'] = 0x3150;
+        t['aemacron'] = 0x01E3;
+        t['afii00208'] = 0x2015;
+        t['afii08941'] = 0x20A4;
+        t['afii10017'] = 0x0410;
+        t['afii10018'] = 0x0411;
+        t['afii10019'] = 0x0412;
+        t['afii10020'] = 0x0413;
+        t['afii10021'] = 0x0414;
+        t['afii10022'] = 0x0415;
+        t['afii10023'] = 0x0401;
+        t['afii10024'] = 0x0416;
+        t['afii10025'] = 0x0417;
+        t['afii10026'] = 0x0418;
+        t['afii10027'] = 0x0419;
+        t['afii10028'] = 0x041A;
+        t['afii10029'] = 0x041B;
+        t['afii10030'] = 0x041C;
+        t['afii10031'] = 0x041D;
+        t['afii10032'] = 0x041E;
+        t['afii10033'] = 0x041F;
+        t['afii10034'] = 0x0420;
+        t['afii10035'] = 0x0421;
+        t['afii10036'] = 0x0422;
+        t['afii10037'] = 0x0423;
+        t['afii10038'] = 0x0424;
+        t['afii10039'] = 0x0425;
+        t['afii10040'] = 0x0426;
+        t['afii10041'] = 0x0427;
+        t['afii10042'] = 0x0428;
+        t['afii10043'] = 0x0429;
+        t['afii10044'] = 0x042A;
+        t['afii10045'] = 0x042B;
+        t['afii10046'] = 0x042C;
+        t['afii10047'] = 0x042D;
+        t['afii10048'] = 0x042E;
+        t['afii10049'] = 0x042F;
+        t['afii10050'] = 0x0490;
+        t['afii10051'] = 0x0402;
+        t['afii10052'] = 0x0403;
+        t['afii10053'] = 0x0404;
+        t['afii10054'] = 0x0405;
+        t['afii10055'] = 0x0406;
+        t['afii10056'] = 0x0407;
+        t['afii10057'] = 0x0408;
+        t['afii10058'] = 0x0409;
+        t['afii10059'] = 0x040A;
+        t['afii10060'] = 0x040B;
+        t['afii10061'] = 0x040C;
+        t['afii10062'] = 0x040E;
+        t['afii10063'] = 0xF6C4;
+        t['afii10064'] = 0xF6C5;
+        t['afii10065'] = 0x0430;
+        t['afii10066'] = 0x0431;
+        t['afii10067'] = 0x0432;
+        t['afii10068'] = 0x0433;
+        t['afii10069'] = 0x0434;
+        t['afii10070'] = 0x0435;
+        t['afii10071'] = 0x0451;
+        t['afii10072'] = 0x0436;
+        t['afii10073'] = 0x0437;
+        t['afii10074'] = 0x0438;
+        t['afii10075'] = 0x0439;
+        t['afii10076'] = 0x043A;
+        t['afii10077'] = 0x043B;
+        t['afii10078'] = 0x043C;
+        t['afii10079'] = 0x043D;
+        t['afii10080'] = 0x043E;
+        t['afii10081'] = 0x043F;
+        t['afii10082'] = 0x0440;
+        t['afii10083'] = 0x0441;
+        t['afii10084'] = 0x0442;
+        t['afii10085'] = 0x0443;
+        t['afii10086'] = 0x0444;
+        t['afii10087'] = 0x0445;
+        t['afii10088'] = 0x0446;
+        t['afii10089'] = 0x0447;
+        t['afii10090'] = 0x0448;
+        t['afii10091'] = 0x0449;
+        t['afii10092'] = 0x044A;
+        t['afii10093'] = 0x044B;
+        t['afii10094'] = 0x044C;
+        t['afii10095'] = 0x044D;
+        t['afii10096'] = 0x044E;
+        t['afii10097'] = 0x044F;
+        t['afii10098'] = 0x0491;
+        t['afii10099'] = 0x0452;
+        t['afii10100'] = 0x0453;
+        t['afii10101'] = 0x0454;
+        t['afii10102'] = 0x0455;
+        t['afii10103'] = 0x0456;
+        t['afii10104'] = 0x0457;
+        t['afii10105'] = 0x0458;
+        t['afii10106'] = 0x0459;
+        t['afii10107'] = 0x045A;
+        t['afii10108'] = 0x045B;
+        t['afii10109'] = 0x045C;
+        t['afii10110'] = 0x045E;
+        t['afii10145'] = 0x040F;
+        t['afii10146'] = 0x0462;
+        t['afii10147'] = 0x0472;
+        t['afii10148'] = 0x0474;
+        t['afii10192'] = 0xF6C6;
+        t['afii10193'] = 0x045F;
+        t['afii10194'] = 0x0463;
+        t['afii10195'] = 0x0473;
+        t['afii10196'] = 0x0475;
+        t['afii10831'] = 0xF6C7;
+        t['afii10832'] = 0xF6C8;
+        t['afii10846'] = 0x04D9;
+        t['afii299'] = 0x200E;
+        t['afii300'] = 0x200F;
+        t['afii301'] = 0x200D;
+        t['afii57381'] = 0x066A;
+        t['afii57388'] = 0x060C;
+        t['afii57392'] = 0x0660;
+        t['afii57393'] = 0x0661;
+        t['afii57394'] = 0x0662;
+        t['afii57395'] = 0x0663;
+        t['afii57396'] = 0x0664;
+        t['afii57397'] = 0x0665;
+        t['afii57398'] = 0x0666;
+        t['afii57399'] = 0x0667;
+        t['afii57400'] = 0x0668;
+        t['afii57401'] = 0x0669;
+        t['afii57403'] = 0x061B;
+        t['afii57407'] = 0x061F;
+        t['afii57409'] = 0x0621;
+        t['afii57410'] = 0x0622;
+        t['afii57411'] = 0x0623;
+        t['afii57412'] = 0x0624;
+        t['afii57413'] = 0x0625;
+        t['afii57414'] = 0x0626;
+        t['afii57415'] = 0x0627;
+        t['afii57416'] = 0x0628;
+        t['afii57417'] = 0x0629;
+        t['afii57418'] = 0x062A;
+        t['afii57419'] = 0x062B;
+        t['afii57420'] = 0x062C;
+        t['afii57421'] = 0x062D;
+        t['afii57422'] = 0x062E;
+        t['afii57423'] = 0x062F;
+        t['afii57424'] = 0x0630;
+        t['afii57425'] = 0x0631;
+        t['afii57426'] = 0x0632;
+        t['afii57427'] = 0x0633;
+        t['afii57428'] = 0x0634;
+        t['afii57429'] = 0x0635;
+        t['afii57430'] = 0x0636;
+        t['afii57431'] = 0x0637;
+        t['afii57432'] = 0x0638;
+        t['afii57433'] = 0x0639;
+        t['afii57434'] = 0x063A;
+        t['afii57440'] = 0x0640;
+        t['afii57441'] = 0x0641;
+        t['afii57442'] = 0x0642;
+        t['afii57443'] = 0x0643;
+        t['afii57444'] = 0x0644;
+        t['afii57445'] = 0x0645;
+        t['afii57446'] = 0x0646;
+        t['afii57448'] = 0x0648;
+        t['afii57449'] = 0x0649;
+        t['afii57450'] = 0x064A;
+        t['afii57451'] = 0x064B;
+        t['afii57452'] = 0x064C;
+        t['afii57453'] = 0x064D;
+        t['afii57454'] = 0x064E;
+        t['afii57455'] = 0x064F;
+        t['afii57456'] = 0x0650;
+        t['afii57457'] = 0x0651;
+        t['afii57458'] = 0x0652;
+        t['afii57470'] = 0x0647;
+        t['afii57505'] = 0x06A4;
+        t['afii57506'] = 0x067E;
+        t['afii57507'] = 0x0686;
+        t['afii57508'] = 0x0698;
+        t['afii57509'] = 0x06AF;
+        t['afii57511'] = 0x0679;
+        t['afii57512'] = 0x0688;
+        t['afii57513'] = 0x0691;
+        t['afii57514'] = 0x06BA;
+        t['afii57519'] = 0x06D2;
+        t['afii57534'] = 0x06D5;
+        t['afii57636'] = 0x20AA;
+        t['afii57645'] = 0x05BE;
+        t['afii57658'] = 0x05C3;
+        t['afii57664'] = 0x05D0;
+        t['afii57665'] = 0x05D1;
+        t['afii57666'] = 0x05D2;
+        t['afii57667'] = 0x05D3;
+        t['afii57668'] = 0x05D4;
+        t['afii57669'] = 0x05D5;
+        t['afii57670'] = 0x05D6;
+        t['afii57671'] = 0x05D7;
+        t['afii57672'] = 0x05D8;
+        t['afii57673'] = 0x05D9;
+        t['afii57674'] = 0x05DA;
+        t['afii57675'] = 0x05DB;
+        t['afii57676'] = 0x05DC;
+        t['afii57677'] = 0x05DD;
+        t['afii57678'] = 0x05DE;
+        t['afii57679'] = 0x05DF;
+        t['afii57680'] = 0x05E0;
+        t['afii57681'] = 0x05E1;
+        t['afii57682'] = 0x05E2;
+        t['afii57683'] = 0x05E3;
+        t['afii57684'] = 0x05E4;
+        t['afii57685'] = 0x05E5;
+        t['afii57686'] = 0x05E6;
+        t['afii57687'] = 0x05E7;
+        t['afii57688'] = 0x05E8;
+        t['afii57689'] = 0x05E9;
+        t['afii57690'] = 0x05EA;
+        t['afii57694'] = 0xFB2A;
+        t['afii57695'] = 0xFB2B;
+        t['afii57700'] = 0xFB4B;
+        t['afii57705'] = 0xFB1F;
+        t['afii57716'] = 0x05F0;
+        t['afii57717'] = 0x05F1;
+        t['afii57718'] = 0x05F2;
+        t['afii57723'] = 0xFB35;
+        t['afii57793'] = 0x05B4;
+        t['afii57794'] = 0x05B5;
+        t['afii57795'] = 0x05B6;
+        t['afii57796'] = 0x05BB;
+        t['afii57797'] = 0x05B8;
+        t['afii57798'] = 0x05B7;
+        t['afii57799'] = 0x05B0;
+        t['afii57800'] = 0x05B2;
+        t['afii57801'] = 0x05B1;
+        t['afii57802'] = 0x05B3;
+        t['afii57803'] = 0x05C2;
+        t['afii57804'] = 0x05C1;
+        t['afii57806'] = 0x05B9;
+        t['afii57807'] = 0x05BC;
+        t['afii57839'] = 0x05BD;
+        t['afii57841'] = 0x05BF;
+        t['afii57842'] = 0x05C0;
+        t['afii57929'] = 0x02BC;
+        t['afii61248'] = 0x2105;
+        t['afii61289'] = 0x2113;
+        t['afii61352'] = 0x2116;
+        t['afii61573'] = 0x202C;
+        t['afii61574'] = 0x202D;
+        t['afii61575'] = 0x202E;
+        t['afii61664'] = 0x200C;
+        t['afii63167'] = 0x066D;
+        t['afii64937'] = 0x02BD;
+        t['agrave'] = 0x00E0;
+        t['agujarati'] = 0x0A85;
+        t['agurmukhi'] = 0x0A05;
+        t['ahiragana'] = 0x3042;
+        t['ahookabove'] = 0x1EA3;
+        t['aibengali'] = 0x0990;
+        t['aibopomofo'] = 0x311E;
+        t['aideva'] = 0x0910;
+        t['aiecyrillic'] = 0x04D5;
+        t['aigujarati'] = 0x0A90;
+        t['aigurmukhi'] = 0x0A10;
+        t['aimatragurmukhi'] = 0x0A48;
+        t['ainarabic'] = 0x0639;
+        t['ainfinalarabic'] = 0xFECA;
+        t['aininitialarabic'] = 0xFECB;
+        t['ainmedialarabic'] = 0xFECC;
+        t['ainvertedbreve'] = 0x0203;
+        t['aivowelsignbengali'] = 0x09C8;
+        t['aivowelsigndeva'] = 0x0948;
+        t['aivowelsigngujarati'] = 0x0AC8;
+        t['akatakana'] = 0x30A2;
+        t['akatakanahalfwidth'] = 0xFF71;
+        t['akorean'] = 0x314F;
+        t['alef'] = 0x05D0;
+        t['alefarabic'] = 0x0627;
+        t['alefdageshhebrew'] = 0xFB30;
+        t['aleffinalarabic'] = 0xFE8E;
+        t['alefhamzaabovearabic'] = 0x0623;
+        t['alefhamzaabovefinalarabic'] = 0xFE84;
+        t['alefhamzabelowarabic'] = 0x0625;
+        t['alefhamzabelowfinalarabic'] = 0xFE88;
+        t['alefhebrew'] = 0x05D0;
+        t['aleflamedhebrew'] = 0xFB4F;
+        t['alefmaddaabovearabic'] = 0x0622;
+        t['alefmaddaabovefinalarabic'] = 0xFE82;
+        t['alefmaksuraarabic'] = 0x0649;
+        t['alefmaksurafinalarabic'] = 0xFEF0;
+        t['alefmaksurainitialarabic'] = 0xFEF3;
+        t['alefmaksuramedialarabic'] = 0xFEF4;
+        t['alefpatahhebrew'] = 0xFB2E;
+        t['alefqamatshebrew'] = 0xFB2F;
+        t['aleph'] = 0x2135;
+        t['allequal'] = 0x224C;
+        t['alpha'] = 0x03B1;
+        t['alphatonos'] = 0x03AC;
+        t['amacron'] = 0x0101;
+        t['amonospace'] = 0xFF41;
+        t['ampersand'] = 0x0026;
+        t['ampersandmonospace'] = 0xFF06;
+        t['ampersandsmall'] = 0xF726;
+        t['amsquare'] = 0x33C2;
+        t['anbopomofo'] = 0x3122;
+        t['angbopomofo'] = 0x3124;
+        t['angbracketleft'] = 0x3008;
+        // Glyph is missing from Adobe's original list.
+        t['angbracketright'] = 0x3009;
+        // Glyph is missing from Adobe's original list.
+        t['angkhankhuthai'] = 0x0E5A;
+        t['angle'] = 0x2220;
+        t['anglebracketleft'] = 0x3008;
+        t['anglebracketleftvertical'] = 0xFE3F;
+        t['anglebracketright'] = 0x3009;
+        t['anglebracketrightvertical'] = 0xFE40;
+        t['angleleft'] = 0x2329;
+        t['angleright'] = 0x232A;
+        t['angstrom'] = 0x212B;
+        t['anoteleia'] = 0x0387;
+        t['anudattadeva'] = 0x0952;
+        t['anusvarabengali'] = 0x0982;
+        t['anusvaradeva'] = 0x0902;
+        t['anusvaragujarati'] = 0x0A82;
+        t['aogonek'] = 0x0105;
+        t['apaatosquare'] = 0x3300;
+        t['aparen'] = 0x249C;
+        t['apostrophearmenian'] = 0x055A;
+        t['apostrophemod'] = 0x02BC;
+        t['apple'] = 0xF8FF;
+        t['approaches'] = 0x2250;
+        t['approxequal'] = 0x2248;
+        t['approxequalorimage'] = 0x2252;
+        t['approximatelyequal'] = 0x2245;
+        t['araeaekorean'] = 0x318E;
+        t['araeakorean'] = 0x318D;
+        t['arc'] = 0x2312;
+        t['arighthalfring'] = 0x1E9A;
+        t['aring'] = 0x00E5;
+        t['aringacute'] = 0x01FB;
+        t['aringbelow'] = 0x1E01;
+        t['arrowboth'] = 0x2194;
+        t['arrowdashdown'] = 0x21E3;
+        t['arrowdashleft'] = 0x21E0;
+        t['arrowdashright'] = 0x21E2;
+        t['arrowdashup'] = 0x21E1;
+        t['arrowdblboth'] = 0x21D4;
+        t['arrowdbldown'] = 0x21D3;
+        t['arrowdblleft'] = 0x21D0;
+        t['arrowdblright'] = 0x21D2;
+        t['arrowdblup'] = 0x21D1;
+        t['arrowdown'] = 0x2193;
+        t['arrowdownleft'] = 0x2199;
+        t['arrowdownright'] = 0x2198;
+        t['arrowdownwhite'] = 0x21E9;
+        t['arrowheaddownmod'] = 0x02C5;
+        t['arrowheadleftmod'] = 0x02C2;
+        t['arrowheadrightmod'] = 0x02C3;
+        t['arrowheadupmod'] = 0x02C4;
+        t['arrowhorizex'] = 0xF8E7;
+        t['arrowleft'] = 0x2190;
+        t['arrowleftdbl'] = 0x21D0;
+        t['arrowleftdblstroke'] = 0x21CD;
+        t['arrowleftoverright'] = 0x21C6;
+        t['arrowleftwhite'] = 0x21E6;
+        t['arrowright'] = 0x2192;
+        t['arrowrightdblstroke'] = 0x21CF;
+        t['arrowrightheavy'] = 0x279E;
+        t['arrowrightoverleft'] = 0x21C4;
+        t['arrowrightwhite'] = 0x21E8;
+        t['arrowtableft'] = 0x21E4;
+        t['arrowtabright'] = 0x21E5;
+        t['arrowup'] = 0x2191;
+        t['arrowupdn'] = 0x2195;
+        t['arrowupdnbse'] = 0x21A8;
+        t['arrowupdownbase'] = 0x21A8;
+        t['arrowupleft'] = 0x2196;
+        t['arrowupleftofdown'] = 0x21C5;
+        t['arrowupright'] = 0x2197;
+        t['arrowupwhite'] = 0x21E7;
+        t['arrowvertex'] = 0xF8E6;
+        t['asciicircum'] = 0x005E;
+        t['asciicircummonospace'] = 0xFF3E;
+        t['asciitilde'] = 0x007E;
+        t['asciitildemonospace'] = 0xFF5E;
+        t['ascript'] = 0x0251;
+        t['ascriptturned'] = 0x0252;
+        t['asmallhiragana'] = 0x3041;
+        t['asmallkatakana'] = 0x30A1;
+        t['asmallkatakanahalfwidth'] = 0xFF67;
+        t['asterisk'] = 0x002A;
+        t['asteriskaltonearabic'] = 0x066D;
+        t['asteriskarabic'] = 0x066D;
+        t['asteriskmath'] = 0x2217;
+        t['asteriskmonospace'] = 0xFF0A;
+        t['asterisksmall'] = 0xFE61;
+        t['asterism'] = 0x2042;
+        t['asuperior'] = 0xF6E9;
+        t['asymptoticallyequal'] = 0x2243;
+        t['at'] = 0x0040;
+        t['atilde'] = 0x00E3;
+        t['atmonospace'] = 0xFF20;
+        t['atsmall'] = 0xFE6B;
+        t['aturned'] = 0x0250;
+        t['aubengali'] = 0x0994;
+        t['aubopomofo'] = 0x3120;
+        t['audeva'] = 0x0914;
+        t['augujarati'] = 0x0A94;
+        t['augurmukhi'] = 0x0A14;
+        t['aulengthmarkbengali'] = 0x09D7;
+        t['aumatragurmukhi'] = 0x0A4C;
+        t['auvowelsignbengali'] = 0x09CC;
+        t['auvowelsigndeva'] = 0x094C;
+        t['auvowelsigngujarati'] = 0x0ACC;
+        t['avagrahadeva'] = 0x093D;
+        t['aybarmenian'] = 0x0561;
+        t['ayin'] = 0x05E2;
+        t['ayinaltonehebrew'] = 0xFB20;
+        t['ayinhebrew'] = 0x05E2;
+        t['b'] = 0x0062;
+        t['babengali'] = 0x09AC;
+        t['backslash'] = 0x005C;
+        t['backslashmonospace'] = 0xFF3C;
+        t['badeva'] = 0x092C;
+        t['bagujarati'] = 0x0AAC;
+        t['bagurmukhi'] = 0x0A2C;
+        t['bahiragana'] = 0x3070;
+        t['bahtthai'] = 0x0E3F;
+        t['bakatakana'] = 0x30D0;
+        t['bar'] = 0x007C;
+        t['barmonospace'] = 0xFF5C;
+        t['bbopomofo'] = 0x3105;
+        t['bcircle'] = 0x24D1;
+        t['bdotaccent'] = 0x1E03;
+        t['bdotbelow'] = 0x1E05;
+        t['beamedsixteenthnotes'] = 0x266C;
+        t['because'] = 0x2235;
+        t['becyrillic'] = 0x0431;
+        t['beharabic'] = 0x0628;
+        t['behfinalarabic'] = 0xFE90;
+        t['behinitialarabic'] = 0xFE91;
+        t['behiragana'] = 0x3079;
+        t['behmedialarabic'] = 0xFE92;
+        t['behmeeminitialarabic'] = 0xFC9F;
+        t['behmeemisolatedarabic'] = 0xFC08;
+        t['behnoonfinalarabic'] = 0xFC6D;
+        t['bekatakana'] = 0x30D9;
+        t['benarmenian'] = 0x0562;
+        t['bet'] = 0x05D1;
+        t['beta'] = 0x03B2;
+        t['betasymbolgreek'] = 0x03D0;
+        t['betdagesh'] = 0xFB31;
+        t['betdageshhebrew'] = 0xFB31;
+        t['bethebrew'] = 0x05D1;
+        t['betrafehebrew'] = 0xFB4C;
+        t['bhabengali'] = 0x09AD;
+        t['bhadeva'] = 0x092D;
+        t['bhagujarati'] = 0x0AAD;
+        t['bhagurmukhi'] = 0x0A2D;
+        t['bhook'] = 0x0253;
+        t['bihiragana'] = 0x3073;
+        t['bikatakana'] = 0x30D3;
+        t['bilabialclick'] = 0x0298;
+        t['bindigurmukhi'] = 0x0A02;
+        t['birusquare'] = 0x3331;
+        t['blackcircle'] = 0x25CF;
+        t['blackdiamond'] = 0x25C6;
+        t['blackdownpointingtriangle'] = 0x25BC;
+        t['blackleftpointingpointer'] = 0x25C4;
+        t['blackleftpointingtriangle'] = 0x25C0;
+        t['blacklenticularbracketleft'] = 0x3010;
+        t['blacklenticularbracketleftvertical'] = 0xFE3B;
+        t['blacklenticularbracketright'] = 0x3011;
+        t['blacklenticularbracketrightvertical'] = 0xFE3C;
+        t['blacklowerlefttriangle'] = 0x25E3;
+        t['blacklowerrighttriangle'] = 0x25E2;
+        t['blackrectangle'] = 0x25AC;
+        t['blackrightpointingpointer'] = 0x25BA;
+        t['blackrightpointingtriangle'] = 0x25B6;
+        t['blacksmallsquare'] = 0x25AA;
+        t['blacksmilingface'] = 0x263B;
+        t['blacksquare'] = 0x25A0;
+        t['blackstar'] = 0x2605;
+        t['blackupperlefttriangle'] = 0x25E4;
+        t['blackupperrighttriangle'] = 0x25E5;
+        t['blackuppointingsmalltriangle'] = 0x25B4;
+        t['blackuppointingtriangle'] = 0x25B2;
+        t['blank'] = 0x2423;
+        t['blinebelow'] = 0x1E07;
+        t['block'] = 0x2588;
+        t['bmonospace'] = 0xFF42;
+        t['bobaimaithai'] = 0x0E1A;
+        t['bohiragana'] = 0x307C;
+        t['bokatakana'] = 0x30DC;
+        t['bparen'] = 0x249D;
+        t['bqsquare'] = 0x33C3;
+        t['braceex'] = 0xF8F4;
+        t['braceleft'] = 0x007B;
+        t['braceleftbt'] = 0xF8F3;
+        t['braceleftmid'] = 0xF8F2;
+        t['braceleftmonospace'] = 0xFF5B;
+        t['braceleftsmall'] = 0xFE5B;
+        t['bracelefttp'] = 0xF8F1;
+        t['braceleftvertical'] = 0xFE37;
+        t['braceright'] = 0x007D;
+        t['bracerightbt'] = 0xF8FE;
+        t['bracerightmid'] = 0xF8FD;
+        t['bracerightmonospace'] = 0xFF5D;
+        t['bracerightsmall'] = 0xFE5C;
+        t['bracerighttp'] = 0xF8FC;
+        t['bracerightvertical'] = 0xFE38;
+        t['bracketleft'] = 0x005B;
+        t['bracketleftbt'] = 0xF8F0;
+        t['bracketleftex'] = 0xF8EF;
+        t['bracketleftmonospace'] = 0xFF3B;
+        t['bracketlefttp'] = 0xF8EE;
+        t['bracketright'] = 0x005D;
+        t['bracketrightbt'] = 0xF8FB;
+        t['bracketrightex'] = 0xF8FA;
+        t['bracketrightmonospace'] = 0xFF3D;
+        t['bracketrighttp'] = 0xF8F9;
+        t['breve'] = 0x02D8;
+        t['brevebelowcmb'] = 0x032E;
+        t['brevecmb'] = 0x0306;
+        t['breveinvertedbelowcmb'] = 0x032F;
+        t['breveinvertedcmb'] = 0x0311;
+        t['breveinverteddoublecmb'] = 0x0361;
+        t['bridgebelowcmb'] = 0x032A;
+        t['bridgeinvertedbelowcmb'] = 0x033A;
+        t['brokenbar'] = 0x00A6;
+        t['bstroke'] = 0x0180;
+        t['bsuperior'] = 0xF6EA;
+        t['btopbar'] = 0x0183;
+        t['buhiragana'] = 0x3076;
+        t['bukatakana'] = 0x30D6;
+        t['bullet'] = 0x2022;
+        t['bulletinverse'] = 0x25D8;
+        t['bulletoperator'] = 0x2219;
+        t['bullseye'] = 0x25CE;
+        t['c'] = 0x0063;
+        t['caarmenian'] = 0x056E;
+        t['cabengali'] = 0x099A;
+        t['cacute'] = 0x0107;
+        t['cadeva'] = 0x091A;
+        t['cagujarati'] = 0x0A9A;
+        t['cagurmukhi'] = 0x0A1A;
+        t['calsquare'] = 0x3388;
+        t['candrabindubengali'] = 0x0981;
+        t['candrabinducmb'] = 0x0310;
+        t['candrabindudeva'] = 0x0901;
+        t['candrabindugujarati'] = 0x0A81;
+        t['capslock'] = 0x21EA;
+        t['careof'] = 0x2105;
+        t['caron'] = 0x02C7;
+        t['caronbelowcmb'] = 0x032C;
+        t['caroncmb'] = 0x030C;
+        t['carriagereturn'] = 0x21B5;
+        t['cbopomofo'] = 0x3118;
+        t['ccaron'] = 0x010D;
+        t['ccedilla'] = 0x00E7;
+        t['ccedillaacute'] = 0x1E09;
+        t['ccircle'] = 0x24D2;
+        t['ccircumflex'] = 0x0109;
+        t['ccurl'] = 0x0255;
+        t['cdot'] = 0x010B;
+        t['cdotaccent'] = 0x010B;
+        t['cdsquare'] = 0x33C5;
+        t['cedilla'] = 0x00B8;
+        t['cedillacmb'] = 0x0327;
+        t['cent'] = 0x00A2;
+        t['centigrade'] = 0x2103;
+        t['centinferior'] = 0xF6DF;
+        t['centmonospace'] = 0xFFE0;
+        t['centoldstyle'] = 0xF7A2;
+        t['centsuperior'] = 0xF6E0;
+        t['chaarmenian'] = 0x0579;
+        t['chabengali'] = 0x099B;
+        t['chadeva'] = 0x091B;
+        t['chagujarati'] = 0x0A9B;
+        t['chagurmukhi'] = 0x0A1B;
+        t['chbopomofo'] = 0x3114;
+        t['cheabkhasiancyrillic'] = 0x04BD;
+        t['checkmark'] = 0x2713;
+        t['checyrillic'] = 0x0447;
+        t['chedescenderabkhasiancyrillic'] = 0x04BF;
+        t['chedescendercyrillic'] = 0x04B7;
+        t['chedieresiscyrillic'] = 0x04F5;
+        t['cheharmenian'] = 0x0573;
+        t['chekhakassiancyrillic'] = 0x04CC;
+        t['cheverticalstrokecyrillic'] = 0x04B9;
+        t['chi'] = 0x03C7;
+        t['chieuchacirclekorean'] = 0x3277;
+        t['chieuchaparenkorean'] = 0x3217;
+        t['chieuchcirclekorean'] = 0x3269;
+        t['chieuchkorean'] = 0x314A;
+        t['chieuchparenkorean'] = 0x3209;
+        t['chochangthai'] = 0x0E0A;
+        t['chochanthai'] = 0x0E08;
+        t['chochingthai'] = 0x0E09;
+        t['chochoethai'] = 0x0E0C;
+        t['chook'] = 0x0188;
+        t['cieucacirclekorean'] = 0x3276;
+        t['cieucaparenkorean'] = 0x3216;
+        t['cieuccirclekorean'] = 0x3268;
+        t['cieuckorean'] = 0x3148;
+        t['cieucparenkorean'] = 0x3208;
+        t['cieucuparenkorean'] = 0x321C;
+        t['circle'] = 0x25CB;
+        t['circlecopyrt'] = 0x00A9;
+        // Glyph is missing from Adobe's original list.
+        t['circlemultiply'] = 0x2297;
+        t['circleot'] = 0x2299;
+        t['circleplus'] = 0x2295;
+        t['circlepostalmark'] = 0x3036;
+        t['circlewithlefthalfblack'] = 0x25D0;
+        t['circlewithrighthalfblack'] = 0x25D1;
+        t['circumflex'] = 0x02C6;
+        t['circumflexbelowcmb'] = 0x032D;
+        t['circumflexcmb'] = 0x0302;
+        t['clear'] = 0x2327;
+        t['clickalveolar'] = 0x01C2;
+        t['clickdental'] = 0x01C0;
+        t['clicklateral'] = 0x01C1;
+        t['clickretroflex'] = 0x01C3;
+        t['club'] = 0x2663;
+        t['clubsuitblack'] = 0x2663;
+        t['clubsuitwhite'] = 0x2667;
+        t['cmcubedsquare'] = 0x33A4;
+        t['cmonospace'] = 0xFF43;
+        t['cmsquaredsquare'] = 0x33A0;
+        t['coarmenian'] = 0x0581;
+        t['colon'] = 0x003A;
+        t['colonmonetary'] = 0x20A1;
+        t['colonmonospace'] = 0xFF1A;
+        t['colonsign'] = 0x20A1;
+        t['colonsmall'] = 0xFE55;
+        t['colontriangularhalfmod'] = 0x02D1;
+        t['colontriangularmod'] = 0x02D0;
+        t['comma'] = 0x002C;
+        t['commaabovecmb'] = 0x0313;
+        t['commaaboverightcmb'] = 0x0315;
+        t['commaaccent'] = 0xF6C3;
+        t['commaarabic'] = 0x060C;
+        t['commaarmenian'] = 0x055D;
+        t['commainferior'] = 0xF6E1;
+        t['commamonospace'] = 0xFF0C;
+        t['commareversedabovecmb'] = 0x0314;
+        t['commareversedmod'] = 0x02BD;
+        t['commasmall'] = 0xFE50;
+        t['commasuperior'] = 0xF6E2;
+        t['commaturnedabovecmb'] = 0x0312;
+        t['commaturnedmod'] = 0x02BB;
+        t['compass'] = 0x263C;
+        t['congruent'] = 0x2245;
+        t['contourintegral'] = 0x222E;
+        t['control'] = 0x2303;
+        t['controlACK'] = 0x0006;
+        t['controlBEL'] = 0x0007;
+        t['controlBS'] = 0x0008;
+        t['controlCAN'] = 0x0018;
+        t['controlCR'] = 0x000D;
+        t['controlDC1'] = 0x0011;
+        t['controlDC2'] = 0x0012;
+        t['controlDC3'] = 0x0013;
+        t['controlDC4'] = 0x0014;
+        t['controlDEL'] = 0x007F;
+        t['controlDLE'] = 0x0010;
+        t['controlEM'] = 0x0019;
+        t['controlENQ'] = 0x0005;
+        t['controlEOT'] = 0x0004;
+        t['controlESC'] = 0x001B;
+        t['controlETB'] = 0x0017;
+        t['controlETX'] = 0x0003;
+        t['controlFF'] = 0x000C;
+        t['controlFS'] = 0x001C;
+        t['controlGS'] = 0x001D;
+        t['controlHT'] = 0x0009;
+        t['controlLF'] = 0x000A;
+        t['controlNAK'] = 0x0015;
+        t['controlRS'] = 0x001E;
+        t['controlSI'] = 0x000F;
+        t['controlSO'] = 0x000E;
+        t['controlSOT'] = 0x0002;
+        t['controlSTX'] = 0x0001;
+        t['controlSUB'] = 0x001A;
+        t['controlSYN'] = 0x0016;
+        t['controlUS'] = 0x001F;
+        t['controlVT'] = 0x000B;
+        t['copyright'] = 0x00A9;
+        t['copyrightsans'] = 0xF8E9;
+        t['copyrightserif'] = 0xF6D9;
+        t['cornerbracketleft'] = 0x300C;
+        t['cornerbracketlefthalfwidth'] = 0xFF62;
+        t['cornerbracketleftvertical'] = 0xFE41;
+        t['cornerbracketright'] = 0x300D;
+        t['cornerbracketrighthalfwidth'] = 0xFF63;
+        t['cornerbracketrightvertical'] = 0xFE42;
+        t['corporationsquare'] = 0x337F;
+        t['cosquare'] = 0x33C7;
+        t['coverkgsquare'] = 0x33C6;
+        t['cparen'] = 0x249E;
+        t['cruzeiro'] = 0x20A2;
+        t['cstretched'] = 0x0297;
+        t['curlyand'] = 0x22CF;
+        t['curlyor'] = 0x22CE;
+        t['currency'] = 0x00A4;
+        t['cyrBreve'] = 0xF6D1;
+        t['cyrFlex'] = 0xF6D2;
+        t['cyrbreve'] = 0xF6D4;
+        t['cyrflex'] = 0xF6D5;
+        t['d'] = 0x0064;
+        t['daarmenian'] = 0x0564;
+        t['dabengali'] = 0x09A6;
+        t['dadarabic'] = 0x0636;
+        t['dadeva'] = 0x0926;
+        t['dadfinalarabic'] = 0xFEBE;
+        t['dadinitialarabic'] = 0xFEBF;
+        t['dadmedialarabic'] = 0xFEC0;
+        t['dagesh'] = 0x05BC;
+        t['dageshhebrew'] = 0x05BC;
+        t['dagger'] = 0x2020;
+        t['daggerdbl'] = 0x2021;
+        t['dagujarati'] = 0x0AA6;
+        t['dagurmukhi'] = 0x0A26;
+        t['dahiragana'] = 0x3060;
+        t['dakatakana'] = 0x30C0;
+        t['dalarabic'] = 0x062F;
+        t['dalet'] = 0x05D3;
+        t['daletdagesh'] = 0xFB33;
+        t['daletdageshhebrew'] = 0xFB33;
+        t['dalethebrew'] = 0x05D3;
+        t['dalfinalarabic'] = 0xFEAA;
+        t['dammaarabic'] = 0x064F;
+        t['dammalowarabic'] = 0x064F;
+        t['dammatanaltonearabic'] = 0x064C;
+        t['dammatanarabic'] = 0x064C;
+        t['danda'] = 0x0964;
+        t['dargahebrew'] = 0x05A7;
+        t['dargalefthebrew'] = 0x05A7;
+        t['dasiapneumatacyrilliccmb'] = 0x0485;
+        t['dblGrave'] = 0xF6D3;
+        t['dblanglebracketleft'] = 0x300A;
+        t['dblanglebracketleftvertical'] = 0xFE3D;
+        t['dblanglebracketright'] = 0x300B;
+        t['dblanglebracketrightvertical'] = 0xFE3E;
+        t['dblarchinvertedbelowcmb'] = 0x032B;
+        t['dblarrowleft'] = 0x21D4;
+        t['dblarrowright'] = 0x21D2;
+        t['dbldanda'] = 0x0965;
+        t['dblgrave'] = 0xF6D6;
+        t['dblgravecmb'] = 0x030F;
+        t['dblintegral'] = 0x222C;
+        t['dbllowline'] = 0x2017;
+        t['dbllowlinecmb'] = 0x0333;
+        t['dbloverlinecmb'] = 0x033F;
+        t['dblprimemod'] = 0x02BA;
+        t['dblverticalbar'] = 0x2016;
+        t['dblverticallineabovecmb'] = 0x030E;
+        t['dbopomofo'] = 0x3109;
+        t['dbsquare'] = 0x33C8;
+        t['dcaron'] = 0x010F;
+        t['dcedilla'] = 0x1E11;
+        t['dcircle'] = 0x24D3;
+        t['dcircumflexbelow'] = 0x1E13;
+        t['dcroat'] = 0x0111;
+        t['ddabengali'] = 0x09A1;
+        t['ddadeva'] = 0x0921;
+        t['ddagujarati'] = 0x0AA1;
+        t['ddagurmukhi'] = 0x0A21;
+        t['ddalarabic'] = 0x0688;
+        t['ddalfinalarabic'] = 0xFB89;
+        t['dddhadeva'] = 0x095C;
+        t['ddhabengali'] = 0x09A2;
+        t['ddhadeva'] = 0x0922;
+        t['ddhagujarati'] = 0x0AA2;
+        t['ddhagurmukhi'] = 0x0A22;
+        t['ddotaccent'] = 0x1E0B;
+        t['ddotbelow'] = 0x1E0D;
+        t['decimalseparatorarabic'] = 0x066B;
+        t['decimalseparatorpersian'] = 0x066B;
+        t['decyrillic'] = 0x0434;
+        t['degree'] = 0x00B0;
+        t['dehihebrew'] = 0x05AD;
+        t['dehiragana'] = 0x3067;
+        t['deicoptic'] = 0x03EF;
+        t['dekatakana'] = 0x30C7;
+        t['deleteleft'] = 0x232B;
+        t['deleteright'] = 0x2326;
+        t['delta'] = 0x03B4;
+        t['deltaturned'] = 0x018D;
+        t['denominatorminusonenumeratorbengali'] = 0x09F8;
+        t['dezh'] = 0x02A4;
+        t['dhabengali'] = 0x09A7;
+        t['dhadeva'] = 0x0927;
+        t['dhagujarati'] = 0x0AA7;
+        t['dhagurmukhi'] = 0x0A27;
+        t['dhook'] = 0x0257;
+        t['dialytikatonos'] = 0x0385;
+        t['dialytikatonoscmb'] = 0x0344;
+        t['diamond'] = 0x2666;
+        t['diamondsuitwhite'] = 0x2662;
+        t['dieresis'] = 0x00A8;
+        t['dieresisacute'] = 0xF6D7;
+        t['dieresisbelowcmb'] = 0x0324;
+        t['dieresiscmb'] = 0x0308;
+        t['dieresisgrave'] = 0xF6D8;
+        t['dieresistonos'] = 0x0385;
+        t['dihiragana'] = 0x3062;
+        t['dikatakana'] = 0x30C2;
+        t['dittomark'] = 0x3003;
+        t['divide'] = 0x00F7;
+        t['divides'] = 0x2223;
+        t['divisionslash'] = 0x2215;
+        t['djecyrillic'] = 0x0452;
+        t['dkshade'] = 0x2593;
+        t['dlinebelow'] = 0x1E0F;
+        t['dlsquare'] = 0x3397;
+        t['dmacron'] = 0x0111;
+        t['dmonospace'] = 0xFF44;
+        t['dnblock'] = 0x2584;
+        t['dochadathai'] = 0x0E0E;
+        t['dodekthai'] = 0x0E14;
+        t['dohiragana'] = 0x3069;
+        t['dokatakana'] = 0x30C9;
+        t['dollar'] = 0x0024;
+        t['dollarinferior'] = 0xF6E3;
+        t['dollarmonospace'] = 0xFF04;
+        t['dollaroldstyle'] = 0xF724;
+        t['dollarsmall'] = 0xFE69;
+        t['dollarsuperior'] = 0xF6E4;
+        t['dong'] = 0x20AB;
+        t['dorusquare'] = 0x3326;
+        t['dotaccent'] = 0x02D9;
+        t['dotaccentcmb'] = 0x0307;
+        t['dotbelowcmb'] = 0x0323;
+        t['dotbelowcomb'] = 0x0323;
+        t['dotkatakana'] = 0x30FB;
+        t['dotlessi'] = 0x0131;
+        t['dotlessj'] = 0xF6BE;
+        t['dotlessjstrokehook'] = 0x0284;
+        t['dotmath'] = 0x22C5;
+        t['dottedcircle'] = 0x25CC;
+        t['doubleyodpatah'] = 0xFB1F;
+        t['doubleyodpatahhebrew'] = 0xFB1F;
+        t['downtackbelowcmb'] = 0x031E;
+        t['downtackmod'] = 0x02D5;
+        t['dparen'] = 0x249F;
+        t['dsuperior'] = 0xF6EB;
+        t['dtail'] = 0x0256;
+        t['dtopbar'] = 0x018C;
+        t['duhiragana'] = 0x3065;
+        t['dukatakana'] = 0x30C5;
+        t['dz'] = 0x01F3;
+        t['dzaltone'] = 0x02A3;
+        t['dzcaron'] = 0x01C6;
+        t['dzcurl'] = 0x02A5;
+        t['dzeabkhasiancyrillic'] = 0x04E1;
+        t['dzecyrillic'] = 0x0455;
+        t['dzhecyrillic'] = 0x045F;
+        t['e'] = 0x0065;
+        t['eacute'] = 0x00E9;
+        t['earth'] = 0x2641;
+        t['ebengali'] = 0x098F;
+        t['ebopomofo'] = 0x311C;
+        t['ebreve'] = 0x0115;
+        t['ecandradeva'] = 0x090D;
+        t['ecandragujarati'] = 0x0A8D;
+        t['ecandravowelsigndeva'] = 0x0945;
+        t['ecandravowelsigngujarati'] = 0x0AC5;
+        t['ecaron'] = 0x011B;
+        t['ecedillabreve'] = 0x1E1D;
+        t['echarmenian'] = 0x0565;
+        t['echyiwnarmenian'] = 0x0587;
+        t['ecircle'] = 0x24D4;
+        t['ecircumflex'] = 0x00EA;
+        t['ecircumflexacute'] = 0x1EBF;
+        t['ecircumflexbelow'] = 0x1E19;
+        t['ecircumflexdotbelow'] = 0x1EC7;
+        t['ecircumflexgrave'] = 0x1EC1;
+        t['ecircumflexhookabove'] = 0x1EC3;
+        t['ecircumflextilde'] = 0x1EC5;
+        t['ecyrillic'] = 0x0454;
+        t['edblgrave'] = 0x0205;
+        t['edeva'] = 0x090F;
+        t['edieresis'] = 0x00EB;
+        t['edot'] = 0x0117;
+        t['edotaccent'] = 0x0117;
+        t['edotbelow'] = 0x1EB9;
+        t['eegurmukhi'] = 0x0A0F;
+        t['eematragurmukhi'] = 0x0A47;
+        t['efcyrillic'] = 0x0444;
+        t['egrave'] = 0x00E8;
+        t['egujarati'] = 0x0A8F;
+        t['eharmenian'] = 0x0567;
+        t['ehbopomofo'] = 0x311D;
+        t['ehiragana'] = 0x3048;
+        t['ehookabove'] = 0x1EBB;
+        t['eibopomofo'] = 0x311F;
+        t['eight'] = 0x0038;
+        t['eightarabic'] = 0x0668;
+        t['eightbengali'] = 0x09EE;
+        t['eightcircle'] = 0x2467;
+        t['eightcircleinversesansserif'] = 0x2791;
+        t['eightdeva'] = 0x096E;
+        t['eighteencircle'] = 0x2471;
+        t['eighteenparen'] = 0x2485;
+        t['eighteenperiod'] = 0x2499;
+        t['eightgujarati'] = 0x0AEE;
+        t['eightgurmukhi'] = 0x0A6E;
+        t['eighthackarabic'] = 0x0668;
+        t['eighthangzhou'] = 0x3028;
+        t['eighthnotebeamed'] = 0x266B;
+        t['eightideographicparen'] = 0x3227;
+        t['eightinferior'] = 0x2088;
+        t['eightmonospace'] = 0xFF18;
+        t['eightoldstyle'] = 0xF738;
+        t['eightparen'] = 0x247B;
+        t['eightperiod'] = 0x248F;
+        t['eightpersian'] = 0x06F8;
+        t['eightroman'] = 0x2177;
+        t['eightsuperior'] = 0x2078;
+        t['eightthai'] = 0x0E58;
+        t['einvertedbreve'] = 0x0207;
+        t['eiotifiedcyrillic'] = 0x0465;
+        t['ekatakana'] = 0x30A8;
+        t['ekatakanahalfwidth'] = 0xFF74;
+        t['ekonkargurmukhi'] = 0x0A74;
+        t['ekorean'] = 0x3154;
+        t['elcyrillic'] = 0x043B;
+        t['element'] = 0x2208;
+        t['elevencircle'] = 0x246A;
+        t['elevenparen'] = 0x247E;
+        t['elevenperiod'] = 0x2492;
+        t['elevenroman'] = 0x217A;
+        t['ellipsis'] = 0x2026;
+        t['ellipsisvertical'] = 0x22EE;
+        t['emacron'] = 0x0113;
+        t['emacronacute'] = 0x1E17;
+        t['emacrongrave'] = 0x1E15;
+        t['emcyrillic'] = 0x043C;
+        t['emdash'] = 0x2014;
+        t['emdashvertical'] = 0xFE31;
+        t['emonospace'] = 0xFF45;
+        t['emphasismarkarmenian'] = 0x055B;
+        t['emptyset'] = 0x2205;
+        t['enbopomofo'] = 0x3123;
+        t['encyrillic'] = 0x043D;
+        t['endash'] = 0x2013;
+        t['endashvertical'] = 0xFE32;
+        t['endescendercyrillic'] = 0x04A3;
+        t['eng'] = 0x014B;
+        t['engbopomofo'] = 0x3125;
+        t['enghecyrillic'] = 0x04A5;
+        t['enhookcyrillic'] = 0x04C8;
+        t['enspace'] = 0x2002;
+        t['eogonek'] = 0x0119;
+        t['eokorean'] = 0x3153;
+        t['eopen'] = 0x025B;
+        t['eopenclosed'] = 0x029A;
+        t['eopenreversed'] = 0x025C;
+        t['eopenreversedclosed'] = 0x025E;
+        t['eopenreversedhook'] = 0x025D;
+        t['eparen'] = 0x24A0;
+        t['epsilon'] = 0x03B5;
+        t['epsilontonos'] = 0x03AD;
+        t['equal'] = 0x003D;
+        t['equalmonospace'] = 0xFF1D;
+        t['equalsmall'] = 0xFE66;
+        t['equalsuperior'] = 0x207C;
+        t['equivalence'] = 0x2261;
+        t['erbopomofo'] = 0x3126;
+        t['ercyrillic'] = 0x0440;
+        t['ereversed'] = 0x0258;
+        t['ereversedcyrillic'] = 0x044D;
+        t['escyrillic'] = 0x0441;
+        t['esdescendercyrillic'] = 0x04AB;
+        t['esh'] = 0x0283;
+        t['eshcurl'] = 0x0286;
+        t['eshortdeva'] = 0x090E;
+        t['eshortvowelsigndeva'] = 0x0946;
+        t['eshreversedloop'] = 0x01AA;
+        t['eshsquatreversed'] = 0x0285;
+        t['esmallhiragana'] = 0x3047;
+        t['esmallkatakana'] = 0x30A7;
+        t['esmallkatakanahalfwidth'] = 0xFF6A;
+        t['estimated'] = 0x212E;
+        t['esuperior'] = 0xF6EC;
+        t['eta'] = 0x03B7;
+        t['etarmenian'] = 0x0568;
+        t['etatonos'] = 0x03AE;
+        t['eth'] = 0x00F0;
+        t['etilde'] = 0x1EBD;
+        t['etildebelow'] = 0x1E1B;
+        t['etnahtafoukhhebrew'] = 0x0591;
+        t['etnahtafoukhlefthebrew'] = 0x0591;
+        t['etnahtahebrew'] = 0x0591;
+        t['etnahtalefthebrew'] = 0x0591;
+        t['eturned'] = 0x01DD;
+        t['eukorean'] = 0x3161;
+        t['euro'] = 0x20AC;
+        t['evowelsignbengali'] = 0x09C7;
+        t['evowelsigndeva'] = 0x0947;
+        t['evowelsigngujarati'] = 0x0AC7;
+        t['exclam'] = 0x0021;
+        t['exclamarmenian'] = 0x055C;
+        t['exclamdbl'] = 0x203C;
+        t['exclamdown'] = 0x00A1;
+        t['exclamdownsmall'] = 0xF7A1;
+        t['exclammonospace'] = 0xFF01;
+        t['exclamsmall'] = 0xF721;
+        t['existential'] = 0x2203;
+        t['ezh'] = 0x0292;
+        t['ezhcaron'] = 0x01EF;
+        t['ezhcurl'] = 0x0293;
+        t['ezhreversed'] = 0x01B9;
+        t['ezhtail'] = 0x01BA;
+        t['f'] = 0x0066;
+        t['fadeva'] = 0x095E;
+        t['fagurmukhi'] = 0x0A5E;
+        t['fahrenheit'] = 0x2109;
+        t['fathaarabic'] = 0x064E;
+        t['fathalowarabic'] = 0x064E;
+        t['fathatanarabic'] = 0x064B;
+        t['fbopomofo'] = 0x3108;
+        t['fcircle'] = 0x24D5;
+        t['fdotaccent'] = 0x1E1F;
+        t['feharabic'] = 0x0641;
+        t['feharmenian'] = 0x0586;
+        t['fehfinalarabic'] = 0xFED2;
+        t['fehinitialarabic'] = 0xFED3;
+        t['fehmedialarabic'] = 0xFED4;
+        t['feicoptic'] = 0x03E5;
+        t['female'] = 0x2640;
+        t['ff'] = 0xFB00;
+        t['ffi'] = 0xFB03;
+        t['ffl'] = 0xFB04;
+        t['fi'] = 0xFB01;
+        t['fifteencircle'] = 0x246E;
+        t['fifteenparen'] = 0x2482;
+        t['fifteenperiod'] = 0x2496;
+        t['figuredash'] = 0x2012;
+        t['filledbox'] = 0x25A0;
+        t['filledrect'] = 0x25AC;
+        t['finalkaf'] = 0x05DA;
+        t['finalkafdagesh'] = 0xFB3A;
+        t['finalkafdageshhebrew'] = 0xFB3A;
+        t['finalkafhebrew'] = 0x05DA;
+        t['finalmem'] = 0x05DD;
+        t['finalmemhebrew'] = 0x05DD;
+        t['finalnun'] = 0x05DF;
+        t['finalnunhebrew'] = 0x05DF;
+        t['finalpe'] = 0x05E3;
+        t['finalpehebrew'] = 0x05E3;
+        t['finaltsadi'] = 0x05E5;
+        t['finaltsadihebrew'] = 0x05E5;
+        t['firsttonechinese'] = 0x02C9;
+        t['fisheye'] = 0x25C9;
+        t['fitacyrillic'] = 0x0473;
+        t['five'] = 0x0035;
+        t['fivearabic'] = 0x0665;
+        t['fivebengali'] = 0x09EB;
+        t['fivecircle'] = 0x2464;
+        t['fivecircleinversesansserif'] = 0x278E;
+        t['fivedeva'] = 0x096B;
+        t['fiveeighths'] = 0x215D;
+        t['fivegujarati'] = 0x0AEB;
+        t['fivegurmukhi'] = 0x0A6B;
+        t['fivehackarabic'] = 0x0665;
+        t['fivehangzhou'] = 0x3025;
+        t['fiveideographicparen'] = 0x3224;
+        t['fiveinferior'] = 0x2085;
+        t['fivemonospace'] = 0xFF15;
+        t['fiveoldstyle'] = 0xF735;
+        t['fiveparen'] = 0x2478;
+        t['fiveperiod'] = 0x248C;
+        t['fivepersian'] = 0x06F5;
+        t['fiveroman'] = 0x2174;
+        t['fivesuperior'] = 0x2075;
+        t['fivethai'] = 0x0E55;
+        t['fl'] = 0xFB02;
+        t['florin'] = 0x0192;
+        t['fmonospace'] = 0xFF46;
+        t['fmsquare'] = 0x3399;
+        t['fofanthai'] = 0x0E1F;
+        t['fofathai'] = 0x0E1D;
+        t['fongmanthai'] = 0x0E4F;
+        t['forall'] = 0x2200;
+        t['four'] = 0x0034;
+        t['fourarabic'] = 0x0664;
+        t['fourbengali'] = 0x09EA;
+        t['fourcircle'] = 0x2463;
+        t['fourcircleinversesansserif'] = 0x278D;
+        t['fourdeva'] = 0x096A;
+        t['fourgujarati'] = 0x0AEA;
+        t['fourgurmukhi'] = 0x0A6A;
+        t['fourhackarabic'] = 0x0664;
+        t['fourhangzhou'] = 0x3024;
+        t['fourideographicparen'] = 0x3223;
+        t['fourinferior'] = 0x2084;
+        t['fourmonospace'] = 0xFF14;
+        t['fournumeratorbengali'] = 0x09F7;
+        t['fouroldstyle'] = 0xF734;
+        t['fourparen'] = 0x2477;
+        t['fourperiod'] = 0x248B;
+        t['fourpersian'] = 0x06F4;
+        t['fourroman'] = 0x2173;
+        t['foursuperior'] = 0x2074;
+        t['fourteencircle'] = 0x246D;
+        t['fourteenparen'] = 0x2481;
+        t['fourteenperiod'] = 0x2495;
+        t['fourthai'] = 0x0E54;
+        t['fourthtonechinese'] = 0x02CB;
+        t['fparen'] = 0x24A1;
+        t['fraction'] = 0x2044;
+        t['franc'] = 0x20A3;
+        t['g'] = 0x0067;
+        t['gabengali'] = 0x0997;
+        t['gacute'] = 0x01F5;
+        t['gadeva'] = 0x0917;
+        t['gafarabic'] = 0x06AF;
+        t['gaffinalarabic'] = 0xFB93;
+        t['gafinitialarabic'] = 0xFB94;
+        t['gafmedialarabic'] = 0xFB95;
+        t['gagujarati'] = 0x0A97;
+        t['gagurmukhi'] = 0x0A17;
+        t['gahiragana'] = 0x304C;
+        t['gakatakana'] = 0x30AC;
+        t['gamma'] = 0x03B3;
+        t['gammalatinsmall'] = 0x0263;
+        t['gammasuperior'] = 0x02E0;
+        t['gangiacoptic'] = 0x03EB;
+        t['gbopomofo'] = 0x310D;
+        t['gbreve'] = 0x011F;
+        t['gcaron'] = 0x01E7;
+        t['gcedilla'] = 0x0123;
+        t['gcircle'] = 0x24D6;
+        t['gcircumflex'] = 0x011D;
+        t['gcommaaccent'] = 0x0123;
+        t['gdot'] = 0x0121;
+        t['gdotaccent'] = 0x0121;
+        t['gecyrillic'] = 0x0433;
+        t['gehiragana'] = 0x3052;
+        t['gekatakana'] = 0x30B2;
+        t['geometricallyequal'] = 0x2251;
+        t['gereshaccenthebrew'] = 0x059C;
+        t['gereshhebrew'] = 0x05F3;
+        t['gereshmuqdamhebrew'] = 0x059D;
+        t['germandbls'] = 0x00DF;
+        t['gershayimaccenthebrew'] = 0x059E;
+        t['gershayimhebrew'] = 0x05F4;
+        t['getamark'] = 0x3013;
+        t['ghabengali'] = 0x0998;
+        t['ghadarmenian'] = 0x0572;
+        t['ghadeva'] = 0x0918;
+        t['ghagujarati'] = 0x0A98;
+        t['ghagurmukhi'] = 0x0A18;
+        t['ghainarabic'] = 0x063A;
+        t['ghainfinalarabic'] = 0xFECE;
+        t['ghaininitialarabic'] = 0xFECF;
+        t['ghainmedialarabic'] = 0xFED0;
+        t['ghemiddlehookcyrillic'] = 0x0495;
+        t['ghestrokecyrillic'] = 0x0493;
+        t['gheupturncyrillic'] = 0x0491;
+        t['ghhadeva'] = 0x095A;
+        t['ghhagurmukhi'] = 0x0A5A;
+        t['ghook'] = 0x0260;
+        t['ghzsquare'] = 0x3393;
+        t['gihiragana'] = 0x304E;
+        t['gikatakana'] = 0x30AE;
+        t['gimarmenian'] = 0x0563;
+        t['gimel'] = 0x05D2;
+        t['gimeldagesh'] = 0xFB32;
+        t['gimeldageshhebrew'] = 0xFB32;
+        t['gimelhebrew'] = 0x05D2;
+        t['gjecyrillic'] = 0x0453;
+        t['glottalinvertedstroke'] = 0x01BE;
+        t['glottalstop'] = 0x0294;
+        t['glottalstopinverted'] = 0x0296;
+        t['glottalstopmod'] = 0x02C0;
+        t['glottalstopreversed'] = 0x0295;
+        t['glottalstopreversedmod'] = 0x02C1;
+        t['glottalstopreversedsuperior'] = 0x02E4;
+        t['glottalstopstroke'] = 0x02A1;
+        t['glottalstopstrokereversed'] = 0x02A2;
+        t['gmacron'] = 0x1E21;
+        t['gmonospace'] = 0xFF47;
+        t['gohiragana'] = 0x3054;
+        t['gokatakana'] = 0x30B4;
+        t['gparen'] = 0x24A2;
+        t['gpasquare'] = 0x33AC;
+        t['gradient'] = 0x2207;
+        t['grave'] = 0x0060;
+        t['gravebelowcmb'] = 0x0316;
+        t['gravecmb'] = 0x0300;
+        t['gravecomb'] = 0x0300;
+        t['gravedeva'] = 0x0953;
+        t['gravelowmod'] = 0x02CE;
+        t['gravemonospace'] = 0xFF40;
+        t['gravetonecmb'] = 0x0340;
+        t['greater'] = 0x003E;
+        t['greaterequal'] = 0x2265;
+        t['greaterequalorless'] = 0x22DB;
+        t['greatermonospace'] = 0xFF1E;
+        t['greaterorequivalent'] = 0x2273;
+        t['greaterorless'] = 0x2277;
+        t['greateroverequal'] = 0x2267;
+        t['greatersmall'] = 0xFE65;
+        t['gscript'] = 0x0261;
+        t['gstroke'] = 0x01E5;
+        t['guhiragana'] = 0x3050;
+        t['guillemotleft'] = 0x00AB;
+        t['guillemotright'] = 0x00BB;
+        t['guilsinglleft'] = 0x2039;
+        t['guilsinglright'] = 0x203A;
+        t['gukatakana'] = 0x30B0;
+        t['guramusquare'] = 0x3318;
+        t['gysquare'] = 0x33C9;
+        t['h'] = 0x0068;
+        t['haabkhasiancyrillic'] = 0x04A9;
+        t['haaltonearabic'] = 0x06C1;
+        t['habengali'] = 0x09B9;
+        t['hadescendercyrillic'] = 0x04B3;
+        t['hadeva'] = 0x0939;
+        t['hagujarati'] = 0x0AB9;
+        t['hagurmukhi'] = 0x0A39;
+        t['haharabic'] = 0x062D;
+        t['hahfinalarabic'] = 0xFEA2;
+        t['hahinitialarabic'] = 0xFEA3;
+        t['hahiragana'] = 0x306F;
+        t['hahmedialarabic'] = 0xFEA4;
+        t['haitusquare'] = 0x332A;
+        t['hakatakana'] = 0x30CF;
+        t['hakatakanahalfwidth'] = 0xFF8A;
+        t['halantgurmukhi'] = 0x0A4D;
+        t['hamzaarabic'] = 0x0621;
+        t['hamzalowarabic'] = 0x0621;
+        t['hangulfiller'] = 0x3164;
+        t['hardsigncyrillic'] = 0x044A;
+        t['harpoonleftbarbup'] = 0x21BC;
+        t['harpoonrightbarbup'] = 0x21C0;
+        t['hasquare'] = 0x33CA;
+        t['hatafpatah'] = 0x05B2;
+        t['hatafpatah16'] = 0x05B2;
+        t['hatafpatah23'] = 0x05B2;
+        t['hatafpatah2f'] = 0x05B2;
+        t['hatafpatahhebrew'] = 0x05B2;
+        t['hatafpatahnarrowhebrew'] = 0x05B2;
+        t['hatafpatahquarterhebrew'] = 0x05B2;
+        t['hatafpatahwidehebrew'] = 0x05B2;
+        t['hatafqamats'] = 0x05B3;
+        t['hatafqamats1b'] = 0x05B3;
+        t['hatafqamats28'] = 0x05B3;
+        t['hatafqamats34'] = 0x05B3;
+        t['hatafqamatshebrew'] = 0x05B3;
+        t['hatafqamatsnarrowhebrew'] = 0x05B3;
+        t['hatafqamatsquarterhebrew'] = 0x05B3;
+        t['hatafqamatswidehebrew'] = 0x05B3;
+        t['hatafsegol'] = 0x05B1;
+        t['hatafsegol17'] = 0x05B1;
+        t['hatafsegol24'] = 0x05B1;
+        t['hatafsegol30'] = 0x05B1;
+        t['hatafsegolhebrew'] = 0x05B1;
+        t['hatafsegolnarrowhebrew'] = 0x05B1;
+        t['hatafsegolquarterhebrew'] = 0x05B1;
+        t['hatafsegolwidehebrew'] = 0x05B1;
+        t['hbar'] = 0x0127;
+        t['hbopomofo'] = 0x310F;
+        t['hbrevebelow'] = 0x1E2B;
+        t['hcedilla'] = 0x1E29;
+        t['hcircle'] = 0x24D7;
+        t['hcircumflex'] = 0x0125;
+        t['hdieresis'] = 0x1E27;
+        t['hdotaccent'] = 0x1E23;
+        t['hdotbelow'] = 0x1E25;
+        t['he'] = 0x05D4;
+        t['heart'] = 0x2665;
+        t['heartsuitblack'] = 0x2665;
+        t['heartsuitwhite'] = 0x2661;
+        t['hedagesh'] = 0xFB34;
+        t['hedageshhebrew'] = 0xFB34;
+        t['hehaltonearabic'] = 0x06C1;
+        t['heharabic'] = 0x0647;
+        t['hehebrew'] = 0x05D4;
+        t['hehfinalaltonearabic'] = 0xFBA7;
+        t['hehfinalalttwoarabic'] = 0xFEEA;
+        t['hehfinalarabic'] = 0xFEEA;
+        t['hehhamzaabovefinalarabic'] = 0xFBA5;
+        t['hehhamzaaboveisolatedarabic'] = 0xFBA4;
+        t['hehinitialaltonearabic'] = 0xFBA8;
+        t['hehinitialarabic'] = 0xFEEB;
+        t['hehiragana'] = 0x3078;
+        t['hehmedialaltonearabic'] = 0xFBA9;
+        t['hehmedialarabic'] = 0xFEEC;
+        t['heiseierasquare'] = 0x337B;
+        t['hekatakana'] = 0x30D8;
+        t['hekatakanahalfwidth'] = 0xFF8D;
+        t['hekutaarusquare'] = 0x3336;
+        t['henghook'] = 0x0267;
+        t['herutusquare'] = 0x3339;
+        t['het'] = 0x05D7;
+        t['hethebrew'] = 0x05D7;
+        t['hhook'] = 0x0266;
+        t['hhooksuperior'] = 0x02B1;
+        t['hieuhacirclekorean'] = 0x327B;
+        t['hieuhaparenkorean'] = 0x321B;
+        t['hieuhcirclekorean'] = 0x326D;
+        t['hieuhkorean'] = 0x314E;
+        t['hieuhparenkorean'] = 0x320D;
+        t['hihiragana'] = 0x3072;
+        t['hikatakana'] = 0x30D2;
+        t['hikatakanahalfwidth'] = 0xFF8B;
+        t['hiriq'] = 0x05B4;
+        t['hiriq14'] = 0x05B4;
+        t['hiriq21'] = 0x05B4;
+        t['hiriq2d'] = 0x05B4;
+        t['hiriqhebrew'] = 0x05B4;
+        t['hiriqnarrowhebrew'] = 0x05B4;
+        t['hiriqquarterhebrew'] = 0x05B4;
+        t['hiriqwidehebrew'] = 0x05B4;
+        t['hlinebelow'] = 0x1E96;
+        t['hmonospace'] = 0xFF48;
+        t['hoarmenian'] = 0x0570;
+        t['hohipthai'] = 0x0E2B;
+        t['hohiragana'] = 0x307B;
+        t['hokatakana'] = 0x30DB;
+        t['hokatakanahalfwidth'] = 0xFF8E;
+        t['holam'] = 0x05B9;
+        t['holam19'] = 0x05B9;
+        t['holam26'] = 0x05B9;
+        t['holam32'] = 0x05B9;
+        t['holamhebrew'] = 0x05B9;
+        t['holamnarrowhebrew'] = 0x05B9;
+        t['holamquarterhebrew'] = 0x05B9;
+        t['holamwidehebrew'] = 0x05B9;
+        t['honokhukthai'] = 0x0E2E;
+        t['hookabovecomb'] = 0x0309;
+        t['hookcmb'] = 0x0309;
+        t['hookpalatalizedbelowcmb'] = 0x0321;
+        t['hookretroflexbelowcmb'] = 0x0322;
+        t['hoonsquare'] = 0x3342;
+        t['horicoptic'] = 0x03E9;
+        t['horizontalbar'] = 0x2015;
+        t['horncmb'] = 0x031B;
+        t['hotsprings'] = 0x2668;
+        t['house'] = 0x2302;
+        t['hparen'] = 0x24A3;
+        t['hsuperior'] = 0x02B0;
+        t['hturned'] = 0x0265;
+        t['huhiragana'] = 0x3075;
+        t['huiitosquare'] = 0x3333;
+        t['hukatakana'] = 0x30D5;
+        t['hukatakanahalfwidth'] = 0xFF8C;
+        t['hungarumlaut'] = 0x02DD;
+        t['hungarumlautcmb'] = 0x030B;
+        t['hv'] = 0x0195;
+        t['hyphen'] = 0x002D;
+        t['hypheninferior'] = 0xF6E5;
+        t['hyphenmonospace'] = 0xFF0D;
+        t['hyphensmall'] = 0xFE63;
+        t['hyphensuperior'] = 0xF6E6;
+        t['hyphentwo'] = 0x2010;
+        t['i'] = 0x0069;
+        t['iacute'] = 0x00ED;
+        t['iacyrillic'] = 0x044F;
+        t['ibengali'] = 0x0987;
+        t['ibopomofo'] = 0x3127;
+        t['ibreve'] = 0x012D;
+        t['icaron'] = 0x01D0;
+        t['icircle'] = 0x24D8;
+        t['icircumflex'] = 0x00EE;
+        t['icyrillic'] = 0x0456;
+        t['idblgrave'] = 0x0209;
+        t['ideographearthcircle'] = 0x328F;
+        t['ideographfirecircle'] = 0x328B;
+        t['ideographicallianceparen'] = 0x323F;
+        t['ideographiccallparen'] = 0x323A;
+        t['ideographiccentrecircle'] = 0x32A5;
+        t['ideographicclose'] = 0x3006;
+        t['ideographiccomma'] = 0x3001;
+        t['ideographiccommaleft'] = 0xFF64;
+        t['ideographiccongratulationparen'] = 0x3237;
+        t['ideographiccorrectcircle'] = 0x32A3;
+        t['ideographicearthparen'] = 0x322F;
+        t['ideographicenterpriseparen'] = 0x323D;
+        t['ideographicexcellentcircle'] = 0x329D;
+        t['ideographicfestivalparen'] = 0x3240;
+        t['ideographicfinancialcircle'] = 0x3296;
+        t['ideographicfinancialparen'] = 0x3236;
+        t['ideographicfireparen'] = 0x322B;
+        t['ideographichaveparen'] = 0x3232;
+        t['ideographichighcircle'] = 0x32A4;
+        t['ideographiciterationmark'] = 0x3005;
+        t['ideographiclaborcircle'] = 0x3298;
+        t['ideographiclaborparen'] = 0x3238;
+        t['ideographicleftcircle'] = 0x32A7;
+        t['ideographiclowcircle'] = 0x32A6;
+        t['ideographicmedicinecircle'] = 0x32A9;
+        t['ideographicmetalparen'] = 0x322E;
+        t['ideographicmoonparen'] = 0x322A;
+        t['ideographicnameparen'] = 0x3234;
+        t['ideographicperiod'] = 0x3002;
+        t['ideographicprintcircle'] = 0x329E;
+        t['ideographicreachparen'] = 0x3243;
+        t['ideographicrepresentparen'] = 0x3239;
+        t['ideographicresourceparen'] = 0x323E;
+        t['ideographicrightcircle'] = 0x32A8;
+        t['ideographicsecretcircle'] = 0x3299;
+        t['ideographicselfparen'] = 0x3242;
+        t['ideographicsocietyparen'] = 0x3233;
+        t['ideographicspace'] = 0x3000;
+        t['ideographicspecialparen'] = 0x3235;
+        t['ideographicstockparen'] = 0x3231;
+        t['ideographicstudyparen'] = 0x323B;
+        t['ideographicsunparen'] = 0x3230;
+        t['ideographicsuperviseparen'] = 0x323C;
+        t['ideographicwaterparen'] = 0x322C;
+        t['ideographicwoodparen'] = 0x322D;
+        t['ideographiczero'] = 0x3007;
+        t['ideographmetalcircle'] = 0x328E;
+        t['ideographmooncircle'] = 0x328A;
+        t['ideographnamecircle'] = 0x3294;
+        t['ideographsuncircle'] = 0x3290;
+        t['ideographwatercircle'] = 0x328C;
+        t['ideographwoodcircle'] = 0x328D;
+        t['ideva'] = 0x0907;
+        t['idieresis'] = 0x00EF;
+        t['idieresisacute'] = 0x1E2F;
+        t['idieresiscyrillic'] = 0x04E5;
+        t['idotbelow'] = 0x1ECB;
+        t['iebrevecyrillic'] = 0x04D7;
+        t['iecyrillic'] = 0x0435;
+        t['ieungacirclekorean'] = 0x3275;
+        t['ieungaparenkorean'] = 0x3215;
+        t['ieungcirclekorean'] = 0x3267;
+        t['ieungkorean'] = 0x3147;
+        t['ieungparenkorean'] = 0x3207;
+        t['igrave'] = 0x00EC;
+        t['igujarati'] = 0x0A87;
+        t['igurmukhi'] = 0x0A07;
+        t['ihiragana'] = 0x3044;
+        t['ihookabove'] = 0x1EC9;
+        t['iibengali'] = 0x0988;
+        t['iicyrillic'] = 0x0438;
+        t['iideva'] = 0x0908;
+        t['iigujarati'] = 0x0A88;
+        t['iigurmukhi'] = 0x0A08;
+        t['iimatragurmukhi'] = 0x0A40;
+        t['iinvertedbreve'] = 0x020B;
+        t['iishortcyrillic'] = 0x0439;
+        t['iivowelsignbengali'] = 0x09C0;
+        t['iivowelsigndeva'] = 0x0940;
+        t['iivowelsigngujarati'] = 0x0AC0;
+        t['ij'] = 0x0133;
+        t['ikatakana'] = 0x30A4;
+        t['ikatakanahalfwidth'] = 0xFF72;
+        t['ikorean'] = 0x3163;
+        t['ilde'] = 0x02DC;
+        t['iluyhebrew'] = 0x05AC;
+        t['imacron'] = 0x012B;
+        t['imacroncyrillic'] = 0x04E3;
+        t['imageorapproximatelyequal'] = 0x2253;
+        t['imatragurmukhi'] = 0x0A3F;
+        t['imonospace'] = 0xFF49;
+        t['increment'] = 0x2206;
+        t['infinity'] = 0x221E;
+        t['iniarmenian'] = 0x056B;
+        t['integral'] = 0x222B;
+        t['integralbottom'] = 0x2321;
+        t['integralbt'] = 0x2321;
+        t['integralex'] = 0xF8F5;
+        t['integraltop'] = 0x2320;
+        t['integraltp'] = 0x2320;
+        t['intersection'] = 0x2229;
+        t['intisquare'] = 0x3305;
+        t['invbullet'] = 0x25D8;
+        t['invcircle'] = 0x25D9;
+        t['invsmileface'] = 0x263B;
+        t['iocyrillic'] = 0x0451;
+        t['iogonek'] = 0x012F;
+        t['iota'] = 0x03B9;
+        t['iotadieresis'] = 0x03CA;
+        t['iotadieresistonos'] = 0x0390;
+        t['iotalatin'] = 0x0269;
+        t['iotatonos'] = 0x03AF;
+        t['iparen'] = 0x24A4;
+        t['irigurmukhi'] = 0x0A72;
+        t['ismallhiragana'] = 0x3043;
+        t['ismallkatakana'] = 0x30A3;
+        t['ismallkatakanahalfwidth'] = 0xFF68;
+        t['issharbengali'] = 0x09FA;
+        t['istroke'] = 0x0268;
+        t['isuperior'] = 0xF6ED;
+        t['iterationhiragana'] = 0x309D;
+        t['iterationkatakana'] = 0x30FD;
+        t['itilde'] = 0x0129;
+        t['itildebelow'] = 0x1E2D;
+        t['iubopomofo'] = 0x3129;
+        t['iucyrillic'] = 0x044E;
+        t['ivowelsignbengali'] = 0x09BF;
+        t['ivowelsigndeva'] = 0x093F;
+        t['ivowelsigngujarati'] = 0x0ABF;
+        t['izhitsacyrillic'] = 0x0475;
+        t['izhitsadblgravecyrillic'] = 0x0477;
+        t['j'] = 0x006A;
+        t['jaarmenian'] = 0x0571;
+        t['jabengali'] = 0x099C;
+        t['jadeva'] = 0x091C;
+        t['jagujarati'] = 0x0A9C;
+        t['jagurmukhi'] = 0x0A1C;
+        t['jbopomofo'] = 0x3110;
+        t['jcaron'] = 0x01F0;
+        t['jcircle'] = 0x24D9;
+        t['jcircumflex'] = 0x0135;
+        t['jcrossedtail'] = 0x029D;
+        t['jdotlessstroke'] = 0x025F;
+        t['jecyrillic'] = 0x0458;
+        t['jeemarabic'] = 0x062C;
+        t['jeemfinalarabic'] = 0xFE9E;
+        t['jeeminitialarabic'] = 0xFE9F;
+        t['jeemmedialarabic'] = 0xFEA0;
+        t['jeharabic'] = 0x0698;
+        t['jehfinalarabic'] = 0xFB8B;
+        t['jhabengali'] = 0x099D;
+        t['jhadeva'] = 0x091D;
+        t['jhagujarati'] = 0x0A9D;
+        t['jhagurmukhi'] = 0x0A1D;
+        t['jheharmenian'] = 0x057B;
+        t['jis'] = 0x3004;
+        t['jmonospace'] = 0xFF4A;
+        t['jparen'] = 0x24A5;
+        t['jsuperior'] = 0x02B2;
+        t['k'] = 0x006B;
+        t['kabashkircyrillic'] = 0x04A1;
+        t['kabengali'] = 0x0995;
+        t['kacute'] = 0x1E31;
+        t['kacyrillic'] = 0x043A;
+        t['kadescendercyrillic'] = 0x049B;
+        t['kadeva'] = 0x0915;
+        t['kaf'] = 0x05DB;
+        t['kafarabic'] = 0x0643;
+        t['kafdagesh'] = 0xFB3B;
+        t['kafdageshhebrew'] = 0xFB3B;
+        t['kaffinalarabic'] = 0xFEDA;
+        t['kafhebrew'] = 0x05DB;
+        t['kafinitialarabic'] = 0xFEDB;
+        t['kafmedialarabic'] = 0xFEDC;
+        t['kafrafehebrew'] = 0xFB4D;
+        t['kagujarati'] = 0x0A95;
+        t['kagurmukhi'] = 0x0A15;
+        t['kahiragana'] = 0x304B;
+        t['kahookcyrillic'] = 0x04C4;
+        t['kakatakana'] = 0x30AB;
+        t['kakatakanahalfwidth'] = 0xFF76;
+        t['kappa'] = 0x03BA;
+        t['kappasymbolgreek'] = 0x03F0;
+        t['kapyeounmieumkorean'] = 0x3171;
+        t['kapyeounphieuphkorean'] = 0x3184;
+        t['kapyeounpieupkorean'] = 0x3178;
+        t['kapyeounssangpieupkorean'] = 0x3179;
+        t['karoriisquare'] = 0x330D;
+        t['kashidaautoarabic'] = 0x0640;
+        t['kashidaautonosidebearingarabic'] = 0x0640;
+        t['kasmallkatakana'] = 0x30F5;
+        t['kasquare'] = 0x3384;
+        t['kasraarabic'] = 0x0650;
+        t['kasratanarabic'] = 0x064D;
+        t['kastrokecyrillic'] = 0x049F;
+        t['katahiraprolongmarkhalfwidth'] = 0xFF70;
+        t['kaverticalstrokecyrillic'] = 0x049D;
+        t['kbopomofo'] = 0x310E;
+        t['kcalsquare'] = 0x3389;
+        t['kcaron'] = 0x01E9;
+        t['kcedilla'] = 0x0137;
+        t['kcircle'] = 0x24DA;
+        t['kcommaaccent'] = 0x0137;
+        t['kdotbelow'] = 0x1E33;
+        t['keharmenian'] = 0x0584;
+        t['kehiragana'] = 0x3051;
+        t['kekatakana'] = 0x30B1;
+        t['kekatakanahalfwidth'] = 0xFF79;
+        t['kenarmenian'] = 0x056F;
+        t['kesmallkatakana'] = 0x30F6;
+        t['kgreenlandic'] = 0x0138;
+        t['khabengali'] = 0x0996;
+        t['khacyrillic'] = 0x0445;
+        t['khadeva'] = 0x0916;
+        t['khagujarati'] = 0x0A96;
+        t['khagurmukhi'] = 0x0A16;
+        t['khaharabic'] = 0x062E;
+        t['khahfinalarabic'] = 0xFEA6;
+        t['khahinitialarabic'] = 0xFEA7;
+        t['khahmedialarabic'] = 0xFEA8;
+        t['kheicoptic'] = 0x03E7;
+        t['khhadeva'] = 0x0959;
+        t['khhagurmukhi'] = 0x0A59;
+        t['khieukhacirclekorean'] = 0x3278;
+        t['khieukhaparenkorean'] = 0x3218;
+        t['khieukhcirclekorean'] = 0x326A;
+        t['khieukhkorean'] = 0x314B;
+        t['khieukhparenkorean'] = 0x320A;
+        t['khokhaithai'] = 0x0E02;
+        t['khokhonthai'] = 0x0E05;
+        t['khokhuatthai'] = 0x0E03;
+        t['khokhwaithai'] = 0x0E04;
+        t['khomutthai'] = 0x0E5B;
+        t['khook'] = 0x0199;
+        t['khorakhangthai'] = 0x0E06;
+        t['khzsquare'] = 0x3391;
+        t['kihiragana'] = 0x304D;
+        t['kikatakana'] = 0x30AD;
+        t['kikatakanahalfwidth'] = 0xFF77;
+        t['kiroguramusquare'] = 0x3315;
+        t['kiromeetorusquare'] = 0x3316;
+        t['kirosquare'] = 0x3314;
+        t['kiyeokacirclekorean'] = 0x326E;
+        t['kiyeokaparenkorean'] = 0x320E;
+        t['kiyeokcirclekorean'] = 0x3260;
+        t['kiyeokkorean'] = 0x3131;
+        t['kiyeokparenkorean'] = 0x3200;
+        t['kiyeoksioskorean'] = 0x3133;
+        t['kjecyrillic'] = 0x045C;
+        t['klinebelow'] = 0x1E35;
+        t['klsquare'] = 0x3398;
+        t['kmcubedsquare'] = 0x33A6;
+        t['kmonospace'] = 0xFF4B;
+        t['kmsquaredsquare'] = 0x33A2;
+        t['kohiragana'] = 0x3053;
+        t['kohmsquare'] = 0x33C0;
+        t['kokaithai'] = 0x0E01;
+        t['kokatakana'] = 0x30B3;
+        t['kokatakanahalfwidth'] = 0xFF7A;
+        t['kooposquare'] = 0x331E;
+        t['koppacyrillic'] = 0x0481;
+        t['koreanstandardsymbol'] = 0x327F;
+        t['koroniscmb'] = 0x0343;
+        t['kparen'] = 0x24A6;
+        t['kpasquare'] = 0x33AA;
+        t['ksicyrillic'] = 0x046F;
+        t['ktsquare'] = 0x33CF;
+        t['kturned'] = 0x029E;
+        t['kuhiragana'] = 0x304F;
+        t['kukatakana'] = 0x30AF;
+        t['kukatakanahalfwidth'] = 0xFF78;
+        t['kvsquare'] = 0x33B8;
+        t['kwsquare'] = 0x33BE;
+        t['l'] = 0x006C;
+        t['labengali'] = 0x09B2;
+        t['lacute'] = 0x013A;
+        t['ladeva'] = 0x0932;
+        t['lagujarati'] = 0x0AB2;
+        t['lagurmukhi'] = 0x0A32;
+        t['lakkhangyaothai'] = 0x0E45;
+        t['lamaleffinalarabic'] = 0xFEFC;
+        t['lamalefhamzaabovefinalarabic'] = 0xFEF8;
+        t['lamalefhamzaaboveisolatedarabic'] = 0xFEF7;
+        t['lamalefhamzabelowfinalarabic'] = 0xFEFA;
+        t['lamalefhamzabelowisolatedarabic'] = 0xFEF9;
+        t['lamalefisolatedarabic'] = 0xFEFB;
+        t['lamalefmaddaabovefinalarabic'] = 0xFEF6;
+        t['lamalefmaddaaboveisolatedarabic'] = 0xFEF5;
+        t['lamarabic'] = 0x0644;
+        t['lambda'] = 0x03BB;
+        t['lambdastroke'] = 0x019B;
+        t['lamed'] = 0x05DC;
+        t['lameddagesh'] = 0xFB3C;
+        t['lameddageshhebrew'] = 0xFB3C;
+        t['lamedhebrew'] = 0x05DC;
+        t['lamfinalarabic'] = 0xFEDE;
+        t['lamhahinitialarabic'] = 0xFCCA;
+        t['laminitialarabic'] = 0xFEDF;
+        t['lamjeeminitialarabic'] = 0xFCC9;
+        t['lamkhahinitialarabic'] = 0xFCCB;
+        t['lamlamhehisolatedarabic'] = 0xFDF2;
+        t['lammedialarabic'] = 0xFEE0;
+        t['lammeemhahinitialarabic'] = 0xFD88;
+        t['lammeeminitialarabic'] = 0xFCCC;
+        t['largecircle'] = 0x25EF;
+        t['lbar'] = 0x019A;
+        t['lbelt'] = 0x026C;
+        t['lbopomofo'] = 0x310C;
+        t['lcaron'] = 0x013E;
+        t['lcedilla'] = 0x013C;
+        t['lcircle'] = 0x24DB;
+        t['lcircumflexbelow'] = 0x1E3D;
+        t['lcommaaccent'] = 0x013C;
+        t['ldot'] = 0x0140;
+        t['ldotaccent'] = 0x0140;
+        t['ldotbelow'] = 0x1E37;
+        t['ldotbelowmacron'] = 0x1E39;
+        t['leftangleabovecmb'] = 0x031A;
+        t['lefttackbelowcmb'] = 0x0318;
+        t['less'] = 0x003C;
+        t['lessequal'] = 0x2264;
+        t['lessequalorgreater'] = 0x22DA;
+        t['lessmonospace'] = 0xFF1C;
+        t['lessorequivalent'] = 0x2272;
+        t['lessorgreater'] = 0x2276;
+        t['lessoverequal'] = 0x2266;
+        t['lesssmall'] = 0xFE64;
+        t['lezh'] = 0x026E;
+        t['lfblock'] = 0x258C;
+        t['lhookretroflex'] = 0x026D;
+        t['lira'] = 0x20A4;
+        t['liwnarmenian'] = 0x056C;
+        t['lj'] = 0x01C9;
+        t['ljecyrillic'] = 0x0459;
+        t['ll'] = 0xF6C0;
+        t['lladeva'] = 0x0933;
+        t['llagujarati'] = 0x0AB3;
+        t['llinebelow'] = 0x1E3B;
+        t['llladeva'] = 0x0934;
+        t['llvocalicbengali'] = 0x09E1;
+        t['llvocalicdeva'] = 0x0961;
+        t['llvocalicvowelsignbengali'] = 0x09E3;
+        t['llvocalicvowelsigndeva'] = 0x0963;
+        t['lmiddletilde'] = 0x026B;
+        t['lmonospace'] = 0xFF4C;
+        t['lmsquare'] = 0x33D0;
+        t['lochulathai'] = 0x0E2C;
+        t['logicaland'] = 0x2227;
+        t['logicalnot'] = 0x00AC;
+        t['logicalnotreversed'] = 0x2310;
+        t['logicalor'] = 0x2228;
+        t['lolingthai'] = 0x0E25;
+        t['longs'] = 0x017F;
+        t['lowlinecenterline'] = 0xFE4E;
+        t['lowlinecmb'] = 0x0332;
+        t['lowlinedashed'] = 0xFE4D;
+        t['lozenge'] = 0x25CA;
+        t['lparen'] = 0x24A7;
+        t['lslash'] = 0x0142;
+        t['lsquare'] = 0x2113;
+        t['lsuperior'] = 0xF6EE;
+        t['ltshade'] = 0x2591;
+        t['luthai'] = 0x0E26;
+        t['lvocalicbengali'] = 0x098C;
+        t['lvocalicdeva'] = 0x090C;
+        t['lvocalicvowelsignbengali'] = 0x09E2;
+        t['lvocalicvowelsigndeva'] = 0x0962;
+        t['lxsquare'] = 0x33D3;
+        t['m'] = 0x006D;
+        t['mabengali'] = 0x09AE;
+        t['macron'] = 0x00AF;
+        t['macronbelowcmb'] = 0x0331;
+        t['macroncmb'] = 0x0304;
+        t['macronlowmod'] = 0x02CD;
+        t['macronmonospace'] = 0xFFE3;
+        t['macute'] = 0x1E3F;
+        t['madeva'] = 0x092E;
+        t['magujarati'] = 0x0AAE;
+        t['magurmukhi'] = 0x0A2E;
+        t['mahapakhhebrew'] = 0x05A4;
+        t['mahapakhlefthebrew'] = 0x05A4;
+        t['mahiragana'] = 0x307E;
+        t['maichattawalowleftthai'] = 0xF895;
+        t['maichattawalowrightthai'] = 0xF894;
+        t['maichattawathai'] = 0x0E4B;
+        t['maichattawaupperleftthai'] = 0xF893;
+        t['maieklowleftthai'] = 0xF88C;
+        t['maieklowrightthai'] = 0xF88B;
+        t['maiekthai'] = 0x0E48;
+        t['maiekupperleftthai'] = 0xF88A;
+        t['maihanakatleftthai'] = 0xF884;
+        t['maihanakatthai'] = 0x0E31;
+        t['maitaikhuleftthai'] = 0xF889;
+        t['maitaikhuthai'] = 0x0E47;
+        t['maitholowleftthai'] = 0xF88F;
+        t['maitholowrightthai'] = 0xF88E;
+        t['maithothai'] = 0x0E49;
+        t['maithoupperleftthai'] = 0xF88D;
+        t['maitrilowleftthai'] = 0xF892;
+        t['maitrilowrightthai'] = 0xF891;
+        t['maitrithai'] = 0x0E4A;
+        t['maitriupperleftthai'] = 0xF890;
+        t['maiyamokthai'] = 0x0E46;
+        t['makatakana'] = 0x30DE;
+        t['makatakanahalfwidth'] = 0xFF8F;
+        t['male'] = 0x2642;
+        t['mansyonsquare'] = 0x3347;
+        t['maqafhebrew'] = 0x05BE;
+        t['mars'] = 0x2642;
+        t['masoracirclehebrew'] = 0x05AF;
+        t['masquare'] = 0x3383;
+        t['mbopomofo'] = 0x3107;
+        t['mbsquare'] = 0x33D4;
+        t['mcircle'] = 0x24DC;
+        t['mcubedsquare'] = 0x33A5;
+        t['mdotaccent'] = 0x1E41;
+        t['mdotbelow'] = 0x1E43;
+        t['meemarabic'] = 0x0645;
+        t['meemfinalarabic'] = 0xFEE2;
+        t['meeminitialarabic'] = 0xFEE3;
+        t['meemmedialarabic'] = 0xFEE4;
+        t['meemmeeminitialarabic'] = 0xFCD1;
+        t['meemmeemisolatedarabic'] = 0xFC48;
+        t['meetorusquare'] = 0x334D;
+        t['mehiragana'] = 0x3081;
+        t['meizierasquare'] = 0x337E;
+        t['mekatakana'] = 0x30E1;
+        t['mekatakanahalfwidth'] = 0xFF92;
+        t['mem'] = 0x05DE;
+        t['memdagesh'] = 0xFB3E;
+        t['memdageshhebrew'] = 0xFB3E;
+        t['memhebrew'] = 0x05DE;
+        t['menarmenian'] = 0x0574;
+        t['merkhahebrew'] = 0x05A5;
+        t['merkhakefulahebrew'] = 0x05A6;
+        t['merkhakefulalefthebrew'] = 0x05A6;
+        t['merkhalefthebrew'] = 0x05A5;
+        t['mhook'] = 0x0271;
+        t['mhzsquare'] = 0x3392;
+        t['middledotkatakanahalfwidth'] = 0xFF65;
+        t['middot'] = 0x00B7;
+        t['mieumacirclekorean'] = 0x3272;
+        t['mieumaparenkorean'] = 0x3212;
+        t['mieumcirclekorean'] = 0x3264;
+        t['mieumkorean'] = 0x3141;
+        t['mieumpansioskorean'] = 0x3170;
+        t['mieumparenkorean'] = 0x3204;
+        t['mieumpieupkorean'] = 0x316E;
+        t['mieumsioskorean'] = 0x316F;
+        t['mihiragana'] = 0x307F;
+        t['mikatakana'] = 0x30DF;
+        t['mikatakanahalfwidth'] = 0xFF90;
+        t['minus'] = 0x2212;
+        t['minusbelowcmb'] = 0x0320;
+        t['minuscircle'] = 0x2296;
+        t['minusmod'] = 0x02D7;
+        t['minusplus'] = 0x2213;
+        t['minute'] = 0x2032;
+        t['miribaarusquare'] = 0x334A;
+        t['mirisquare'] = 0x3349;
+        t['mlonglegturned'] = 0x0270;
+        t['mlsquare'] = 0x3396;
+        t['mmcubedsquare'] = 0x33A3;
+        t['mmonospace'] = 0xFF4D;
+        t['mmsquaredsquare'] = 0x339F;
+        t['mohiragana'] = 0x3082;
+        t['mohmsquare'] = 0x33C1;
+        t['mokatakana'] = 0x30E2;
+        t['mokatakanahalfwidth'] = 0xFF93;
+        t['molsquare'] = 0x33D6;
+        t['momathai'] = 0x0E21;
+        t['moverssquare'] = 0x33A7;
+        t['moverssquaredsquare'] = 0x33A8;
+        t['mparen'] = 0x24A8;
+        t['mpasquare'] = 0x33AB;
+        t['mssquare'] = 0x33B3;
+        t['msuperior'] = 0xF6EF;
+        t['mturned'] = 0x026F;
+        t['mu'] = 0x00B5;
+        t['mu1'] = 0x00B5;
+        t['muasquare'] = 0x3382;
+        t['muchgreater'] = 0x226B;
+        t['muchless'] = 0x226A;
+        t['mufsquare'] = 0x338C;
+        t['mugreek'] = 0x03BC;
+        t['mugsquare'] = 0x338D;
+        t['muhiragana'] = 0x3080;
+        t['mukatakana'] = 0x30E0;
+        t['mukatakanahalfwidth'] = 0xFF91;
+        t['mulsquare'] = 0x3395;
+        t['multiply'] = 0x00D7;
+        t['mumsquare'] = 0x339B;
+        t['munahhebrew'] = 0x05A3;
+        t['munahlefthebrew'] = 0x05A3;
+        t['musicalnote'] = 0x266A;
+        t['musicalnotedbl'] = 0x266B;
+        t['musicflatsign'] = 0x266D;
+        t['musicsharpsign'] = 0x266F;
+        t['mussquare'] = 0x33B2;
+        t['muvsquare'] = 0x33B6;
+        t['muwsquare'] = 0x33BC;
+        t['mvmegasquare'] = 0x33B9;
+        t['mvsquare'] = 0x33B7;
+        t['mwmegasquare'] = 0x33BF;
+        t['mwsquare'] = 0x33BD;
+        t['n'] = 0x006E;
+        t['nabengali'] = 0x09A8;
+        t['nabla'] = 0x2207;
+        t['nacute'] = 0x0144;
+        t['nadeva'] = 0x0928;
+        t['nagujarati'] = 0x0AA8;
+        t['nagurmukhi'] = 0x0A28;
+        t['nahiragana'] = 0x306A;
+        t['nakatakana'] = 0x30CA;
+        t['nakatakanahalfwidth'] = 0xFF85;
+        t['napostrophe'] = 0x0149;
+        t['nasquare'] = 0x3381;
+        t['nbopomofo'] = 0x310B;
+        t['nbspace'] = 0x00A0;
+        t['ncaron'] = 0x0148;
+        t['ncedilla'] = 0x0146;
+        t['ncircle'] = 0x24DD;
+        t['ncircumflexbelow'] = 0x1E4B;
+        t['ncommaaccent'] = 0x0146;
+        t['ndotaccent'] = 0x1E45;
+        t['ndotbelow'] = 0x1E47;
+        t['nehiragana'] = 0x306D;
+        t['nekatakana'] = 0x30CD;
+        t['nekatakanahalfwidth'] = 0xFF88;
+        t['newsheqelsign'] = 0x20AA;
+        t['nfsquare'] = 0x338B;
+        t['ngabengali'] = 0x0999;
+        t['ngadeva'] = 0x0919;
+        t['ngagujarati'] = 0x0A99;
+        t['ngagurmukhi'] = 0x0A19;
+        t['ngonguthai'] = 0x0E07;
+        t['nhiragana'] = 0x3093;
+        t['nhookleft'] = 0x0272;
+        t['nhookretroflex'] = 0x0273;
+        t['nieunacirclekorean'] = 0x326F;
+        t['nieunaparenkorean'] = 0x320F;
+        t['nieuncieuckorean'] = 0x3135;
+        t['nieuncirclekorean'] = 0x3261;
+        t['nieunhieuhkorean'] = 0x3136;
+        t['nieunkorean'] = 0x3134;
+        t['nieunpansioskorean'] = 0x3168;
+        t['nieunparenkorean'] = 0x3201;
+        t['nieunsioskorean'] = 0x3167;
+        t['nieuntikeutkorean'] = 0x3166;
+        t['nihiragana'] = 0x306B;
+        t['nikatakana'] = 0x30CB;
+        t['nikatakanahalfwidth'] = 0xFF86;
+        t['nikhahitleftthai'] = 0xF899;
+        t['nikhahitthai'] = 0x0E4D;
+        t['nine'] = 0x0039;
+        t['ninearabic'] = 0x0669;
+        t['ninebengali'] = 0x09EF;
+        t['ninecircle'] = 0x2468;
+        t['ninecircleinversesansserif'] = 0x2792;
+        t['ninedeva'] = 0x096F;
+        t['ninegujarati'] = 0x0AEF;
+        t['ninegurmukhi'] = 0x0A6F;
+        t['ninehackarabic'] = 0x0669;
+        t['ninehangzhou'] = 0x3029;
+        t['nineideographicparen'] = 0x3228;
+        t['nineinferior'] = 0x2089;
+        t['ninemonospace'] = 0xFF19;
+        t['nineoldstyle'] = 0xF739;
+        t['nineparen'] = 0x247C;
+        t['nineperiod'] = 0x2490;
+        t['ninepersian'] = 0x06F9;
+        t['nineroman'] = 0x2178;
+        t['ninesuperior'] = 0x2079;
+        t['nineteencircle'] = 0x2472;
+        t['nineteenparen'] = 0x2486;
+        t['nineteenperiod'] = 0x249A;
+        t['ninethai'] = 0x0E59;
+        t['nj'] = 0x01CC;
+        t['njecyrillic'] = 0x045A;
+        t['nkatakana'] = 0x30F3;
+        t['nkatakanahalfwidth'] = 0xFF9D;
+        t['nlegrightlong'] = 0x019E;
+        t['nlinebelow'] = 0x1E49;
+        t['nmonospace'] = 0xFF4E;
+        t['nmsquare'] = 0x339A;
+        t['nnabengali'] = 0x09A3;
+        t['nnadeva'] = 0x0923;
+        t['nnagujarati'] = 0x0AA3;
+        t['nnagurmukhi'] = 0x0A23;
+        t['nnnadeva'] = 0x0929;
+        t['nohiragana'] = 0x306E;
+        t['nokatakana'] = 0x30CE;
+        t['nokatakanahalfwidth'] = 0xFF89;
+        t['nonbreakingspace'] = 0x00A0;
+        t['nonenthai'] = 0x0E13;
+        t['nonuthai'] = 0x0E19;
+        t['noonarabic'] = 0x0646;
+        t['noonfinalarabic'] = 0xFEE6;
+        t['noonghunnaarabic'] = 0x06BA;
+        t['noonghunnafinalarabic'] = 0xFB9F;
+        t['nooninitialarabic'] = 0xFEE7;
+        t['noonjeeminitialarabic'] = 0xFCD2;
+        t['noonjeemisolatedarabic'] = 0xFC4B;
+        t['noonmedialarabic'] = 0xFEE8;
+        t['noonmeeminitialarabic'] = 0xFCD5;
+        t['noonmeemisolatedarabic'] = 0xFC4E;
+        t['noonnoonfinalarabic'] = 0xFC8D;
+        t['notcontains'] = 0x220C;
+        t['notelement'] = 0x2209;
+        t['notelementof'] = 0x2209;
+        t['notequal'] = 0x2260;
+        t['notgreater'] = 0x226F;
+        t['notgreaternorequal'] = 0x2271;
+        t['notgreaternorless'] = 0x2279;
+        t['notidentical'] = 0x2262;
+        t['notless'] = 0x226E;
+        t['notlessnorequal'] = 0x2270;
+        t['notparallel'] = 0x2226;
+        t['notprecedes'] = 0x2280;
+        t['notsubset'] = 0x2284;
+        t['notsucceeds'] = 0x2281;
+        t['notsuperset'] = 0x2285;
+        t['nowarmenian'] = 0x0576;
+        t['nparen'] = 0x24A9;
+        t['nssquare'] = 0x33B1;
+        t['nsuperior'] = 0x207F;
+        t['ntilde'] = 0x00F1;
+        t['nu'] = 0x03BD;
+        t['nuhiragana'] = 0x306C;
+        t['nukatakana'] = 0x30CC;
+        t['nukatakanahalfwidth'] = 0xFF87;
+        t['nuktabengali'] = 0x09BC;
+        t['nuktadeva'] = 0x093C;
+        t['nuktagujarati'] = 0x0ABC;
+        t['nuktagurmukhi'] = 0x0A3C;
+        t['numbersign'] = 0x0023;
+        t['numbersignmonospace'] = 0xFF03;
+        t['numbersignsmall'] = 0xFE5F;
+        t['numeralsigngreek'] = 0x0374;
+        t['numeralsignlowergreek'] = 0x0375;
+        t['numero'] = 0x2116;
+        t['nun'] = 0x05E0;
+        t['nundagesh'] = 0xFB40;
+        t['nundageshhebrew'] = 0xFB40;
+        t['nunhebrew'] = 0x05E0;
+        t['nvsquare'] = 0x33B5;
+        t['nwsquare'] = 0x33BB;
+        t['nyabengali'] = 0x099E;
+        t['nyadeva'] = 0x091E;
+        t['nyagujarati'] = 0x0A9E;
+        t['nyagurmukhi'] = 0x0A1E;
+        t['o'] = 0x006F;
+        t['oacute'] = 0x00F3;
+        t['oangthai'] = 0x0E2D;
+        t['obarred'] = 0x0275;
+        t['obarredcyrillic'] = 0x04E9;
+        t['obarreddieresiscyrillic'] = 0x04EB;
+        t['obengali'] = 0x0993;
+        t['obopomofo'] = 0x311B;
+        t['obreve'] = 0x014F;
+        t['ocandradeva'] = 0x0911;
+        t['ocandragujarati'] = 0x0A91;
+        t['ocandravowelsigndeva'] = 0x0949;
+        t['ocandravowelsigngujarati'] = 0x0AC9;
+        t['ocaron'] = 0x01D2;
+        t['ocircle'] = 0x24DE;
+        t['ocircumflex'] = 0x00F4;
+        t['ocircumflexacute'] = 0x1ED1;
+        t['ocircumflexdotbelow'] = 0x1ED9;
+        t['ocircumflexgrave'] = 0x1ED3;
+        t['ocircumflexhookabove'] = 0x1ED5;
+        t['ocircumflextilde'] = 0x1ED7;
+        t['ocyrillic'] = 0x043E;
+        t['odblacute'] = 0x0151;
+        t['odblgrave'] = 0x020D;
+        t['odeva'] = 0x0913;
+        t['odieresis'] = 0x00F6;
+        t['odieresiscyrillic'] = 0x04E7;
+        t['odotbelow'] = 0x1ECD;
+        t['oe'] = 0x0153;
+        t['oekorean'] = 0x315A;
+        t['ogonek'] = 0x02DB;
+        t['ogonekcmb'] = 0x0328;
+        t['ograve'] = 0x00F2;
+        t['ogujarati'] = 0x0A93;
+        t['oharmenian'] = 0x0585;
+        t['ohiragana'] = 0x304A;
+        t['ohookabove'] = 0x1ECF;
+        t['ohorn'] = 0x01A1;
+        t['ohornacute'] = 0x1EDB;
+        t['ohorndotbelow'] = 0x1EE3;
+        t['ohorngrave'] = 0x1EDD;
+        t['ohornhookabove'] = 0x1EDF;
+        t['ohorntilde'] = 0x1EE1;
+        t['ohungarumlaut'] = 0x0151;
+        t['oi'] = 0x01A3;
+        t['oinvertedbreve'] = 0x020F;
+        t['okatakana'] = 0x30AA;
+        t['okatakanahalfwidth'] = 0xFF75;
+        t['okorean'] = 0x3157;
+        t['olehebrew'] = 0x05AB;
+        t['omacron'] = 0x014D;
+        t['omacronacute'] = 0x1E53;
+        t['omacrongrave'] = 0x1E51;
+        t['omdeva'] = 0x0950;
+        t['omega'] = 0x03C9;
+        t['omega1'] = 0x03D6;
+        t['omegacyrillic'] = 0x0461;
+        t['omegalatinclosed'] = 0x0277;
+        t['omegaroundcyrillic'] = 0x047B;
+        t['omegatitlocyrillic'] = 0x047D;
+        t['omegatonos'] = 0x03CE;
+        t['omgujarati'] = 0x0AD0;
+        t['omicron'] = 0x03BF;
+        t['omicrontonos'] = 0x03CC;
+        t['omonospace'] = 0xFF4F;
+        t['one'] = 0x0031;
+        t['onearabic'] = 0x0661;
+        t['onebengali'] = 0x09E7;
+        t['onecircle'] = 0x2460;
+        t['onecircleinversesansserif'] = 0x278A;
+        t['onedeva'] = 0x0967;
+        t['onedotenleader'] = 0x2024;
+        t['oneeighth'] = 0x215B;
+        t['onefitted'] = 0xF6DC;
+        t['onegujarati'] = 0x0AE7;
+        t['onegurmukhi'] = 0x0A67;
+        t['onehackarabic'] = 0x0661;
+        t['onehalf'] = 0x00BD;
+        t['onehangzhou'] = 0x3021;
+        t['oneideographicparen'] = 0x3220;
+        t['oneinferior'] = 0x2081;
+        t['onemonospace'] = 0xFF11;
+        t['onenumeratorbengali'] = 0x09F4;
+        t['oneoldstyle'] = 0xF731;
+        t['oneparen'] = 0x2474;
+        t['oneperiod'] = 0x2488;
+        t['onepersian'] = 0x06F1;
+        t['onequarter'] = 0x00BC;
+        t['oneroman'] = 0x2170;
+        t['onesuperior'] = 0x00B9;
+        t['onethai'] = 0x0E51;
+        t['onethird'] = 0x2153;
+        t['oogonek'] = 0x01EB;
+        t['oogonekmacron'] = 0x01ED;
+        t['oogurmukhi'] = 0x0A13;
+        t['oomatragurmukhi'] = 0x0A4B;
+        t['oopen'] = 0x0254;
+        t['oparen'] = 0x24AA;
+        t['openbullet'] = 0x25E6;
+        t['option'] = 0x2325;
+        t['ordfeminine'] = 0x00AA;
+        t['ordmasculine'] = 0x00BA;
+        t['orthogonal'] = 0x221F;
+        t['oshortdeva'] = 0x0912;
+        t['oshortvowelsigndeva'] = 0x094A;
+        t['oslash'] = 0x00F8;
+        t['oslashacute'] = 0x01FF;
+        t['osmallhiragana'] = 0x3049;
+        t['osmallkatakana'] = 0x30A9;
+        t['osmallkatakanahalfwidth'] = 0xFF6B;
+        t['ostrokeacute'] = 0x01FF;
+        t['osuperior'] = 0xF6F0;
+        t['otcyrillic'] = 0x047F;
+        t['otilde'] = 0x00F5;
+        t['otildeacute'] = 0x1E4D;
+        t['otildedieresis'] = 0x1E4F;
+        t['oubopomofo'] = 0x3121;
+        t['overline'] = 0x203E;
+        t['overlinecenterline'] = 0xFE4A;
+        t['overlinecmb'] = 0x0305;
+        t['overlinedashed'] = 0xFE49;
+        t['overlinedblwavy'] = 0xFE4C;
+        t['overlinewavy'] = 0xFE4B;
+        t['overscore'] = 0x00AF;
+        t['ovowelsignbengali'] = 0x09CB;
+        t['ovowelsigndeva'] = 0x094B;
+        t['ovowelsigngujarati'] = 0x0ACB;
+        t['p'] = 0x0070;
+        t['paampssquare'] = 0x3380;
+        t['paasentosquare'] = 0x332B;
+        t['pabengali'] = 0x09AA;
+        t['pacute'] = 0x1E55;
+        t['padeva'] = 0x092A;
+        t['pagedown'] = 0x21DF;
+        t['pageup'] = 0x21DE;
+        t['pagujarati'] = 0x0AAA;
+        t['pagurmukhi'] = 0x0A2A;
+        t['pahiragana'] = 0x3071;
+        t['paiyannoithai'] = 0x0E2F;
+        t['pakatakana'] = 0x30D1;
+        t['palatalizationcyrilliccmb'] = 0x0484;
+        t['palochkacyrillic'] = 0x04C0;
+        t['pansioskorean'] = 0x317F;
+        t['paragraph'] = 0x00B6;
+        t['parallel'] = 0x2225;
+        t['parenleft'] = 0x0028;
+        t['parenleftaltonearabic'] = 0xFD3E;
+        t['parenleftbt'] = 0xF8ED;
+        t['parenleftex'] = 0xF8EC;
+        t['parenleftinferior'] = 0x208D;
+        t['parenleftmonospace'] = 0xFF08;
+        t['parenleftsmall'] = 0xFE59;
+        t['parenleftsuperior'] = 0x207D;
+        t['parenlefttp'] = 0xF8EB;
+        t['parenleftvertical'] = 0xFE35;
+        t['parenright'] = 0x0029;
+        t['parenrightaltonearabic'] = 0xFD3F;
+        t['parenrightbt'] = 0xF8F8;
+        t['parenrightex'] = 0xF8F7;
+        t['parenrightinferior'] = 0x208E;
+        t['parenrightmonospace'] = 0xFF09;
+        t['parenrightsmall'] = 0xFE5A;
+        t['parenrightsuperior'] = 0x207E;
+        t['parenrighttp'] = 0xF8F6;
+        t['parenrightvertical'] = 0xFE36;
+        t['partialdiff'] = 0x2202;
+        t['paseqhebrew'] = 0x05C0;
+        t['pashtahebrew'] = 0x0599;
+        t['pasquare'] = 0x33A9;
+        t['patah'] = 0x05B7;
+        t['patah11'] = 0x05B7;
+        t['patah1d'] = 0x05B7;
+        t['patah2a'] = 0x05B7;
+        t['patahhebrew'] = 0x05B7;
+        t['patahnarrowhebrew'] = 0x05B7;
+        t['patahquarterhebrew'] = 0x05B7;
+        t['patahwidehebrew'] = 0x05B7;
+        t['pazerhebrew'] = 0x05A1;
+        t['pbopomofo'] = 0x3106;
+        t['pcircle'] = 0x24DF;
+        t['pdotaccent'] = 0x1E57;
+        t['pe'] = 0x05E4;
+        t['pecyrillic'] = 0x043F;
+        t['pedagesh'] = 0xFB44;
+        t['pedageshhebrew'] = 0xFB44;
+        t['peezisquare'] = 0x333B;
+        t['pefinaldageshhebrew'] = 0xFB43;
+        t['peharabic'] = 0x067E;
+        t['peharmenian'] = 0x057A;
+        t['pehebrew'] = 0x05E4;
+        t['pehfinalarabic'] = 0xFB57;
+        t['pehinitialarabic'] = 0xFB58;
+        t['pehiragana'] = 0x307A;
+        t['pehmedialarabic'] = 0xFB59;
+        t['pekatakana'] = 0x30DA;
+        t['pemiddlehookcyrillic'] = 0x04A7;
+        t['perafehebrew'] = 0xFB4E;
+        t['percent'] = 0x0025;
+        t['percentarabic'] = 0x066A;
+        t['percentmonospace'] = 0xFF05;
+        t['percentsmall'] = 0xFE6A;
+        t['period'] = 0x002E;
+        t['periodarmenian'] = 0x0589;
+        t['periodcentered'] = 0x00B7;
+        t['periodhalfwidth'] = 0xFF61;
+        t['periodinferior'] = 0xF6E7;
+        t['periodmonospace'] = 0xFF0E;
+        t['periodsmall'] = 0xFE52;
+        t['periodsuperior'] = 0xF6E8;
+        t['perispomenigreekcmb'] = 0x0342;
+        t['perpendicular'] = 0x22A5;
+        t['perthousand'] = 0x2030;
+        t['peseta'] = 0x20A7;
+        t['pfsquare'] = 0x338A;
+        t['phabengali'] = 0x09AB;
+        t['phadeva'] = 0x092B;
+        t['phagujarati'] = 0x0AAB;
+        t['phagurmukhi'] = 0x0A2B;
+        t['phi'] = 0x03C6;
+        t['phi1'] = 0x03D5;
+        t['phieuphacirclekorean'] = 0x327A;
+        t['phieuphaparenkorean'] = 0x321A;
+        t['phieuphcirclekorean'] = 0x326C;
+        t['phieuphkorean'] = 0x314D;
+        t['phieuphparenkorean'] = 0x320C;
+        t['philatin'] = 0x0278;
+        t['phinthuthai'] = 0x0E3A;
+        t['phisymbolgreek'] = 0x03D5;
+        t['phook'] = 0x01A5;
+        t['phophanthai'] = 0x0E1E;
+        t['phophungthai'] = 0x0E1C;
+        t['phosamphaothai'] = 0x0E20;
+        t['pi'] = 0x03C0;
+        t['pieupacirclekorean'] = 0x3273;
+        t['pieupaparenkorean'] = 0x3213;
+        t['pieupcieuckorean'] = 0x3176;
+        t['pieupcirclekorean'] = 0x3265;
+        t['pieupkiyeokkorean'] = 0x3172;
+        t['pieupkorean'] = 0x3142;
+        t['pieupparenkorean'] = 0x3205;
+        t['pieupsioskiyeokkorean'] = 0x3174;
+        t['pieupsioskorean'] = 0x3144;
+        t['pieupsiostikeutkorean'] = 0x3175;
+        t['pieupthieuthkorean'] = 0x3177;
+        t['pieuptikeutkorean'] = 0x3173;
+        t['pihiragana'] = 0x3074;
+        t['pikatakana'] = 0x30D4;
+        t['pisymbolgreek'] = 0x03D6;
+        t['piwrarmenian'] = 0x0583;
+        t['plus'] = 0x002B;
+        t['plusbelowcmb'] = 0x031F;
+        t['pluscircle'] = 0x2295;
+        t['plusminus'] = 0x00B1;
+        t['plusmod'] = 0x02D6;
+        t['plusmonospace'] = 0xFF0B;
+        t['plussmall'] = 0xFE62;
+        t['plussuperior'] = 0x207A;
+        t['pmonospace'] = 0xFF50;
+        t['pmsquare'] = 0x33D8;
+        t['pohiragana'] = 0x307D;
+        t['pointingindexdownwhite'] = 0x261F;
+        t['pointingindexleftwhite'] = 0x261C;
+        t['pointingindexrightwhite'] = 0x261E;
+        t['pointingindexupwhite'] = 0x261D;
+        t['pokatakana'] = 0x30DD;
+        t['poplathai'] = 0x0E1B;
+        t['postalmark'] = 0x3012;
+        t['postalmarkface'] = 0x3020;
+        t['pparen'] = 0x24AB;
+        t['precedes'] = 0x227A;
+        t['prescription'] = 0x211E;
+        t['primemod'] = 0x02B9;
+        t['primereversed'] = 0x2035;
+        t['product'] = 0x220F;
+        t['projective'] = 0x2305;
+        t['prolongedkana'] = 0x30FC;
+        t['propellor'] = 0x2318;
+        t['propersubset'] = 0x2282;
+        t['propersuperset'] = 0x2283;
+        t['proportion'] = 0x2237;
+        t['proportional'] = 0x221D;
+        t['psi'] = 0x03C8;
+        t['psicyrillic'] = 0x0471;
+        t['psilipneumatacyrilliccmb'] = 0x0486;
+        t['pssquare'] = 0x33B0;
+        t['puhiragana'] = 0x3077;
+        t['pukatakana'] = 0x30D7;
+        t['pvsquare'] = 0x33B4;
+        t['pwsquare'] = 0x33BA;
+        t['q'] = 0x0071;
+        t['qadeva'] = 0x0958;
+        t['qadmahebrew'] = 0x05A8;
+        t['qafarabic'] = 0x0642;
+        t['qaffinalarabic'] = 0xFED6;
+        t['qafinitialarabic'] = 0xFED7;
+        t['qafmedialarabic'] = 0xFED8;
+        t['qamats'] = 0x05B8;
+        t['qamats10'] = 0x05B8;
+        t['qamats1a'] = 0x05B8;
+        t['qamats1c'] = 0x05B8;
+        t['qamats27'] = 0x05B8;
+        t['qamats29'] = 0x05B8;
+        t['qamats33'] = 0x05B8;
+        t['qamatsde'] = 0x05B8;
+        t['qamatshebrew'] = 0x05B8;
+        t['qamatsnarrowhebrew'] = 0x05B8;
+        t['qamatsqatanhebrew'] = 0x05B8;
+        t['qamatsqatannarrowhebrew'] = 0x05B8;
+        t['qamatsqatanquarterhebrew'] = 0x05B8;
+        t['qamatsqatanwidehebrew'] = 0x05B8;
+        t['qamatsquarterhebrew'] = 0x05B8;
+        t['qamatswidehebrew'] = 0x05B8;
+        t['qarneyparahebrew'] = 0x059F;
+        t['qbopomofo'] = 0x3111;
+        t['qcircle'] = 0x24E0;
+        t['qhook'] = 0x02A0;
+        t['qmonospace'] = 0xFF51;
+        t['qof'] = 0x05E7;
+        t['qofdagesh'] = 0xFB47;
+        t['qofdageshhebrew'] = 0xFB47;
+        t['qofhebrew'] = 0x05E7;
+        t['qparen'] = 0x24AC;
+        t['quarternote'] = 0x2669;
+        t['qubuts'] = 0x05BB;
+        t['qubuts18'] = 0x05BB;
+        t['qubuts25'] = 0x05BB;
+        t['qubuts31'] = 0x05BB;
+        t['qubutshebrew'] = 0x05BB;
+        t['qubutsnarrowhebrew'] = 0x05BB;
+        t['qubutsquarterhebrew'] = 0x05BB;
+        t['qubutswidehebrew'] = 0x05BB;
+        t['question'] = 0x003F;
+        t['questionarabic'] = 0x061F;
+        t['questionarmenian'] = 0x055E;
+        t['questiondown'] = 0x00BF;
+        t['questiondownsmall'] = 0xF7BF;
+        t['questiongreek'] = 0x037E;
+        t['questionmonospace'] = 0xFF1F;
+        t['questionsmall'] = 0xF73F;
+        t['quotedbl'] = 0x0022;
+        t['quotedblbase'] = 0x201E;
+        t['quotedblleft'] = 0x201C;
+        t['quotedblmonospace'] = 0xFF02;
+        t['quotedblprime'] = 0x301E;
+        t['quotedblprimereversed'] = 0x301D;
+        t['quotedblright'] = 0x201D;
+        t['quoteleft'] = 0x2018;
+        t['quoteleftreversed'] = 0x201B;
+        t['quotereversed'] = 0x201B;
+        t['quoteright'] = 0x2019;
+        t['quoterightn'] = 0x0149;
+        t['quotesinglbase'] = 0x201A;
+        t['quotesingle'] = 0x0027;
+        t['quotesinglemonospace'] = 0xFF07;
+        t['r'] = 0x0072;
+        t['raarmenian'] = 0x057C;
+        t['rabengali'] = 0x09B0;
+        t['racute'] = 0x0155;
+        t['radeva'] = 0x0930;
+        t['radical'] = 0x221A;
+        t['radicalex'] = 0xF8E5;
+        t['radoverssquare'] = 0x33AE;
+        t['radoverssquaredsquare'] = 0x33AF;
+        t['radsquare'] = 0x33AD;
+        t['rafe'] = 0x05BF;
+        t['rafehebrew'] = 0x05BF;
+        t['ragujarati'] = 0x0AB0;
+        t['ragurmukhi'] = 0x0A30;
+        t['rahiragana'] = 0x3089;
+        t['rakatakana'] = 0x30E9;
+        t['rakatakanahalfwidth'] = 0xFF97;
+        t['ralowerdiagonalbengali'] = 0x09F1;
+        t['ramiddlediagonalbengali'] = 0x09F0;
+        t['ramshorn'] = 0x0264;
+        t['ratio'] = 0x2236;
+        t['rbopomofo'] = 0x3116;
+        t['rcaron'] = 0x0159;
+        t['rcedilla'] = 0x0157;
+        t['rcircle'] = 0x24E1;
+        t['rcommaaccent'] = 0x0157;
+        t['rdblgrave'] = 0x0211;
+        t['rdotaccent'] = 0x1E59;
+        t['rdotbelow'] = 0x1E5B;
+        t['rdotbelowmacron'] = 0x1E5D;
+        t['referencemark'] = 0x203B;
+        t['reflexsubset'] = 0x2286;
+        t['reflexsuperset'] = 0x2287;
+        t['registered'] = 0x00AE;
+        t['registersans'] = 0xF8E8;
+        t['registerserif'] = 0xF6DA;
+        t['reharabic'] = 0x0631;
+        t['reharmenian'] = 0x0580;
+        t['rehfinalarabic'] = 0xFEAE;
+        t['rehiragana'] = 0x308C;
+        t['rekatakana'] = 0x30EC;
+        t['rekatakanahalfwidth'] = 0xFF9A;
+        t['resh'] = 0x05E8;
+        t['reshdageshhebrew'] = 0xFB48;
+        t['reshhebrew'] = 0x05E8;
+        t['reversedtilde'] = 0x223D;
+        t['reviahebrew'] = 0x0597;
+        t['reviamugrashhebrew'] = 0x0597;
+        t['revlogicalnot'] = 0x2310;
+        t['rfishhook'] = 0x027E;
+        t['rfishhookreversed'] = 0x027F;
+        t['rhabengali'] = 0x09DD;
+        t['rhadeva'] = 0x095D;
+        t['rho'] = 0x03C1;
+        t['rhook'] = 0x027D;
+        t['rhookturned'] = 0x027B;
+        t['rhookturnedsuperior'] = 0x02B5;
+        t['rhosymbolgreek'] = 0x03F1;
+        t['rhotichookmod'] = 0x02DE;
+        t['rieulacirclekorean'] = 0x3271;
+        t['rieulaparenkorean'] = 0x3211;
+        t['rieulcirclekorean'] = 0x3263;
+        t['rieulhieuhkorean'] = 0x3140;
+        t['rieulkiyeokkorean'] = 0x313A;
+        t['rieulkiyeoksioskorean'] = 0x3169;
+        t['rieulkorean'] = 0x3139;
+        t['rieulmieumkorean'] = 0x313B;
+        t['rieulpansioskorean'] = 0x316C;
+        t['rieulparenkorean'] = 0x3203;
+        t['rieulphieuphkorean'] = 0x313F;
+        t['rieulpieupkorean'] = 0x313C;
+        t['rieulpieupsioskorean'] = 0x316B;
+        t['rieulsioskorean'] = 0x313D;
+        t['rieulthieuthkorean'] = 0x313E;
+        t['rieultikeutkorean'] = 0x316A;
+        t['rieulyeorinhieuhkorean'] = 0x316D;
+        t['rightangle'] = 0x221F;
+        t['righttackbelowcmb'] = 0x0319;
+        t['righttriangle'] = 0x22BF;
+        t['rihiragana'] = 0x308A;
+        t['rikatakana'] = 0x30EA;
+        t['rikatakanahalfwidth'] = 0xFF98;
+        t['ring'] = 0x02DA;
+        t['ringbelowcmb'] = 0x0325;
+        t['ringcmb'] = 0x030A;
+        t['ringhalfleft'] = 0x02BF;
+        t['ringhalfleftarmenian'] = 0x0559;
+        t['ringhalfleftbelowcmb'] = 0x031C;
+        t['ringhalfleftcentered'] = 0x02D3;
+        t['ringhalfright'] = 0x02BE;
+        t['ringhalfrightbelowcmb'] = 0x0339;
+        t['ringhalfrightcentered'] = 0x02D2;
+        t['rinvertedbreve'] = 0x0213;
+        t['rittorusquare'] = 0x3351;
+        t['rlinebelow'] = 0x1E5F;
+        t['rlongleg'] = 0x027C;
+        t['rlonglegturned'] = 0x027A;
+        t['rmonospace'] = 0xFF52;
+        t['rohiragana'] = 0x308D;
+        t['rokatakana'] = 0x30ED;
+        t['rokatakanahalfwidth'] = 0xFF9B;
+        t['roruathai'] = 0x0E23;
+        t['rparen'] = 0x24AD;
+        t['rrabengali'] = 0x09DC;
+        t['rradeva'] = 0x0931;
+        t['rragurmukhi'] = 0x0A5C;
+        t['rreharabic'] = 0x0691;
+        t['rrehfinalarabic'] = 0xFB8D;
+        t['rrvocalicbengali'] = 0x09E0;
+        t['rrvocalicdeva'] = 0x0960;
+        t['rrvocalicgujarati'] = 0x0AE0;
+        t['rrvocalicvowelsignbengali'] = 0x09C4;
+        t['rrvocalicvowelsigndeva'] = 0x0944;
+        t['rrvocalicvowelsigngujarati'] = 0x0AC4;
+        t['rsuperior'] = 0xF6F1;
+        t['rtblock'] = 0x2590;
+        t['rturned'] = 0x0279;
+        t['rturnedsuperior'] = 0x02B4;
+        t['ruhiragana'] = 0x308B;
+        t['rukatakana'] = 0x30EB;
+        t['rukatakanahalfwidth'] = 0xFF99;
+        t['rupeemarkbengali'] = 0x09F2;
+        t['rupeesignbengali'] = 0x09F3;
+        t['rupiah'] = 0xF6DD;
+        t['ruthai'] = 0x0E24;
+        t['rvocalicbengali'] = 0x098B;
+        t['rvocalicdeva'] = 0x090B;
+        t['rvocalicgujarati'] = 0x0A8B;
+        t['rvocalicvowelsignbengali'] = 0x09C3;
+        t['rvocalicvowelsigndeva'] = 0x0943;
+        t['rvocalicvowelsigngujarati'] = 0x0AC3;
+        t['s'] = 0x0073;
+        t['sabengali'] = 0x09B8;
+        t['sacute'] = 0x015B;
+        t['sacutedotaccent'] = 0x1E65;
+        t['sadarabic'] = 0x0635;
+        t['sadeva'] = 0x0938;
+        t['sadfinalarabic'] = 0xFEBA;
+        t['sadinitialarabic'] = 0xFEBB;
+        t['sadmedialarabic'] = 0xFEBC;
+        t['sagujarati'] = 0x0AB8;
+        t['sagurmukhi'] = 0x0A38;
+        t['sahiragana'] = 0x3055;
+        t['sakatakana'] = 0x30B5;
+        t['sakatakanahalfwidth'] = 0xFF7B;
+        t['sallallahoualayhewasallamarabic'] = 0xFDFA;
+        t['samekh'] = 0x05E1;
+        t['samekhdagesh'] = 0xFB41;
+        t['samekhdageshhebrew'] = 0xFB41;
+        t['samekhhebrew'] = 0x05E1;
+        t['saraaathai'] = 0x0E32;
+        t['saraaethai'] = 0x0E41;
+        t['saraaimaimalaithai'] = 0x0E44;
+        t['saraaimaimuanthai'] = 0x0E43;
+        t['saraamthai'] = 0x0E33;
+        t['saraathai'] = 0x0E30;
+        t['saraethai'] = 0x0E40;
+        t['saraiileftthai'] = 0xF886;
+        t['saraiithai'] = 0x0E35;
+        t['saraileftthai'] = 0xF885;
+        t['saraithai'] = 0x0E34;
+        t['saraothai'] = 0x0E42;
+        t['saraueeleftthai'] = 0xF888;
+        t['saraueethai'] = 0x0E37;
+        t['saraueleftthai'] = 0xF887;
+        t['sarauethai'] = 0x0E36;
+        t['sarauthai'] = 0x0E38;
+        t['sarauuthai'] = 0x0E39;
+        t['sbopomofo'] = 0x3119;
+        t['scaron'] = 0x0161;
+        t['scarondotaccent'] = 0x1E67;
+        t['scedilla'] = 0x015F;
+        t['schwa'] = 0x0259;
+        t['schwacyrillic'] = 0x04D9;
+        t['schwadieresiscyrillic'] = 0x04DB;
+        t['schwahook'] = 0x025A;
+        t['scircle'] = 0x24E2;
+        t['scircumflex'] = 0x015D;
+        t['scommaaccent'] = 0x0219;
+        t['sdotaccent'] = 0x1E61;
+        t['sdotbelow'] = 0x1E63;
+        t['sdotbelowdotaccent'] = 0x1E69;
+        t['seagullbelowcmb'] = 0x033C;
+        t['second'] = 0x2033;
+        t['secondtonechinese'] = 0x02CA;
+        t['section'] = 0x00A7;
+        t['seenarabic'] = 0x0633;
+        t['seenfinalarabic'] = 0xFEB2;
+        t['seeninitialarabic'] = 0xFEB3;
+        t['seenmedialarabic'] = 0xFEB4;
+        t['segol'] = 0x05B6;
+        t['segol13'] = 0x05B6;
+        t['segol1f'] = 0x05B6;
+        t['segol2c'] = 0x05B6;
+        t['segolhebrew'] = 0x05B6;
+        t['segolnarrowhebrew'] = 0x05B6;
+        t['segolquarterhebrew'] = 0x05B6;
+        t['segoltahebrew'] = 0x0592;
+        t['segolwidehebrew'] = 0x05B6;
+        t['seharmenian'] = 0x057D;
+        t['sehiragana'] = 0x305B;
+        t['sekatakana'] = 0x30BB;
+        t['sekatakanahalfwidth'] = 0xFF7E;
+        t['semicolon'] = 0x003B;
+        t['semicolonarabic'] = 0x061B;
+        t['semicolonmonospace'] = 0xFF1B;
+        t['semicolonsmall'] = 0xFE54;
+        t['semivoicedmarkkana'] = 0x309C;
+        t['semivoicedmarkkanahalfwidth'] = 0xFF9F;
+        t['sentisquare'] = 0x3322;
+        t['sentosquare'] = 0x3323;
+        t['seven'] = 0x0037;
+        t['sevenarabic'] = 0x0667;
+        t['sevenbengali'] = 0x09ED;
+        t['sevencircle'] = 0x2466;
+        t['sevencircleinversesansserif'] = 0x2790;
+        t['sevendeva'] = 0x096D;
+        t['seveneighths'] = 0x215E;
+        t['sevengujarati'] = 0x0AED;
+        t['sevengurmukhi'] = 0x0A6D;
+        t['sevenhackarabic'] = 0x0667;
+        t['sevenhangzhou'] = 0x3027;
+        t['sevenideographicparen'] = 0x3226;
+        t['seveninferior'] = 0x2087;
+        t['sevenmonospace'] = 0xFF17;
+        t['sevenoldstyle'] = 0xF737;
+        t['sevenparen'] = 0x247A;
+        t['sevenperiod'] = 0x248E;
+        t['sevenpersian'] = 0x06F7;
+        t['sevenroman'] = 0x2176;
+        t['sevensuperior'] = 0x2077;
+        t['seventeencircle'] = 0x2470;
+        t['seventeenparen'] = 0x2484;
+        t['seventeenperiod'] = 0x2498;
+        t['seventhai'] = 0x0E57;
+        t['sfthyphen'] = 0x00AD;
+        t['shaarmenian'] = 0x0577;
+        t['shabengali'] = 0x09B6;
+        t['shacyrillic'] = 0x0448;
+        t['shaddaarabic'] = 0x0651;
+        t['shaddadammaarabic'] = 0xFC61;
+        t['shaddadammatanarabic'] = 0xFC5E;
+        t['shaddafathaarabic'] = 0xFC60;
+        t['shaddakasraarabic'] = 0xFC62;
+        t['shaddakasratanarabic'] = 0xFC5F;
+        t['shade'] = 0x2592;
+        t['shadedark'] = 0x2593;
+        t['shadelight'] = 0x2591;
+        t['shademedium'] = 0x2592;
+        t['shadeva'] = 0x0936;
+        t['shagujarati'] = 0x0AB6;
+        t['shagurmukhi'] = 0x0A36;
+        t['shalshelethebrew'] = 0x0593;
+        t['shbopomofo'] = 0x3115;
+        t['shchacyrillic'] = 0x0449;
+        t['sheenarabic'] = 0x0634;
+        t['sheenfinalarabic'] = 0xFEB6;
+        t['sheeninitialarabic'] = 0xFEB7;
+        t['sheenmedialarabic'] = 0xFEB8;
+        t['sheicoptic'] = 0x03E3;
+        t['sheqel'] = 0x20AA;
+        t['sheqelhebrew'] = 0x20AA;
+        t['sheva'] = 0x05B0;
+        t['sheva115'] = 0x05B0;
+        t['sheva15'] = 0x05B0;
+        t['sheva22'] = 0x05B0;
+        t['sheva2e'] = 0x05B0;
+        t['shevahebrew'] = 0x05B0;
+        t['shevanarrowhebrew'] = 0x05B0;
+        t['shevaquarterhebrew'] = 0x05B0;
+        t['shevawidehebrew'] = 0x05B0;
+        t['shhacyrillic'] = 0x04BB;
+        t['shimacoptic'] = 0x03ED;
+        t['shin'] = 0x05E9;
+        t['shindagesh'] = 0xFB49;
+        t['shindageshhebrew'] = 0xFB49;
+        t['shindageshshindot'] = 0xFB2C;
+        t['shindageshshindothebrew'] = 0xFB2C;
+        t['shindageshsindot'] = 0xFB2D;
+        t['shindageshsindothebrew'] = 0xFB2D;
+        t['shindothebrew'] = 0x05C1;
+        t['shinhebrew'] = 0x05E9;
+        t['shinshindot'] = 0xFB2A;
+        t['shinshindothebrew'] = 0xFB2A;
+        t['shinsindot'] = 0xFB2B;
+        t['shinsindothebrew'] = 0xFB2B;
+        t['shook'] = 0x0282;
+        t['sigma'] = 0x03C3;
+        t['sigma1'] = 0x03C2;
+        t['sigmafinal'] = 0x03C2;
+        t['sigmalunatesymbolgreek'] = 0x03F2;
+        t['sihiragana'] = 0x3057;
+        t['sikatakana'] = 0x30B7;
+        t['sikatakanahalfwidth'] = 0xFF7C;
+        t['siluqhebrew'] = 0x05BD;
+        t['siluqlefthebrew'] = 0x05BD;
+        t['similar'] = 0x223C;
+        t['sindothebrew'] = 0x05C2;
+        t['siosacirclekorean'] = 0x3274;
+        t['siosaparenkorean'] = 0x3214;
+        t['sioscieuckorean'] = 0x317E;
+        t['sioscirclekorean'] = 0x3266;
+        t['sioskiyeokkorean'] = 0x317A;
+        t['sioskorean'] = 0x3145;
+        t['siosnieunkorean'] = 0x317B;
+        t['siosparenkorean'] = 0x3206;
+        t['siospieupkorean'] = 0x317D;
+        t['siostikeutkorean'] = 0x317C;
+        t['six'] = 0x0036;
+        t['sixarabic'] = 0x0666;
+        t['sixbengali'] = 0x09EC;
+        t['sixcircle'] = 0x2465;
+        t['sixcircleinversesansserif'] = 0x278F;
+        t['sixdeva'] = 0x096C;
+        t['sixgujarati'] = 0x0AEC;
+        t['sixgurmukhi'] = 0x0A6C;
+        t['sixhackarabic'] = 0x0666;
+        t['sixhangzhou'] = 0x3026;
+        t['sixideographicparen'] = 0x3225;
+        t['sixinferior'] = 0x2086;
+        t['sixmonospace'] = 0xFF16;
+        t['sixoldstyle'] = 0xF736;
+        t['sixparen'] = 0x2479;
+        t['sixperiod'] = 0x248D;
+        t['sixpersian'] = 0x06F6;
+        t['sixroman'] = 0x2175;
+        t['sixsuperior'] = 0x2076;
+        t['sixteencircle'] = 0x246F;
+        t['sixteencurrencydenominatorbengali'] = 0x09F9;
+        t['sixteenparen'] = 0x2483;
+        t['sixteenperiod'] = 0x2497;
+        t['sixthai'] = 0x0E56;
+        t['slash'] = 0x002F;
+        t['slashmonospace'] = 0xFF0F;
+        t['slong'] = 0x017F;
+        t['slongdotaccent'] = 0x1E9B;
+        t['smileface'] = 0x263A;
+        t['smonospace'] = 0xFF53;
+        t['sofpasuqhebrew'] = 0x05C3;
+        t['softhyphen'] = 0x00AD;
+        t['softsigncyrillic'] = 0x044C;
+        t['sohiragana'] = 0x305D;
+        t['sokatakana'] = 0x30BD;
+        t['sokatakanahalfwidth'] = 0xFF7F;
+        t['soliduslongoverlaycmb'] = 0x0338;
+        t['solidusshortoverlaycmb'] = 0x0337;
+        t['sorusithai'] = 0x0E29;
+        t['sosalathai'] = 0x0E28;
+        t['sosothai'] = 0x0E0B;
+        t['sosuathai'] = 0x0E2A;
+        t['space'] = 0x0020;
+        t['spacehackarabic'] = 0x0020;
+        t['spade'] = 0x2660;
+        t['spadesuitblack'] = 0x2660;
+        t['spadesuitwhite'] = 0x2664;
+        t['sparen'] = 0x24AE;
+        t['squarebelowcmb'] = 0x033B;
+        t['squarecc'] = 0x33C4;
+        t['squarecm'] = 0x339D;
+        t['squarediagonalcrosshatchfill'] = 0x25A9;
+        t['squarehorizontalfill'] = 0x25A4;
+        t['squarekg'] = 0x338F;
+        t['squarekm'] = 0x339E;
+        t['squarekmcapital'] = 0x33CE;
+        t['squareln'] = 0x33D1;
+        t['squarelog'] = 0x33D2;
+        t['squaremg'] = 0x338E;
+        t['squaremil'] = 0x33D5;
+        t['squaremm'] = 0x339C;
+        t['squaremsquared'] = 0x33A1;
+        t['squareorthogonalcrosshatchfill'] = 0x25A6;
+        t['squareupperlefttolowerrightfill'] = 0x25A7;
+        t['squareupperrighttolowerleftfill'] = 0x25A8;
+        t['squareverticalfill'] = 0x25A5;
+        t['squarewhitewithsmallblack'] = 0x25A3;
+        t['srsquare'] = 0x33DB;
+        t['ssabengali'] = 0x09B7;
+        t['ssadeva'] = 0x0937;
+        t['ssagujarati'] = 0x0AB7;
+        t['ssangcieuckorean'] = 0x3149;
+        t['ssanghieuhkorean'] = 0x3185;
+        t['ssangieungkorean'] = 0x3180;
+        t['ssangkiyeokkorean'] = 0x3132;
+        t['ssangnieunkorean'] = 0x3165;
+        t['ssangpieupkorean'] = 0x3143;
+        t['ssangsioskorean'] = 0x3146;
+        t['ssangtikeutkorean'] = 0x3138;
+        t['ssuperior'] = 0xF6F2;
+        t['sterling'] = 0x00A3;
+        t['sterlingmonospace'] = 0xFFE1;
+        t['strokelongoverlaycmb'] = 0x0336;
+        t['strokeshortoverlaycmb'] = 0x0335;
+        t['subset'] = 0x2282;
+        t['subsetnotequal'] = 0x228A;
+        t['subsetorequal'] = 0x2286;
+        t['succeeds'] = 0x227B;
+        t['suchthat'] = 0x220B;
+        t['suhiragana'] = 0x3059;
+        t['sukatakana'] = 0x30B9;
+        t['sukatakanahalfwidth'] = 0xFF7D;
+        t['sukunarabic'] = 0x0652;
+        t['summation'] = 0x2211;
+        t['sun'] = 0x263C;
+        t['superset'] = 0x2283;
+        t['supersetnotequal'] = 0x228B;
+        t['supersetorequal'] = 0x2287;
+        t['svsquare'] = 0x33DC;
+        t['syouwaerasquare'] = 0x337C;
+        t['t'] = 0x0074;
+        t['tabengali'] = 0x09A4;
+        t['tackdown'] = 0x22A4;
+        t['tackleft'] = 0x22A3;
+        t['tadeva'] = 0x0924;
+        t['tagujarati'] = 0x0AA4;
+        t['tagurmukhi'] = 0x0A24;
+        t['taharabic'] = 0x0637;
+        t['tahfinalarabic'] = 0xFEC2;
+        t['tahinitialarabic'] = 0xFEC3;
+        t['tahiragana'] = 0x305F;
+        t['tahmedialarabic'] = 0xFEC4;
+        t['taisyouerasquare'] = 0x337D;
+        t['takatakana'] = 0x30BF;
+        t['takatakanahalfwidth'] = 0xFF80;
+        t['tatweelarabic'] = 0x0640;
+        t['tau'] = 0x03C4;
+        t['tav'] = 0x05EA;
+        t['tavdages'] = 0xFB4A;
+        t['tavdagesh'] = 0xFB4A;
+        t['tavdageshhebrew'] = 0xFB4A;
+        t['tavhebrew'] = 0x05EA;
+        t['tbar'] = 0x0167;
+        t['tbopomofo'] = 0x310A;
+        t['tcaron'] = 0x0165;
+        t['tccurl'] = 0x02A8;
+        t['tcedilla'] = 0x0163;
+        t['tcheharabic'] = 0x0686;
+        t['tchehfinalarabic'] = 0xFB7B;
+        t['tchehinitialarabic'] = 0xFB7C;
+        t['tchehmedialarabic'] = 0xFB7D;
+        t['tcircle'] = 0x24E3;
+        t['tcircumflexbelow'] = 0x1E71;
+        t['tcommaaccent'] = 0x0163;
+        t['tdieresis'] = 0x1E97;
+        t['tdotaccent'] = 0x1E6B;
+        t['tdotbelow'] = 0x1E6D;
+        t['tecyrillic'] = 0x0442;
+        t['tedescendercyrillic'] = 0x04AD;
+        t['teharabic'] = 0x062A;
+        t['tehfinalarabic'] = 0xFE96;
+        t['tehhahinitialarabic'] = 0xFCA2;
+        t['tehhahisolatedarabic'] = 0xFC0C;
+        t['tehinitialarabic'] = 0xFE97;
+        t['tehiragana'] = 0x3066;
+        t['tehjeeminitialarabic'] = 0xFCA1;
+        t['tehjeemisolatedarabic'] = 0xFC0B;
+        t['tehmarbutaarabic'] = 0x0629;
+        t['tehmarbutafinalarabic'] = 0xFE94;
+        t['tehmedialarabic'] = 0xFE98;
+        t['tehmeeminitialarabic'] = 0xFCA4;
+        t['tehmeemisolatedarabic'] = 0xFC0E;
+        t['tehnoonfinalarabic'] = 0xFC73;
+        t['tekatakana'] = 0x30C6;
+        t['tekatakanahalfwidth'] = 0xFF83;
+        t['telephone'] = 0x2121;
+        t['telephoneblack'] = 0x260E;
+        t['telishagedolahebrew'] = 0x05A0;
+        t['telishaqetanahebrew'] = 0x05A9;
+        t['tencircle'] = 0x2469;
+        t['tenideographicparen'] = 0x3229;
+        t['tenparen'] = 0x247D;
+        t['tenperiod'] = 0x2491;
+        t['tenroman'] = 0x2179;
+        t['tesh'] = 0x02A7;
+        t['tet'] = 0x05D8;
+        t['tetdagesh'] = 0xFB38;
+        t['tetdageshhebrew'] = 0xFB38;
+        t['tethebrew'] = 0x05D8;
+        t['tetsecyrillic'] = 0x04B5;
+        t['tevirhebrew'] = 0x059B;
+        t['tevirlefthebrew'] = 0x059B;
+        t['thabengali'] = 0x09A5;
+        t['thadeva'] = 0x0925;
+        t['thagujarati'] = 0x0AA5;
+        t['thagurmukhi'] = 0x0A25;
+        t['thalarabic'] = 0x0630;
+        t['thalfinalarabic'] = 0xFEAC;
+        t['thanthakhatlowleftthai'] = 0xF898;
+        t['thanthakhatlowrightthai'] = 0xF897;
+        t['thanthakhatthai'] = 0x0E4C;
+        t['thanthakhatupperleftthai'] = 0xF896;
+        t['theharabic'] = 0x062B;
+        t['thehfinalarabic'] = 0xFE9A;
+        t['thehinitialarabic'] = 0xFE9B;
+        t['thehmedialarabic'] = 0xFE9C;
+        t['thereexists'] = 0x2203;
+        t['therefore'] = 0x2234;
+        t['theta'] = 0x03B8;
+        t['theta1'] = 0x03D1;
+        t['thetasymbolgreek'] = 0x03D1;
+        t['thieuthacirclekorean'] = 0x3279;
+        t['thieuthaparenkorean'] = 0x3219;
+        t['thieuthcirclekorean'] = 0x326B;
+        t['thieuthkorean'] = 0x314C;
+        t['thieuthparenkorean'] = 0x320B;
+        t['thirteencircle'] = 0x246C;
+        t['thirteenparen'] = 0x2480;
+        t['thirteenperiod'] = 0x2494;
+        t['thonangmonthothai'] = 0x0E11;
+        t['thook'] = 0x01AD;
+        t['thophuthaothai'] = 0x0E12;
+        t['thorn'] = 0x00FE;
+        t['thothahanthai'] = 0x0E17;
+        t['thothanthai'] = 0x0E10;
+        t['thothongthai'] = 0x0E18;
+        t['thothungthai'] = 0x0E16;
+        t['thousandcyrillic'] = 0x0482;
+        t['thousandsseparatorarabic'] = 0x066C;
+        t['thousandsseparatorpersian'] = 0x066C;
+        t['three'] = 0x0033;
+        t['threearabic'] = 0x0663;
+        t['threebengali'] = 0x09E9;
+        t['threecircle'] = 0x2462;
+        t['threecircleinversesansserif'] = 0x278C;
+        t['threedeva'] = 0x0969;
+        t['threeeighths'] = 0x215C;
+        t['threegujarati'] = 0x0AE9;
+        t['threegurmukhi'] = 0x0A69;
+        t['threehackarabic'] = 0x0663;
+        t['threehangzhou'] = 0x3023;
+        t['threeideographicparen'] = 0x3222;
+        t['threeinferior'] = 0x2083;
+        t['threemonospace'] = 0xFF13;
+        t['threenumeratorbengali'] = 0x09F6;
+        t['threeoldstyle'] = 0xF733;
+        t['threeparen'] = 0x2476;
+        t['threeperiod'] = 0x248A;
+        t['threepersian'] = 0x06F3;
+        t['threequarters'] = 0x00BE;
+        t['threequartersemdash'] = 0xF6DE;
+        t['threeroman'] = 0x2172;
+        t['threesuperior'] = 0x00B3;
+        t['threethai'] = 0x0E53;
+        t['thzsquare'] = 0x3394;
+        t['tihiragana'] = 0x3061;
+        t['tikatakana'] = 0x30C1;
+        t['tikatakanahalfwidth'] = 0xFF81;
+        t['tikeutacirclekorean'] = 0x3270;
+        t['tikeutaparenkorean'] = 0x3210;
+        t['tikeutcirclekorean'] = 0x3262;
+        t['tikeutkorean'] = 0x3137;
+        t['tikeutparenkorean'] = 0x3202;
+        t['tilde'] = 0x02DC;
+        t['tildebelowcmb'] = 0x0330;
+        t['tildecmb'] = 0x0303;
+        t['tildecomb'] = 0x0303;
+        t['tildedoublecmb'] = 0x0360;
+        t['tildeoperator'] = 0x223C;
+        t['tildeoverlaycmb'] = 0x0334;
+        t['tildeverticalcmb'] = 0x033E;
+        t['timescircle'] = 0x2297;
+        t['tipehahebrew'] = 0x0596;
+        t['tipehalefthebrew'] = 0x0596;
+        t['tippigurmukhi'] = 0x0A70;
+        t['titlocyrilliccmb'] = 0x0483;
+        t['tiwnarmenian'] = 0x057F;
+        t['tlinebelow'] = 0x1E6F;
+        t['tmonospace'] = 0xFF54;
+        t['toarmenian'] = 0x0569;
+        t['tohiragana'] = 0x3068;
+        t['tokatakana'] = 0x30C8;
+        t['tokatakanahalfwidth'] = 0xFF84;
+        t['tonebarextrahighmod'] = 0x02E5;
+        t['tonebarextralowmod'] = 0x02E9;
+        t['tonebarhighmod'] = 0x02E6;
+        t['tonebarlowmod'] = 0x02E8;
+        t['tonebarmidmod'] = 0x02E7;
+        t['tonefive'] = 0x01BD;
+        t['tonesix'] = 0x0185;
+        t['tonetwo'] = 0x01A8;
+        t['tonos'] = 0x0384;
+        t['tonsquare'] = 0x3327;
+        t['topatakthai'] = 0x0E0F;
+        t['tortoiseshellbracketleft'] = 0x3014;
+        t['tortoiseshellbracketleftsmall'] = 0xFE5D;
+        t['tortoiseshellbracketleftvertical'] = 0xFE39;
+        t['tortoiseshellbracketright'] = 0x3015;
+        t['tortoiseshellbracketrightsmall'] = 0xFE5E;
+        t['tortoiseshellbracketrightvertical'] = 0xFE3A;
+        t['totaothai'] = 0x0E15;
+        t['tpalatalhook'] = 0x01AB;
+        t['tparen'] = 0x24AF;
+        t['trademark'] = 0x2122;
+        t['trademarksans'] = 0xF8EA;
+        t['trademarkserif'] = 0xF6DB;
+        t['tretroflexhook'] = 0x0288;
+        t['triagdn'] = 0x25BC;
+        t['triaglf'] = 0x25C4;
+        t['triagrt'] = 0x25BA;
+        t['triagup'] = 0x25B2;
+        t['ts'] = 0x02A6;
+        t['tsadi'] = 0x05E6;
+        t['tsadidagesh'] = 0xFB46;
+        t['tsadidageshhebrew'] = 0xFB46;
+        t['tsadihebrew'] = 0x05E6;
+        t['tsecyrillic'] = 0x0446;
+        t['tsere'] = 0x05B5;
+        t['tsere12'] = 0x05B5;
+        t['tsere1e'] = 0x05B5;
+        t['tsere2b'] = 0x05B5;
+        t['tserehebrew'] = 0x05B5;
+        t['tserenarrowhebrew'] = 0x05B5;
+        t['tserequarterhebrew'] = 0x05B5;
+        t['tserewidehebrew'] = 0x05B5;
+        t['tshecyrillic'] = 0x045B;
+        t['tsuperior'] = 0xF6F3;
+        t['ttabengali'] = 0x099F;
+        t['ttadeva'] = 0x091F;
+        t['ttagujarati'] = 0x0A9F;
+        t['ttagurmukhi'] = 0x0A1F;
+        t['tteharabic'] = 0x0679;
+        t['ttehfinalarabic'] = 0xFB67;
+        t['ttehinitialarabic'] = 0xFB68;
+        t['ttehmedialarabic'] = 0xFB69;
+        t['tthabengali'] = 0x09A0;
+        t['tthadeva'] = 0x0920;
+        t['tthagujarati'] = 0x0AA0;
+        t['tthagurmukhi'] = 0x0A20;
+        t['tturned'] = 0x0287;
+        t['tuhiragana'] = 0x3064;
+        t['tukatakana'] = 0x30C4;
+        t['tukatakanahalfwidth'] = 0xFF82;
+        t['tusmallhiragana'] = 0x3063;
+        t['tusmallkatakana'] = 0x30C3;
+        t['tusmallkatakanahalfwidth'] = 0xFF6F;
+        t['twelvecircle'] = 0x246B;
+        t['twelveparen'] = 0x247F;
+        t['twelveperiod'] = 0x2493;
+        t['twelveroman'] = 0x217B;
+        t['twentycircle'] = 0x2473;
+        t['twentyhangzhou'] = 0x5344;
+        t['twentyparen'] = 0x2487;
+        t['twentyperiod'] = 0x249B;
+        t['two'] = 0x0032;
+        t['twoarabic'] = 0x0662;
+        t['twobengali'] = 0x09E8;
+        t['twocircle'] = 0x2461;
+        t['twocircleinversesansserif'] = 0x278B;
+        t['twodeva'] = 0x0968;
+        t['twodotenleader'] = 0x2025;
+        t['twodotleader'] = 0x2025;
+        t['twodotleadervertical'] = 0xFE30;
+        t['twogujarati'] = 0x0AE8;
+        t['twogurmukhi'] = 0x0A68;
+        t['twohackarabic'] = 0x0662;
+        t['twohangzhou'] = 0x3022;
+        t['twoideographicparen'] = 0x3221;
+        t['twoinferior'] = 0x2082;
+        t['twomonospace'] = 0xFF12;
+        t['twonumeratorbengali'] = 0x09F5;
+        t['twooldstyle'] = 0xF732;
+        t['twoparen'] = 0x2475;
+        t['twoperiod'] = 0x2489;
+        t['twopersian'] = 0x06F2;
+        t['tworoman'] = 0x2171;
+        t['twostroke'] = 0x01BB;
+        t['twosuperior'] = 0x00B2;
+        t['twothai'] = 0x0E52;
+        t['twothirds'] = 0x2154;
+        t['u'] = 0x0075;
+        t['uacute'] = 0x00FA;
+        t['ubar'] = 0x0289;
+        t['ubengali'] = 0x0989;
+        t['ubopomofo'] = 0x3128;
+        t['ubreve'] = 0x016D;
+        t['ucaron'] = 0x01D4;
+        t['ucircle'] = 0x24E4;
+        t['ucircumflex'] = 0x00FB;
+        t['ucircumflexbelow'] = 0x1E77;
+        t['ucyrillic'] = 0x0443;
+        t['udattadeva'] = 0x0951;
+        t['udblacute'] = 0x0171;
+        t['udblgrave'] = 0x0215;
+        t['udeva'] = 0x0909;
+        t['udieresis'] = 0x00FC;
+        t['udieresisacute'] = 0x01D8;
+        t['udieresisbelow'] = 0x1E73;
+        t['udieresiscaron'] = 0x01DA;
+        t['udieresiscyrillic'] = 0x04F1;
+        t['udieresisgrave'] = 0x01DC;
+        t['udieresismacron'] = 0x01D6;
+        t['udotbelow'] = 0x1EE5;
+        t['ugrave'] = 0x00F9;
+        t['ugujarati'] = 0x0A89;
+        t['ugurmukhi'] = 0x0A09;
+        t['uhiragana'] = 0x3046;
+        t['uhookabove'] = 0x1EE7;
+        t['uhorn'] = 0x01B0;
+        t['uhornacute'] = 0x1EE9;
+        t['uhorndotbelow'] = 0x1EF1;
+        t['uhorngrave'] = 0x1EEB;
+        t['uhornhookabove'] = 0x1EED;
+        t['uhorntilde'] = 0x1EEF;
+        t['uhungarumlaut'] = 0x0171;
+        t['uhungarumlautcyrillic'] = 0x04F3;
+        t['uinvertedbreve'] = 0x0217;
+        t['ukatakana'] = 0x30A6;
+        t['ukatakanahalfwidth'] = 0xFF73;
+        t['ukcyrillic'] = 0x0479;
+        t['ukorean'] = 0x315C;
+        t['umacron'] = 0x016B;
+        t['umacroncyrillic'] = 0x04EF;
+        t['umacrondieresis'] = 0x1E7B;
+        t['umatragurmukhi'] = 0x0A41;
+        t['umonospace'] = 0xFF55;
+        t['underscore'] = 0x005F;
+        t['underscoredbl'] = 0x2017;
+        t['underscoremonospace'] = 0xFF3F;
+        t['underscorevertical'] = 0xFE33;
+        t['underscorewavy'] = 0xFE4F;
+        t['union'] = 0x222A;
+        t['universal'] = 0x2200;
+        t['uogonek'] = 0x0173;
+        t['uparen'] = 0x24B0;
+        t['upblock'] = 0x2580;
+        t['upperdothebrew'] = 0x05C4;
+        t['upsilon'] = 0x03C5;
+        t['upsilondieresis'] = 0x03CB;
+        t['upsilondieresistonos'] = 0x03B0;
+        t['upsilonlatin'] = 0x028A;
+        t['upsilontonos'] = 0x03CD;
+        t['uptackbelowcmb'] = 0x031D;
+        t['uptackmod'] = 0x02D4;
+        t['uragurmukhi'] = 0x0A73;
+        t['uring'] = 0x016F;
+        t['ushortcyrillic'] = 0x045E;
+        t['usmallhiragana'] = 0x3045;
+        t['usmallkatakana'] = 0x30A5;
+        t['usmallkatakanahalfwidth'] = 0xFF69;
+        t['ustraightcyrillic'] = 0x04AF;
+        t['ustraightstrokecyrillic'] = 0x04B1;
+        t['utilde'] = 0x0169;
+        t['utildeacute'] = 0x1E79;
+        t['utildebelow'] = 0x1E75;
+        t['uubengali'] = 0x098A;
+        t['uudeva'] = 0x090A;
+        t['uugujarati'] = 0x0A8A;
+        t['uugurmukhi'] = 0x0A0A;
+        t['uumatragurmukhi'] = 0x0A42;
+        t['uuvowelsignbengali'] = 0x09C2;
+        t['uuvowelsigndeva'] = 0x0942;
+        t['uuvowelsigngujarati'] = 0x0AC2;
+        t['uvowelsignbengali'] = 0x09C1;
+        t['uvowelsigndeva'] = 0x0941;
+        t['uvowelsigngujarati'] = 0x0AC1;
+        t['v'] = 0x0076;
+        t['vadeva'] = 0x0935;
+        t['vagujarati'] = 0x0AB5;
+        t['vagurmukhi'] = 0x0A35;
+        t['vakatakana'] = 0x30F7;
+        t['vav'] = 0x05D5;
+        t['vavdagesh'] = 0xFB35;
+        t['vavdagesh65'] = 0xFB35;
+        t['vavdageshhebrew'] = 0xFB35;
+        t['vavhebrew'] = 0x05D5;
+        t['vavholam'] = 0xFB4B;
+        t['vavholamhebrew'] = 0xFB4B;
+        t['vavvavhebrew'] = 0x05F0;
+        t['vavyodhebrew'] = 0x05F1;
+        t['vcircle'] = 0x24E5;
+        t['vdotbelow'] = 0x1E7F;
+        t['vecyrillic'] = 0x0432;
+        t['veharabic'] = 0x06A4;
+        t['vehfinalarabic'] = 0xFB6B;
+        t['vehinitialarabic'] = 0xFB6C;
+        t['vehmedialarabic'] = 0xFB6D;
+        t['vekatakana'] = 0x30F9;
+        t['venus'] = 0x2640;
+        t['verticalbar'] = 0x007C;
+        t['verticallineabovecmb'] = 0x030D;
+        t['verticallinebelowcmb'] = 0x0329;
+        t['verticallinelowmod'] = 0x02CC;
+        t['verticallinemod'] = 0x02C8;
+        t['vewarmenian'] = 0x057E;
+        t['vhook'] = 0x028B;
+        t['vikatakana'] = 0x30F8;
+        t['viramabengali'] = 0x09CD;
+        t['viramadeva'] = 0x094D;
+        t['viramagujarati'] = 0x0ACD;
+        t['visargabengali'] = 0x0983;
+        t['visargadeva'] = 0x0903;
+        t['visargagujarati'] = 0x0A83;
+        t['vmonospace'] = 0xFF56;
+        t['voarmenian'] = 0x0578;
+        t['voicediterationhiragana'] = 0x309E;
+        t['voicediterationkatakana'] = 0x30FE;
+        t['voicedmarkkana'] = 0x309B;
+        t['voicedmarkkanahalfwidth'] = 0xFF9E;
+        t['vokatakana'] = 0x30FA;
+        t['vparen'] = 0x24B1;
+        t['vtilde'] = 0x1E7D;
+        t['vturned'] = 0x028C;
+        t['vuhiragana'] = 0x3094;
+        t['vukatakana'] = 0x30F4;
+        t['w'] = 0x0077;
+        t['wacute'] = 0x1E83;
+        t['waekorean'] = 0x3159;
+        t['wahiragana'] = 0x308F;
+        t['wakatakana'] = 0x30EF;
+        t['wakatakanahalfwidth'] = 0xFF9C;
+        t['wakorean'] = 0x3158;
+        t['wasmallhiragana'] = 0x308E;
+        t['wasmallkatakana'] = 0x30EE;
+        t['wattosquare'] = 0x3357;
+        t['wavedash'] = 0x301C;
+        t['wavyunderscorevertical'] = 0xFE34;
+        t['wawarabic'] = 0x0648;
+        t['wawfinalarabic'] = 0xFEEE;
+        t['wawhamzaabovearabic'] = 0x0624;
+        t['wawhamzaabovefinalarabic'] = 0xFE86;
+        t['wbsquare'] = 0x33DD;
+        t['wcircle'] = 0x24E6;
+        t['wcircumflex'] = 0x0175;
+        t['wdieresis'] = 0x1E85;
+        t['wdotaccent'] = 0x1E87;
+        t['wdotbelow'] = 0x1E89;
+        t['wehiragana'] = 0x3091;
+        t['weierstrass'] = 0x2118;
+        t['wekatakana'] = 0x30F1;
+        t['wekorean'] = 0x315E;
+        t['weokorean'] = 0x315D;
+        t['wgrave'] = 0x1E81;
+        t['whitebullet'] = 0x25E6;
+        t['whitecircle'] = 0x25CB;
+        t['whitecircleinverse'] = 0x25D9;
+        t['whitecornerbracketleft'] = 0x300E;
+        t['whitecornerbracketleftvertical'] = 0xFE43;
+        t['whitecornerbracketright'] = 0x300F;
+        t['whitecornerbracketrightvertical'] = 0xFE44;
+        t['whitediamond'] = 0x25C7;
+        t['whitediamondcontainingblacksmalldiamond'] = 0x25C8;
+        t['whitedownpointingsmalltriangle'] = 0x25BF;
+        t['whitedownpointingtriangle'] = 0x25BD;
+        t['whiteleftpointingsmalltriangle'] = 0x25C3;
+        t['whiteleftpointingtriangle'] = 0x25C1;
+        t['whitelenticularbracketleft'] = 0x3016;
+        t['whitelenticularbracketright'] = 0x3017;
+        t['whiterightpointingsmalltriangle'] = 0x25B9;
+        t['whiterightpointingtriangle'] = 0x25B7;
+        t['whitesmallsquare'] = 0x25AB;
+        t['whitesmilingface'] = 0x263A;
+        t['whitesquare'] = 0x25A1;
+        t['whitestar'] = 0x2606;
+        t['whitetelephone'] = 0x260F;
+        t['whitetortoiseshellbracketleft'] = 0x3018;
+        t['whitetortoiseshellbracketright'] = 0x3019;
+        t['whiteuppointingsmalltriangle'] = 0x25B5;
+        t['whiteuppointingtriangle'] = 0x25B3;
+        t['wihiragana'] = 0x3090;
+        t['wikatakana'] = 0x30F0;
+        t['wikorean'] = 0x315F;
+        t['wmonospace'] = 0xFF57;
+        t['wohiragana'] = 0x3092;
+        t['wokatakana'] = 0x30F2;
+        t['wokatakanahalfwidth'] = 0xFF66;
+        t['won'] = 0x20A9;
+        t['wonmonospace'] = 0xFFE6;
+        t['wowaenthai'] = 0x0E27;
+        t['wparen'] = 0x24B2;
+        t['wring'] = 0x1E98;
+        t['wsuperior'] = 0x02B7;
+        t['wturned'] = 0x028D;
+        t['wynn'] = 0x01BF;
+        t['x'] = 0x0078;
+        t['xabovecmb'] = 0x033D;
+        t['xbopomofo'] = 0x3112;
+        t['xcircle'] = 0x24E7;
+        t['xdieresis'] = 0x1E8D;
+        t['xdotaccent'] = 0x1E8B;
+        t['xeharmenian'] = 0x056D;
+        t['xi'] = 0x03BE;
+        t['xmonospace'] = 0xFF58;
+        t['xparen'] = 0x24B3;
+        t['xsuperior'] = 0x02E3;
+        t['y'] = 0x0079;
+        t['yaadosquare'] = 0x334E;
+        t['yabengali'] = 0x09AF;
+        t['yacute'] = 0x00FD;
+        t['yadeva'] = 0x092F;
+        t['yaekorean'] = 0x3152;
+        t['yagujarati'] = 0x0AAF;
+        t['yagurmukhi'] = 0x0A2F;
+        t['yahiragana'] = 0x3084;
+        t['yakatakana'] = 0x30E4;
+        t['yakatakanahalfwidth'] = 0xFF94;
+        t['yakorean'] = 0x3151;
+        t['yamakkanthai'] = 0x0E4E;
+        t['yasmallhiragana'] = 0x3083;
+        t['yasmallkatakana'] = 0x30E3;
+        t['yasmallkatakanahalfwidth'] = 0xFF6C;
+        t['yatcyrillic'] = 0x0463;
+        t['ycircle'] = 0x24E8;
+        t['ycircumflex'] = 0x0177;
+        t['ydieresis'] = 0x00FF;
+        t['ydotaccent'] = 0x1E8F;
+        t['ydotbelow'] = 0x1EF5;
+        t['yeharabic'] = 0x064A;
+        t['yehbarreearabic'] = 0x06D2;
+        t['yehbarreefinalarabic'] = 0xFBAF;
+        t['yehfinalarabic'] = 0xFEF2;
+        t['yehhamzaabovearabic'] = 0x0626;
+        t['yehhamzaabovefinalarabic'] = 0xFE8A;
+        t['yehhamzaaboveinitialarabic'] = 0xFE8B;
+        t['yehhamzaabovemedialarabic'] = 0xFE8C;
+        t['yehinitialarabic'] = 0xFEF3;
+        t['yehmedialarabic'] = 0xFEF4;
+        t['yehmeeminitialarabic'] = 0xFCDD;
+        t['yehmeemisolatedarabic'] = 0xFC58;
+        t['yehnoonfinalarabic'] = 0xFC94;
+        t['yehthreedotsbelowarabic'] = 0x06D1;
+        t['yekorean'] = 0x3156;
+        t['yen'] = 0x00A5;
+        t['yenmonospace'] = 0xFFE5;
+        t['yeokorean'] = 0x3155;
+        t['yeorinhieuhkorean'] = 0x3186;
+        t['yerahbenyomohebrew'] = 0x05AA;
+        t['yerahbenyomolefthebrew'] = 0x05AA;
+        t['yericyrillic'] = 0x044B;
+        t['yerudieresiscyrillic'] = 0x04F9;
+        t['yesieungkorean'] = 0x3181;
+        t['yesieungpansioskorean'] = 0x3183;
+        t['yesieungsioskorean'] = 0x3182;
+        t['yetivhebrew'] = 0x059A;
+        t['ygrave'] = 0x1EF3;
+        t['yhook'] = 0x01B4;
+        t['yhookabove'] = 0x1EF7;
+        t['yiarmenian'] = 0x0575;
+        t['yicyrillic'] = 0x0457;
+        t['yikorean'] = 0x3162;
+        t['yinyang'] = 0x262F;
+        t['yiwnarmenian'] = 0x0582;
+        t['ymonospace'] = 0xFF59;
+        t['yod'] = 0x05D9;
+        t['yoddagesh'] = 0xFB39;
+        t['yoddageshhebrew'] = 0xFB39;
+        t['yodhebrew'] = 0x05D9;
+        t['yodyodhebrew'] = 0x05F2;
+        t['yodyodpatahhebrew'] = 0xFB1F;
+        t['yohiragana'] = 0x3088;
+        t['yoikorean'] = 0x3189;
+        t['yokatakana'] = 0x30E8;
+        t['yokatakanahalfwidth'] = 0xFF96;
+        t['yokorean'] = 0x315B;
+        t['yosmallhiragana'] = 0x3087;
+        t['yosmallkatakana'] = 0x30E7;
+        t['yosmallkatakanahalfwidth'] = 0xFF6E;
+        t['yotgreek'] = 0x03F3;
+        t['yoyaekorean'] = 0x3188;
+        t['yoyakorean'] = 0x3187;
+        t['yoyakthai'] = 0x0E22;
+        t['yoyingthai'] = 0x0E0D;
+        t['yparen'] = 0x24B4;
+        t['ypogegrammeni'] = 0x037A;
+        t['ypogegrammenigreekcmb'] = 0x0345;
+        t['yr'] = 0x01A6;
+        t['yring'] = 0x1E99;
+        t['ysuperior'] = 0x02B8;
+        t['ytilde'] = 0x1EF9;
+        t['yturned'] = 0x028E;
+        t['yuhiragana'] = 0x3086;
+        t['yuikorean'] = 0x318C;
+        t['yukatakana'] = 0x30E6;
+        t['yukatakanahalfwidth'] = 0xFF95;
+        t['yukorean'] = 0x3160;
+        t['yusbigcyrillic'] = 0x046B;
+        t['yusbigiotifiedcyrillic'] = 0x046D;
+        t['yuslittlecyrillic'] = 0x0467;
+        t['yuslittleiotifiedcyrillic'] = 0x0469;
+        t['yusmallhiragana'] = 0x3085;
+        t['yusmallkatakana'] = 0x30E5;
+        t['yusmallkatakanahalfwidth'] = 0xFF6D;
+        t['yuyekorean'] = 0x318B;
+        t['yuyeokorean'] = 0x318A;
+        t['yyabengali'] = 0x09DF;
+        t['yyadeva'] = 0x095F;
+        t['z'] = 0x007A;
+        t['zaarmenian'] = 0x0566;
+        t['zacute'] = 0x017A;
+        t['zadeva'] = 0x095B;
+        t['zagurmukhi'] = 0x0A5B;
+        t['zaharabic'] = 0x0638;
+        t['zahfinalarabic'] = 0xFEC6;
+        t['zahinitialarabic'] = 0xFEC7;
+        t['zahiragana'] = 0x3056;
+        t['zahmedialarabic'] = 0xFEC8;
+        t['zainarabic'] = 0x0632;
+        t['zainfinalarabic'] = 0xFEB0;
+        t['zakatakana'] = 0x30B6;
+        t['zaqefgadolhebrew'] = 0x0595;
+        t['zaqefqatanhebrew'] = 0x0594;
+        t['zarqahebrew'] = 0x0598;
+        t['zayin'] = 0x05D6;
+        t['zayindagesh'] = 0xFB36;
+        t['zayindageshhebrew'] = 0xFB36;
+        t['zayinhebrew'] = 0x05D6;
+        t['zbopomofo'] = 0x3117;
+        t['zcaron'] = 0x017E;
+        t['zcircle'] = 0x24E9;
+        t['zcircumflex'] = 0x1E91;
+        t['zcurl'] = 0x0291;
+        t['zdot'] = 0x017C;
+        t['zdotaccent'] = 0x017C;
+        t['zdotbelow'] = 0x1E93;
+        t['zecyrillic'] = 0x0437;
+        t['zedescendercyrillic'] = 0x0499;
+        t['zedieresiscyrillic'] = 0x04DF;
+        t['zehiragana'] = 0x305C;
+        t['zekatakana'] = 0x30BC;
+        t['zero'] = 0x0030;
+        t['zeroarabic'] = 0x0660;
+        t['zerobengali'] = 0x09E6;
+        t['zerodeva'] = 0x0966;
+        t['zerogujarati'] = 0x0AE6;
+        t['zerogurmukhi'] = 0x0A66;
+        t['zerohackarabic'] = 0x0660;
+        t['zeroinferior'] = 0x2080;
+        t['zeromonospace'] = 0xFF10;
+        t['zerooldstyle'] = 0xF730;
+        t['zeropersian'] = 0x06F0;
+        t['zerosuperior'] = 0x2070;
+        t['zerothai'] = 0x0E50;
+        t['zerowidthjoiner'] = 0xFEFF;
+        t['zerowidthnonjoiner'] = 0x200C;
+        t['zerowidthspace'] = 0x200B;
+        t['zeta'] = 0x03B6;
+        t['zhbopomofo'] = 0x3113;
+        t['zhearmenian'] = 0x056A;
+        t['zhebrevecyrillic'] = 0x04C2;
+        t['zhecyrillic'] = 0x0436;
+        t['zhedescendercyrillic'] = 0x0497;
+        t['zhedieresiscyrillic'] = 0x04DD;
+        t['zihiragana'] = 0x3058;
+        t['zikatakana'] = 0x30B8;
+        t['zinorhebrew'] = 0x05AE;
+        t['zlinebelow'] = 0x1E95;
+        t['zmonospace'] = 0xFF5A;
+        t['zohiragana'] = 0x305E;
+        t['zokatakana'] = 0x30BE;
+        t['zparen'] = 0x24B5;
+        t['zretroflexhook'] = 0x0290;
+        t['zstroke'] = 0x01B6;
+        t['zuhiragana'] = 0x305A;
+        t['zukatakana'] = 0x30BA;
+        t['.notdef'] = 0x0000;
+      });
+      var getDingbatsGlyphsUnicode = getLookupTableFactory(function (t) {
+        t['space'] = 0x0020;
+        t['a1'] = 0x2701;
+        t['a2'] = 0x2702;
+        t['a202'] = 0x2703;
+        t['a3'] = 0x2704;
+        t['a4'] = 0x260E;
+        t['a5'] = 0x2706;
+        t['a119'] = 0x2707;
+        t['a118'] = 0x2708;
+        t['a117'] = 0x2709;
+        t['a11'] = 0x261B;
+        t['a12'] = 0x261E;
+        t['a13'] = 0x270C;
+        t['a14'] = 0x270D;
+        t['a15'] = 0x270E;
+        t['a16'] = 0x270F;
+        t['a105'] = 0x2710;
+        t['a17'] = 0x2711;
+        t['a18'] = 0x2712;
+        t['a19'] = 0x2713;
+        t['a20'] = 0x2714;
+        t['a21'] = 0x2715;
+        t['a22'] = 0x2716;
+        t['a23'] = 0x2717;
+        t['a24'] = 0x2718;
+        t['a25'] = 0x2719;
+        t['a26'] = 0x271A;
+        t['a27'] = 0x271B;
+        t['a28'] = 0x271C;
+        t['a6'] = 0x271D;
+        t['a7'] = 0x271E;
+        t['a8'] = 0x271F;
+        t['a9'] = 0x2720;
+        t['a10'] = 0x2721;
+        t['a29'] = 0x2722;
+        t['a30'] = 0x2723;
+        t['a31'] = 0x2724;
+        t['a32'] = 0x2725;
+        t['a33'] = 0x2726;
+        t['a34'] = 0x2727;
+        t['a35'] = 0x2605;
+        t['a36'] = 0x2729;
+        t['a37'] = 0x272A;
+        t['a38'] = 0x272B;
+        t['a39'] = 0x272C;
+        t['a40'] = 0x272D;
+        t['a41'] = 0x272E;
+        t['a42'] = 0x272F;
+        t['a43'] = 0x2730;
+        t['a44'] = 0x2731;
+        t['a45'] = 0x2732;
+        t['a46'] = 0x2733;
+        t['a47'] = 0x2734;
+        t['a48'] = 0x2735;
+        t['a49'] = 0x2736;
+        t['a50'] = 0x2737;
+        t['a51'] = 0x2738;
+        t['a52'] = 0x2739;
+        t['a53'] = 0x273A;
+        t['a54'] = 0x273B;
+        t['a55'] = 0x273C;
+        t['a56'] = 0x273D;
+        t['a57'] = 0x273E;
+        t['a58'] = 0x273F;
+        t['a59'] = 0x2740;
+        t['a60'] = 0x2741;
+        t['a61'] = 0x2742;
+        t['a62'] = 0x2743;
+        t['a63'] = 0x2744;
+        t['a64'] = 0x2745;
+        t['a65'] = 0x2746;
+        t['a66'] = 0x2747;
+        t['a67'] = 0x2748;
+        t['a68'] = 0x2749;
+        t['a69'] = 0x274A;
+        t['a70'] = 0x274B;
+        t['a71'] = 0x25CF;
+        t['a72'] = 0x274D;
+        t['a73'] = 0x25A0;
+        t['a74'] = 0x274F;
+        t['a203'] = 0x2750;
+        t['a75'] = 0x2751;
+        t['a204'] = 0x2752;
+        t['a76'] = 0x25B2;
+        t['a77'] = 0x25BC;
+        t['a78'] = 0x25C6;
+        t['a79'] = 0x2756;
+        t['a81'] = 0x25D7;
+        t['a82'] = 0x2758;
+        t['a83'] = 0x2759;
+        t['a84'] = 0x275A;
+        t['a97'] = 0x275B;
+        t['a98'] = 0x275C;
+        t['a99'] = 0x275D;
+        t['a100'] = 0x275E;
+        t['a101'] = 0x2761;
+        t['a102'] = 0x2762;
+        t['a103'] = 0x2763;
+        t['a104'] = 0x2764;
+        t['a106'] = 0x2765;
+        t['a107'] = 0x2766;
+        t['a108'] = 0x2767;
+        t['a112'] = 0x2663;
+        t['a111'] = 0x2666;
+        t['a110'] = 0x2665;
+        t['a109'] = 0x2660;
+        t['a120'] = 0x2460;
+        t['a121'] = 0x2461;
+        t['a122'] = 0x2462;
+        t['a123'] = 0x2463;
+        t['a124'] = 0x2464;
+        t['a125'] = 0x2465;
+        t['a126'] = 0x2466;
+        t['a127'] = 0x2467;
+        t['a128'] = 0x2468;
+        t['a129'] = 0x2469;
+        t['a130'] = 0x2776;
+        t['a131'] = 0x2777;
+        t['a132'] = 0x2778;
+        t['a133'] = 0x2779;
+        t['a134'] = 0x277A;
+        t['a135'] = 0x277B;
+        t['a136'] = 0x277C;
+        t['a137'] = 0x277D;
+        t['a138'] = 0x277E;
+        t['a139'] = 0x277F;
+        t['a140'] = 0x2780;
+        t['a141'] = 0x2781;
+        t['a142'] = 0x2782;
+        t['a143'] = 0x2783;
+        t['a144'] = 0x2784;
+        t['a145'] = 0x2785;
+        t['a146'] = 0x2786;
+        t['a147'] = 0x2787;
+        t['a148'] = 0x2788;
+        t['a149'] = 0x2789;
+        t['a150'] = 0x278A;
+        t['a151'] = 0x278B;
+        t['a152'] = 0x278C;
+        t['a153'] = 0x278D;
+        t['a154'] = 0x278E;
+        t['a155'] = 0x278F;
+        t['a156'] = 0x2790;
+        t['a157'] = 0x2791;
+        t['a158'] = 0x2792;
+        t['a159'] = 0x2793;
+        t['a160'] = 0x2794;
+        t['a161'] = 0x2192;
+        t['a163'] = 0x2194;
+        t['a164'] = 0x2195;
+        t['a196'] = 0x2798;
+        t['a165'] = 0x2799;
+        t['a192'] = 0x279A;
+        t['a166'] = 0x279B;
+        t['a167'] = 0x279C;
+        t['a168'] = 0x279D;
+        t['a169'] = 0x279E;
+        t['a170'] = 0x279F;
+        t['a171'] = 0x27A0;
+        t['a172'] = 0x27A1;
+        t['a173'] = 0x27A2;
+        t['a162'] = 0x27A3;
+        t['a174'] = 0x27A4;
+        t['a175'] = 0x27A5;
+        t['a176'] = 0x27A6;
+        t['a177'] = 0x27A7;
+        t['a178'] = 0x27A8;
+        t['a179'] = 0x27A9;
+        t['a193'] = 0x27AA;
+        t['a180'] = 0x27AB;
+        t['a199'] = 0x27AC;
+        t['a181'] = 0x27AD;
+        t['a200'] = 0x27AE;
+        t['a182'] = 0x27AF;
+        t['a201'] = 0x27B1;
+        t['a183'] = 0x27B2;
+        t['a184'] = 0x27B3;
+        t['a197'] = 0x27B4;
+        t['a185'] = 0x27B5;
+        t['a194'] = 0x27B6;
+        t['a198'] = 0x27B7;
+        t['a186'] = 0x27B8;
+        t['a195'] = 0x27B9;
+        t['a187'] = 0x27BA;
+        t['a188'] = 0x27BB;
+        t['a189'] = 0x27BC;
+        t['a190'] = 0x27BD;
+        t['a191'] = 0x27BE;
+        t['a89'] = 0x2768;
+        // 0xF8D7
+        t['a90'] = 0x2769;
+        // 0xF8D8
+        t['a93'] = 0x276A;
+        // 0xF8D9
+        t['a94'] = 0x276B;
+        // 0xF8DA
+        t['a91'] = 0x276C;
+        // 0xF8DB
+        t['a92'] = 0x276D;
+        // 0xF8DC
+        t['a205'] = 0x276E;
+        // 0xF8DD
+        t['a85'] = 0x276F;
+        // 0xF8DE
+        t['a206'] = 0x2770;
+        // 0xF8DF
+        t['a86'] = 0x2771;
+        // 0xF8E0
+        t['a87'] = 0x2772;
+        // 0xF8E1
+        t['a88'] = 0x2773;
+        // 0xF8E2
+        t['a95'] = 0x2774;
+        // 0xF8E3
+        t['a96'] = 0x2775;
+        // 0xF8E4
+        t['.notdef'] = 0x0000;
+      });
+      exports.getGlyphsUnicode = getGlyphsUnicode;
+      exports.getDingbatsGlyphsUnicode = getDingbatsGlyphsUnicode;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreJbig2 = {}, root.pdfjsSharedUtil, root.pdfjsCoreArithmeticDecoder);
+    }(this, function (exports, sharedUtil, coreArithmeticDecoder) {
+      var error = sharedUtil.error;
+      var log2 = sharedUtil.log2;
+      var readInt8 = sharedUtil.readInt8;
+      var readUint16 = sharedUtil.readUint16;
+      var readUint32 = sharedUtil.readUint32;
+      var shadow = sharedUtil.shadow;
+      var ArithmeticDecoder = coreArithmeticDecoder.ArithmeticDecoder;
+      var Jbig2Image = function Jbig2ImageClosure() {
+        // Utility data structures
+        function ContextCache() {
+        }
+        ContextCache.prototype = {
+          getContexts: function (id) {
+            if (id in this) {
+              return this[id];
+            }
+            return this[id] = new Int8Array(1 << 16);
+          }
+        };
+        function DecodingContext(data, start, end) {
+          this.data = data;
+          this.start = start;
+          this.end = end;
+        }
+        DecodingContext.prototype = {
+          get decoder() {
+            var decoder = new ArithmeticDecoder(this.data, this.start, this.end);
+            return shadow(this, 'decoder', decoder);
+          },
+          get contextCache() {
+            var cache = new ContextCache();
+            return shadow(this, 'contextCache', cache);
+          }
+        };
+        // Annex A. Arithmetic Integer Decoding Procedure
+        // A.2 Procedure for decoding values
+        function decodeInteger(contextCache, procedure, decoder) {
+          var contexts = contextCache.getContexts(procedure);
+          var prev = 1;
+          function readBits(length) {
+            var v = 0;
+            for (var i = 0; i < length; i++) {
+              var bit = decoder.readBit(contexts, prev);
+              prev = prev < 256 ? prev << 1 | bit : (prev << 1 | bit) & 511 | 256;
+              v = v << 1 | bit;
+            }
+            return v >>> 0;
+          }
+          var sign = readBits(1);
+          var value = readBits(1) ? readBits(1) ? readBits(1) ? readBits(1) ? readBits(1) ? readBits(32) + 4436 : readBits(12) + 340 : readBits(8) + 84 : readBits(6) + 20 : readBits(4) + 4 : readBits(2);
+          return sign === 0 ? value : value > 0 ? -value : null;
+        }
+        // A.3 The IAID decoding procedure
+        function decodeIAID(contextCache, decoder, codeLength) {
+          var contexts = contextCache.getContexts('IAID');
+          var prev = 1;
+          for (var i = 0; i < codeLength; i++) {
+            var bit = decoder.readBit(contexts, prev);
+            prev = prev << 1 | bit;
+          }
+          if (codeLength < 31) {
+            return prev & (1 << codeLength) - 1;
+          }
+          return prev & 0x7FFFFFFF;
+        }
+        // 7.3 Segment types
+        var SegmentTypes = [
+          'SymbolDictionary',
+          null,
+          null,
+          null,
+          'IntermediateTextRegion',
+          null,
+          'ImmediateTextRegion',
+          'ImmediateLosslessTextRegion',
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          'patternDictionary',
+          null,
+          null,
+          null,
+          'IntermediateHalftoneRegion',
+          null,
+          'ImmediateHalftoneRegion',
+          'ImmediateLosslessHalftoneRegion',
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          'IntermediateGenericRegion',
+          null,
+          'ImmediateGenericRegion',
+          'ImmediateLosslessGenericRegion',
+          'IntermediateGenericRefinementRegion',
+          null,
+          'ImmediateGenericRefinementRegion',
+          'ImmediateLosslessGenericRefinementRegion',
+          null,
+          null,
+          null,
+          null,
+          'PageInformation',
+          'EndOfPage',
+          'EndOfStripe',
+          'EndOfFile',
+          'Profiles',
+          'Tables',
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          null,
+          'Extension'
+        ];
+        var CodingTemplates = [
+          [
+            {
+              x: -1,
+              y: -2
+            },
+            {
+              x: 0,
+              y: -2
+            },
+            {
+              x: 1,
+              y: -2
+            },
+            {
+              x: -2,
+              y: -1
+            },
+            {
+              x: -1,
+              y: -1
+            },
+            {
+              x: 0,
+              y: -1
+            },
+            {
+              x: 1,
+              y: -1
+            },
+            {
+              x: 2,
+              y: -1
+            },
+            {
+              x: -4,
+              y: 0
+            },
+            {
+              x: -3,
+              y: 0
+            },
+            {
+              x: -2,
+              y: 0
+            },
+            {
+              x: -1,
+              y: 0
+            }
+          ],
+          [
+            {
+              x: -1,
+              y: -2
+            },
+            {
+              x: 0,
+              y: -2
+            },
+            {
+              x: 1,
+              y: -2
+            },
+            {
+              x: 2,
+              y: -2
+            },
+            {
+              x: -2,
+              y: -1
+            },
+            {
+              x: -1,
+              y: -1
+            },
+            {
+              x: 0,
+              y: -1
+            },
+            {
+              x: 1,
+              y: -1
+            },
+            {
+              x: 2,
+              y: -1
+            },
+            {
+              x: -3,
+              y: 0
+            },
+            {
+              x: -2,
+              y: 0
+            },
+            {
+              x: -1,
+              y: 0
+            }
+          ],
+          [
+            {
+              x: -1,
+              y: -2
+            },
+            {
+              x: 0,
+              y: -2
+            },
+            {
+              x: 1,
+              y: -2
+            },
+            {
+              x: -2,
+              y: -1
+            },
+            {
+              x: -1,
+              y: -1
+            },
+            {
+              x: 0,
+              y: -1
+            },
+            {
+              x: 1,
+              y: -1
+            },
+            {
+              x: -2,
+              y: 0
+            },
+            {
+              x: -1,
+              y: 0
+            }
+          ],
+          [
+            {
+              x: -3,
+              y: -1
+            },
+            {
+              x: -2,
+              y: -1
+            },
+            {
+              x: -1,
+              y: -1
+            },
+            {
+              x: 0,
+              y: -1
+            },
+            {
+              x: 1,
+              y: -1
+            },
+            {
+              x: -4,
+              y: 0
+            },
+            {
+              x: -3,
+              y: 0
+            },
+            {
+              x: -2,
+              y: 0
+            },
+            {
+              x: -1,
+              y: 0
+            }
+          ]
+        ];
+        var RefinementTemplates = [
+          {
+            coding: [
+              {
+                x: 0,
+                y: -1
+              },
+              {
+                x: 1,
+                y: -1
+              },
+              {
+                x: -1,
+                y: 0
+              }
+            ],
+            reference: [
+              {
+                x: 0,
+                y: -1
+              },
+              {
+                x: 1,
+                y: -1
+              },
+              {
+                x: -1,
+                y: 0
+              },
+              {
+                x: 0,
+                y: 0
+              },
+              {
+                x: 1,
+                y: 0
+              },
+              {
+                x: -1,
+                y: 1
+              },
+              {
+                x: 0,
+                y: 1
+              },
+              {
+                x: 1,
+                y: 1
+              }
+            ]
+          },
+          {
+            coding: [
+              {
+                x: -1,
+                y: -1
+              },
+              {
+                x: 0,
+                y: -1
+              },
+              {
+                x: 1,
+                y: -1
+              },
+              {
+                x: -1,
+                y: 0
+              }
+            ],
+            reference: [
+              {
+                x: 0,
+                y: -1
+              },
+              {
+                x: -1,
+                y: 0
+              },
+              {
+                x: 0,
+                y: 0
+              },
+              {
+                x: 1,
+                y: 0
+              },
+              {
+                x: 0,
+                y: 1
+              },
+              {
+                x: 1,
+                y: 1
+              }
+            ]
+          }
+        ];
+        // See 6.2.5.7 Decoding the bitmap.
+        var ReusedContexts = [
+          0x9B25,
+          // 10011 0110010 0101
+          0x0795,
+          // 0011 110010 101
+          0x00E5,
+          // 001 11001 01
+          0x0195
+        ];
+        // 011001 0101
+        var RefinementReusedContexts = [
+          0x0020,
+          // '000' + '0' (coding) + '00010000' + '0' (reference)
+          0x0008
+        ];
+        // '0000' + '001000'
+        function decodeBitmapTemplate0(width, height, decodingContext) {
+          var decoder = decodingContext.decoder;
+          var contexts = decodingContext.contextCache.getContexts('GB');
+          var contextLabel, i, j, pixel, row, row1, row2, bitmap = [];
+          // ...ooooo....
+          // ..ooooooo... Context template for current pixel (X)
+          // .ooooX...... (concatenate values of 'o'-pixels to get contextLabel)
+          var OLD_PIXEL_MASK = 0x7BF7;
+          // 01111 0111111 0111
+          for (i = 0; i < height; i++) {
+            row = bitmap[i] = new Uint8Array(width);
+            row1 = i < 1 ? row : bitmap[i - 1];
+            row2 = i < 2 ? row : bitmap[i - 2];
+            // At the beginning of each row:
+            // Fill contextLabel with pixels that are above/right of (X)
+            contextLabel = row2[0] << 13 | row2[1] << 12 | row2[2] << 11 | row1[0] << 7 | row1[1] << 6 | row1[2] << 5 | row1[3] << 4;
+            for (j = 0; j < width; j++) {
+              row[j] = pixel = decoder.readBit(contexts, contextLabel);
+              // At each pixel: Clear contextLabel pixels that are shifted
+              // out of the context, then add new ones.
+              contextLabel = (contextLabel & OLD_PIXEL_MASK) << 1 | (j + 3 < width ? row2[j + 3] << 11 : 0) | (j + 4 < width ? row1[j + 4] << 4 : 0) | pixel;
+            }
+          }
+          return bitmap;
+        }
+        // 6.2 Generic Region Decoding Procedure
+        function decodeBitmap(mmr, width, height, templateIndex, prediction, skip, at, decodingContext) {
+          if (mmr) {
+            error('JBIG2 error: MMR encoding is not supported');
+          }
+          // Use optimized version for the most common case
+          if (templateIndex === 0 && !skip && !prediction && at.length === 4 && at[0].x === 3 && at[0].y === -1 && at[1].x === -3 && at[1].y === -1 && at[2].x === 2 && at[2].y === -2 && at[3].x === -2 && at[3].y === -2) {
+            return decodeBitmapTemplate0(width, height, decodingContext);
+          }
+          var useskip = !!skip;
+          var template = CodingTemplates[templateIndex].concat(at);
+          // Sorting is non-standard, and it is not required. But sorting increases
+          // the number of template bits that can be reused from the previous
+          // contextLabel in the main loop.
+          template.sort(function (a, b) {
+            return a.y - b.y || a.x - b.x;
+          });
+          var templateLength = template.length;
+          var templateX = new Int8Array(templateLength);
+          var templateY = new Int8Array(templateLength);
+          var changingTemplateEntries = [];
+          var reuseMask = 0, minX = 0, maxX = 0, minY = 0;
+          var c, k;
+          for (k = 0; k < templateLength; k++) {
+            templateX[k] = template[k].x;
+            templateY[k] = template[k].y;
+            minX = Math.min(minX, template[k].x);
+            maxX = Math.max(maxX, template[k].x);
+            minY = Math.min(minY, template[k].y);
+            // Check if the template pixel appears in two consecutive context labels,
+            // so it can be reused. Otherwise, we add it to the list of changing
+            // template entries.
+            if (k < templateLength - 1 && template[k].y === template[k + 1].y && template[k].x === template[k + 1].x - 1) {
+              reuseMask |= 1 << templateLength - 1 - k;
+            } else {
+              changingTemplateEntries.push(k);
+            }
+          }
+          var changingEntriesLength = changingTemplateEntries.length;
+          var changingTemplateX = new Int8Array(changingEntriesLength);
+          var changingTemplateY = new Int8Array(changingEntriesLength);
+          var changingTemplateBit = new Uint16Array(changingEntriesLength);
+          for (c = 0; c < changingEntriesLength; c++) {
+            k = changingTemplateEntries[c];
+            changingTemplateX[c] = template[k].x;
+            changingTemplateY[c] = template[k].y;
+            changingTemplateBit[c] = 1 << templateLength - 1 - k;
+          }
+          // Get the safe bounding box edges from the width, height, minX, maxX, minY
+          var sbb_left = -minX;
+          var sbb_top = -minY;
+          var sbb_right = width - maxX;
+          var pseudoPixelContext = ReusedContexts[templateIndex];
+          var row = new Uint8Array(width);
+          var bitmap = [];
+          var decoder = decodingContext.decoder;
+          var contexts = decodingContext.contextCache.getContexts('GB');
+          var ltp = 0, j, i0, j0, contextLabel = 0, bit, shift;
+          for (var i = 0; i < height; i++) {
+            if (prediction) {
+              var sltp = decoder.readBit(contexts, pseudoPixelContext);
+              ltp ^= sltp;
+              if (ltp) {
+                bitmap.push(row);
+                // duplicate previous row
+                continue;
+              }
+            }
+            row = new Uint8Array(row);
+            bitmap.push(row);
+            for (j = 0; j < width; j++) {
+              if (useskip && skip[i][j]) {
+                row[j] = 0;
+                continue;
+              }
+              // Are we in the middle of a scanline, so we can reuse contextLabel
+              // bits?
+              if (j >= sbb_left && j < sbb_right && i >= sbb_top) {
+                // If yes, we can just shift the bits that are reusable and only
+                // fetch the remaining ones.
+                contextLabel = contextLabel << 1 & reuseMask;
+                for (k = 0; k < changingEntriesLength; k++) {
+                  i0 = i + changingTemplateY[k];
+                  j0 = j + changingTemplateX[k];
+                  bit = bitmap[i0][j0];
+                  if (bit) {
+                    bit = changingTemplateBit[k];
+                    contextLabel |= bit;
+                  }
+                }
+              } else {
+                // compute the contextLabel from scratch
+                contextLabel = 0;
+                shift = templateLength - 1;
+                for (k = 0; k < templateLength; k++, shift--) {
+                  j0 = j + templateX[k];
+                  if (j0 >= 0 && j0 < width) {
+                    i0 = i + templateY[k];
+                    if (i0 >= 0) {
+                      bit = bitmap[i0][j0];
+                      if (bit) {
+                        contextLabel |= bit << shift;
+                      }
+                    }
+                  }
+                }
+              }
+              var pixel = decoder.readBit(contexts, contextLabel);
+              row[j] = pixel;
+            }
+          }
+          return bitmap;
+        }
+        // 6.3.2 Generic Refinement Region Decoding Procedure
+        function decodeRefinement(width, height, templateIndex, referenceBitmap, offsetX, offsetY, prediction, at, decodingContext) {
+          var codingTemplate = RefinementTemplates[templateIndex].coding;
+          if (templateIndex === 0) {
+            codingTemplate = codingTemplate.concat([at[0]]);
+          }
+          var codingTemplateLength = codingTemplate.length;
+          var codingTemplateX = new Int32Array(codingTemplateLength);
+          var codingTemplateY = new Int32Array(codingTemplateLength);
+          var k;
+          for (k = 0; k < codingTemplateLength; k++) {
+            codingTemplateX[k] = codingTemplate[k].x;
+            codingTemplateY[k] = codingTemplate[k].y;
+          }
+          var referenceTemplate = RefinementTemplates[templateIndex].reference;
+          if (templateIndex === 0) {
+            referenceTemplate = referenceTemplate.concat([at[1]]);
+          }
+          var referenceTemplateLength = referenceTemplate.length;
+          var referenceTemplateX = new Int32Array(referenceTemplateLength);
+          var referenceTemplateY = new Int32Array(referenceTemplateLength);
+          for (k = 0; k < referenceTemplateLength; k++) {
+            referenceTemplateX[k] = referenceTemplate[k].x;
+            referenceTemplateY[k] = referenceTemplate[k].y;
+          }
+          var referenceWidth = referenceBitmap[0].length;
+          var referenceHeight = referenceBitmap.length;
+          var pseudoPixelContext = RefinementReusedContexts[templateIndex];
+          var bitmap = [];
+          var decoder = decodingContext.decoder;
+          var contexts = decodingContext.contextCache.getContexts('GR');
+          var ltp = 0;
+          for (var i = 0; i < height; i++) {
+            if (prediction) {
+              var sltp = decoder.readBit(contexts, pseudoPixelContext);
+              ltp ^= sltp;
+              if (ltp) {
+                error('JBIG2 error: prediction is not supported');
+              }
+            }
+            var row = new Uint8Array(width);
+            bitmap.push(row);
+            for (var j = 0; j < width; j++) {
+              var i0, j0;
+              var contextLabel = 0;
+              for (k = 0; k < codingTemplateLength; k++) {
+                i0 = i + codingTemplateY[k];
+                j0 = j + codingTemplateX[k];
+                if (i0 < 0 || j0 < 0 || j0 >= width) {
+                  contextLabel <<= 1;
+                } else
+                  // out of bound pixel
+                  {
+                    contextLabel = contextLabel << 1 | bitmap[i0][j0];
+                  }
+              }
+              for (k = 0; k < referenceTemplateLength; k++) {
+                i0 = i + referenceTemplateY[k] + offsetY;
+                j0 = j + referenceTemplateX[k] + offsetX;
+                if (i0 < 0 || i0 >= referenceHeight || j0 < 0 || j0 >= referenceWidth) {
+                  contextLabel <<= 1;
+                } else
+                  // out of bound pixel
+                  {
+                    contextLabel = contextLabel << 1 | referenceBitmap[i0][j0];
+                  }
+              }
+              var pixel = decoder.readBit(contexts, contextLabel);
+              row[j] = pixel;
+            }
+          }
+          return bitmap;
+        }
+        // 6.5.5 Decoding the symbol dictionary
+        function decodeSymbolDictionary(huffman, refinement, symbols, numberOfNewSymbols, numberOfExportedSymbols, huffmanTables, templateIndex, at, refinementTemplateIndex, refinementAt, decodingContext) {
+          if (huffman) {
+            error('JBIG2 error: huffman is not supported');
+          }
+          var newSymbols = [];
+          var currentHeight = 0;
+          var symbolCodeLength = log2(symbols.length + numberOfNewSymbols);
+          var decoder = decodingContext.decoder;
+          var contextCache = decodingContext.contextCache;
+          while (newSymbols.length < numberOfNewSymbols) {
+            var deltaHeight = decodeInteger(contextCache, 'IADH', decoder);
+            // 6.5.6
+            currentHeight += deltaHeight;
+            var currentWidth = 0;
+            var totalWidth = 0;
+            while (true) {
+              var deltaWidth = decodeInteger(contextCache, 'IADW', decoder);
+              // 6.5.7
+              if (deltaWidth === null) {
+                break;
+              }
+              // OOB
+              currentWidth += deltaWidth;
+              totalWidth += currentWidth;
+              var bitmap;
+              if (refinement) {
+                // 6.5.8.2 Refinement/aggregate-coded symbol bitmap
+                var numberOfInstances = decodeInteger(contextCache, 'IAAI', decoder);
+                if (numberOfInstances > 1) {
+                  bitmap = decodeTextRegion(huffman, refinement, currentWidth, currentHeight, 0, numberOfInstances, 1, //strip size
+                  symbols.concat(newSymbols), symbolCodeLength, 0, //transposed
+                  0, //ds offset
+                  1, //top left 7.4.3.1.1
+                  0, //OR operator
+                  huffmanTables, refinementTemplateIndex, refinementAt, decodingContext);
+                } else {
+                  var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);
+                  var rdx = decodeInteger(contextCache, 'IARDX', decoder);
+                  // 6.4.11.3
+                  var rdy = decodeInteger(contextCache, 'IARDY', decoder);
+                  // 6.4.11.4
+                  var symbol = symbolId < symbols.length ? symbols[symbolId] : newSymbols[symbolId - symbols.length];
+                  bitmap = decodeRefinement(currentWidth, currentHeight, refinementTemplateIndex, symbol, rdx, rdy, false, refinementAt, decodingContext);
+                }
+              } else {
+                // 6.5.8.1 Direct-coded symbol bitmap
+                bitmap = decodeBitmap(false, currentWidth, currentHeight, templateIndex, false, null, at, decodingContext);
+              }
+              newSymbols.push(bitmap);
+            }
+          }
+          // 6.5.10 Exported symbols
+          var exportedSymbols = [];
+          var flags = [], currentFlag = false;
+          var totalSymbolsLength = symbols.length + numberOfNewSymbols;
+          while (flags.length < totalSymbolsLength) {
+            var runLength = decodeInteger(contextCache, 'IAEX', decoder);
+            while (runLength--) {
+              flags.push(currentFlag);
+            }
+            currentFlag = !currentFlag;
+          }
+          for (var i = 0, ii = symbols.length; i < ii; i++) {
+            if (flags[i]) {
+              exportedSymbols.push(symbols[i]);
+            }
+          }
+          for (var j = 0; j < numberOfNewSymbols; i++, j++) {
+            if (flags[i]) {
+              exportedSymbols.push(newSymbols[j]);
+            }
+          }
+          return exportedSymbols;
+        }
+        function decodeTextRegion(huffman, refinement, width, height, defaultPixelValue, numberOfSymbolInstances, stripSize, inputSymbols, symbolCodeLength, transposed, dsOffset, referenceCorner, combinationOperator, huffmanTables, refinementTemplateIndex, refinementAt, decodingContext) {
+          if (huffman) {
+            error('JBIG2 error: huffman is not supported');
+          }
+          // Prepare bitmap
+          var bitmap = [];
+          var i, row;
+          for (i = 0; i < height; i++) {
+            row = new Uint8Array(width);
+            if (defaultPixelValue) {
+              for (var j = 0; j < width; j++) {
+                row[j] = defaultPixelValue;
+              }
+            }
+            bitmap.push(row);
+          }
+          var decoder = decodingContext.decoder;
+          var contextCache = decodingContext.contextCache;
+          var stripT = -decodeInteger(contextCache, 'IADT', decoder);
+          // 6.4.6
+          var firstS = 0;
+          i = 0;
+          while (i < numberOfSymbolInstances) {
+            var deltaT = decodeInteger(contextCache, 'IADT', decoder);
+            // 6.4.6
+            stripT += deltaT;
+            var deltaFirstS = decodeInteger(contextCache, 'IAFS', decoder);
+            // 6.4.7
+            firstS += deltaFirstS;
+            var currentS = firstS;
+            do {
+              var currentT = stripSize === 1 ? 0 : decodeInteger(contextCache, 'IAIT', decoder);
+              // 6.4.9
+              var t = stripSize * stripT + currentT;
+              var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);
+              var applyRefinement = refinement && decodeInteger(contextCache, 'IARI', decoder);
+              var symbolBitmap = inputSymbols[symbolId];
+              var symbolWidth = symbolBitmap[0].length;
+              var symbolHeight = symbolBitmap.length;
+              if (applyRefinement) {
+                var rdw = decodeInteger(contextCache, 'IARDW', decoder);
+                // 6.4.11.1
+                var rdh = decodeInteger(contextCache, 'IARDH', decoder);
+                // 6.4.11.2
+                var rdx = decodeInteger(contextCache, 'IARDX', decoder);
+                // 6.4.11.3
+                var rdy = decodeInteger(contextCache, 'IARDY', decoder);
+                // 6.4.11.4
+                symbolWidth += rdw;
+                symbolHeight += rdh;
+                symbolBitmap = decodeRefinement(symbolWidth, symbolHeight, refinementTemplateIndex, symbolBitmap, (rdw >> 1) + rdx, (rdh >> 1) + rdy, false, refinementAt, decodingContext);
+              }
+              var offsetT = t - (referenceCorner & 1 ? 0 : symbolHeight);
+              var offsetS = currentS - (referenceCorner & 2 ? symbolWidth : 0);
+              var s2, t2, symbolRow;
+              if (transposed) {
+                // Place Symbol Bitmap from T1,S1
+                for (s2 = 0; s2 < symbolHeight; s2++) {
+                  row = bitmap[offsetS + s2];
+                  if (!row) {
+                    continue;
+                  }
+                  symbolRow = symbolBitmap[s2];
+                  // To ignore Parts of Symbol bitmap which goes
+                  // outside bitmap region
+                  var maxWidth = Math.min(width - offsetT, symbolWidth);
+                  switch (combinationOperator) {
+                  case 0:
+                    // OR
+                    for (t2 = 0; t2 < maxWidth; t2++) {
+                      row[offsetT + t2] |= symbolRow[t2];
+                    }
+                    break;
+                  case 2:
+                    // XOR
+                    for (t2 = 0; t2 < maxWidth; t2++) {
+                      row[offsetT + t2] ^= symbolRow[t2];
+                    }
+                    break;
+                  default:
+                    error('JBIG2 error: operator ' + combinationOperator + ' is not supported');
+                  }
+                }
+                currentS += symbolHeight - 1;
+              } else {
+                for (t2 = 0; t2 < symbolHeight; t2++) {
+                  row = bitmap[offsetT + t2];
+                  if (!row) {
+                    continue;
+                  }
+                  symbolRow = symbolBitmap[t2];
+                  switch (combinationOperator) {
+                  case 0:
+                    // OR
+                    for (s2 = 0; s2 < symbolWidth; s2++) {
+                      row[offsetS + s2] |= symbolRow[s2];
+                    }
+                    break;
+                  case 2:
+                    // XOR
+                    for (s2 = 0; s2 < symbolWidth; s2++) {
+                      row[offsetS + s2] ^= symbolRow[s2];
+                    }
+                    break;
+                  default:
+                    error('JBIG2 error: operator ' + combinationOperator + ' is not supported');
+                  }
+                }
+                currentS += symbolWidth - 1;
+              }
+              i++;
+              var deltaS = decodeInteger(contextCache, 'IADS', decoder);
+              // 6.4.8
+              if (deltaS === null) {
+                break;
+              }
+              // OOB
+              currentS += deltaS + dsOffset;
+            } while (true);
+          }
+          return bitmap;
+        }
+        function readSegmentHeader(data, start) {
+          var segmentHeader = {};
+          segmentHeader.number = readUint32(data, start);
+          var flags = data[start + 4];
+          var segmentType = flags & 0x3F;
+          if (!SegmentTypes[segmentType]) {
+            error('JBIG2 error: invalid segment type: ' + segmentType);
+          }
+          segmentHeader.type = segmentType;
+          segmentHeader.typeName = SegmentTypes[segmentType];
+          segmentHeader.deferredNonRetain = !!(flags & 0x80);
+          var pageAssociationFieldSize = !!(flags & 0x40);
+          var referredFlags = data[start + 5];
+          var referredToCount = referredFlags >> 5 & 7;
+          var retainBits = [referredFlags & 31];
+          var position = start + 6;
+          if (referredFlags === 7) {
+            referredToCount = readUint32(data, position - 1) & 0x1FFFFFFF;
+            position += 3;
+            var bytes = referredToCount + 7 >> 3;
+            retainBits[0] = data[position++];
+            while (--bytes > 0) {
+              retainBits.push(data[position++]);
+            }
+          } else if (referredFlags === 5 || referredFlags === 6) {
+            error('JBIG2 error: invalid referred-to flags');
+          }
+          segmentHeader.retainBits = retainBits;
+          var referredToSegmentNumberSize = segmentHeader.number <= 256 ? 1 : segmentHeader.number <= 65536 ? 2 : 4;
+          var referredTo = [];
+          var i, ii;
+          for (i = 0; i < referredToCount; i++) {
+            var number = referredToSegmentNumberSize === 1 ? data[position] : referredToSegmentNumberSize === 2 ? readUint16(data, position) : readUint32(data, position);
+            referredTo.push(number);
+            position += referredToSegmentNumberSize;
+          }
+          segmentHeader.referredTo = referredTo;
+          if (!pageAssociationFieldSize) {
+            segmentHeader.pageAssociation = data[position++];
+          } else {
+            segmentHeader.pageAssociation = readUint32(data, position);
+            position += 4;
+          }
+          segmentHeader.length = readUint32(data, position);
+          position += 4;
+          if (segmentHeader.length === 0xFFFFFFFF) {
+            // 7.2.7 Segment data length, unknown segment length
+            if (segmentType === 38) {
+              // ImmediateGenericRegion
+              var genericRegionInfo = readRegionSegmentInformation(data, position);
+              var genericRegionSegmentFlags = data[position + RegionSegmentInformationFieldLength];
+              var genericRegionMmr = !!(genericRegionSegmentFlags & 1);
+              // searching for the segment end
+              var searchPatternLength = 6;
+              var searchPattern = new Uint8Array(searchPatternLength);
+              if (!genericRegionMmr) {
+                searchPattern[0] = 0xFF;
+                searchPattern[1] = 0xAC;
+              }
+              searchPattern[2] = genericRegionInfo.height >>> 24 & 0xFF;
+              searchPattern[3] = genericRegionInfo.height >> 16 & 0xFF;
+              searchPattern[4] = genericRegionInfo.height >> 8 & 0xFF;
+              searchPattern[5] = genericRegionInfo.height & 0xFF;
+              for (i = position, ii = data.length; i < ii; i++) {
+                var j = 0;
+                while (j < searchPatternLength && searchPattern[j] === data[i + j]) {
+                  j++;
+                }
+                if (j === searchPatternLength) {
+                  segmentHeader.length = i + searchPatternLength;
+                  break;
+                }
+              }
+              if (segmentHeader.length === 0xFFFFFFFF) {
+                error('JBIG2 error: segment end was not found');
+              }
+            } else {
+              error('JBIG2 error: invalid unknown segment length');
+            }
+          }
+          segmentHeader.headerEnd = position;
+          return segmentHeader;
+        }
+        function readSegments(header, data, start, end) {
+          var segments = [];
+          var position = start;
+          while (position < end) {
+            var segmentHeader = readSegmentHeader(data, position);
+            position = segmentHeader.headerEnd;
+            var segment = {
+              header: segmentHeader,
+              data: data
+            };
+            if (!header.randomAccess) {
+              segment.start = position;
+              position += segmentHeader.length;
+              segment.end = position;
+            }
+            segments.push(segment);
+            if (segmentHeader.type === 51) {
+              break;
+            }
+          }
+          // end of file is found
+          if (header.randomAccess) {
+            for (var i = 0, ii = segments.length; i < ii; i++) {
+              segments[i].start = position;
+              position += segments[i].header.length;
+              segments[i].end = position;
+            }
+          }
+          return segments;
+        }
+        // 7.4.1 Region segment information field
+        function readRegionSegmentInformation(data, start) {
+          return {
+            width: readUint32(data, start),
+            height: readUint32(data, start + 4),
+            x: readUint32(data, start + 8),
+            y: readUint32(data, start + 12),
+            combinationOperator: data[start + 16] & 7
+          };
+        }
+        var RegionSegmentInformationFieldLength = 17;
+        function processSegment(segment, visitor) {
+          var header = segment.header;
+          var data = segment.data, position = segment.start, end = segment.end;
+          var args, at, i, atLength;
+          switch (header.type) {
+          case 0:
+            // SymbolDictionary
+            // 7.4.2 Symbol dictionary segment syntax
+            var dictionary = {};
+            var dictionaryFlags = readUint16(data, position);
+            // 7.4.2.1.1
+            dictionary.huffman = !!(dictionaryFlags & 1);
+            dictionary.refinement = !!(dictionaryFlags & 2);
+            dictionary.huffmanDHSelector = dictionaryFlags >> 2 & 3;
+            dictionary.huffmanDWSelector = dictionaryFlags >> 4 & 3;
+            dictionary.bitmapSizeSelector = dictionaryFlags >> 6 & 1;
+            dictionary.aggregationInstancesSelector = dictionaryFlags >> 7 & 1;
+            dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256);
+            dictionary.bitmapCodingContextRetained = !!(dictionaryFlags & 512);
+            dictionary.template = dictionaryFlags >> 10 & 3;
+            dictionary.refinementTemplate = dictionaryFlags >> 12 & 1;
+            position += 2;
+            if (!dictionary.huffman) {
+              atLength = dictionary.template === 0 ? 4 : 1;
+              at = [];
+              for (i = 0; i < atLength; i++) {
+                at.push({
+                  x: readInt8(data, position),
+                  y: readInt8(data, position + 1)
+                });
+                position += 2;
+              }
+              dictionary.at = at;
+            }
+            if (dictionary.refinement && !dictionary.refinementTemplate) {
+              at = [];
+              for (i = 0; i < 2; i++) {
+                at.push({
+                  x: readInt8(data, position),
+                  y: readInt8(data, position + 1)
+                });
+                position += 2;
+              }
+              dictionary.refinementAt = at;
+            }
+            dictionary.numberOfExportedSymbols = readUint32(data, position);
+            position += 4;
+            dictionary.numberOfNewSymbols = readUint32(data, position);
+            position += 4;
+            args = [
+              dictionary,
+              header.number,
+              header.referredTo,
+              data,
+              position,
+              end
+            ];
+            break;
+          case 6:
+          // ImmediateTextRegion
+          case 7:
+            // ImmediateLosslessTextRegion
+            var textRegion = {};
+            textRegion.info = readRegionSegmentInformation(data, position);
+            position += RegionSegmentInformationFieldLength;
+            var textRegionSegmentFlags = readUint16(data, position);
+            position += 2;
+            textRegion.huffman = !!(textRegionSegmentFlags & 1);
+            textRegion.refinement = !!(textRegionSegmentFlags & 2);
+            textRegion.stripSize = 1 << (textRegionSegmentFlags >> 2 & 3);
+            textRegion.referenceCorner = textRegionSegmentFlags >> 4 & 3;
+            textRegion.transposed = !!(textRegionSegmentFlags & 64);
+            textRegion.combinationOperator = textRegionSegmentFlags >> 7 & 3;
+            textRegion.defaultPixelValue = textRegionSegmentFlags >> 9 & 1;
+            textRegion.dsOffset = textRegionSegmentFlags << 17 >> 27;
+            textRegion.refinementTemplate = textRegionSegmentFlags >> 15 & 1;
+            if (textRegion.huffman) {
+              var textRegionHuffmanFlags = readUint16(data, position);
+              position += 2;
+              textRegion.huffmanFS = textRegionHuffmanFlags & 3;
+              textRegion.huffmanDS = textRegionHuffmanFlags >> 2 & 3;
+              textRegion.huffmanDT = textRegionHuffmanFlags >> 4 & 3;
+              textRegion.huffmanRefinementDW = textRegionHuffmanFlags >> 6 & 3;
+              textRegion.huffmanRefinementDH = textRegionHuffmanFlags >> 8 & 3;
+              textRegion.huffmanRefinementDX = textRegionHuffmanFlags >> 10 & 3;
+              textRegion.huffmanRefinementDY = textRegionHuffmanFlags >> 12 & 3;
+              textRegion.huffmanRefinementSizeSelector = !!(textRegionHuffmanFlags & 14);
+            }
+            if (textRegion.refinement && !textRegion.refinementTemplate) {
+              at = [];
+              for (i = 0; i < 2; i++) {
+                at.push({
+                  x: readInt8(data, position),
+                  y: readInt8(data, position + 1)
+                });
+                position += 2;
+              }
+              textRegion.refinementAt = at;
+            }
+            textRegion.numberOfSymbolInstances = readUint32(data, position);
+            position += 4;
+            // TODO 7.4.3.1.7 Symbol ID Huffman table decoding
+            if (textRegion.huffman) {
+              error('JBIG2 error: huffman is not supported');
+            }
+            args = [
+              textRegion,
+              header.referredTo,
+              data,
+              position,
+              end
+            ];
+            break;
+          case 38:
+          // ImmediateGenericRegion
+          case 39:
+            // ImmediateLosslessGenericRegion
+            var genericRegion = {};
+            genericRegion.info = readRegionSegmentInformation(data, position);
+            position += RegionSegmentInformationFieldLength;
+            var genericRegionSegmentFlags = data[position++];
+            genericRegion.mmr = !!(genericRegionSegmentFlags & 1);
+            genericRegion.template = genericRegionSegmentFlags >> 1 & 3;
+            genericRegion.prediction = !!(genericRegionSegmentFlags & 8);
+            if (!genericRegion.mmr) {
+              atLength = genericRegion.template === 0 ? 4 : 1;
+              at = [];
+              for (i = 0; i < atLength; i++) {
+                at.push({
+                  x: readInt8(data, position),
+                  y: readInt8(data, position + 1)
+                });
+                position += 2;
+              }
+              genericRegion.at = at;
+            }
+            args = [
+              genericRegion,
+              data,
+              position,
+              end
+            ];
+            break;
+          case 48:
+            // PageInformation
+            var pageInfo = {
+              width: readUint32(data, position),
+              height: readUint32(data, position + 4),
+              resolutionX: readUint32(data, position + 8),
+              resolutionY: readUint32(data, position + 12)
+            };
+            if (pageInfo.height === 0xFFFFFFFF) {
+              delete pageInfo.height;
+            }
+            var pageSegmentFlags = data[position + 16];
+            var pageStripingInformation = readUint16(data, position + 17);
+            pageInfo.lossless = !!(pageSegmentFlags & 1);
+            pageInfo.refinement = !!(pageSegmentFlags & 2);
+            pageInfo.defaultPixelValue = pageSegmentFlags >> 2 & 1;
+            pageInfo.combinationOperator = pageSegmentFlags >> 3 & 3;
+            pageInfo.requiresBuffer = !!(pageSegmentFlags & 32);
+            pageInfo.combinationOperatorOverride = !!(pageSegmentFlags & 64);
+            args = [pageInfo];
+            break;
+          case 49:
+            // EndOfPage
+            break;
+          case 50:
+            // EndOfStripe
+            break;
+          case 51:
+            // EndOfFile
+            break;
+          case 62:
+            // 7.4.15 defines 2 extension types which
+            // are comments and can be ignored.
+            break;
+          default:
+            error('JBIG2 error: segment type ' + header.typeName + '(' + header.type + ') is not implemented');
+          }
+          var callbackName = 'on' + header.typeName;
+          if (callbackName in visitor) {
+            visitor[callbackName].apply(visitor, args);
+          }
+        }
+        function processSegments(segments, visitor) {
+          for (var i = 0, ii = segments.length; i < ii; i++) {
+            processSegment(segments[i], visitor);
+          }
+        }
+        function parseJbig2(data, start, end) {
+          var position = start;
+          if (data[position] !== 0x97 || data[position + 1] !== 0x4A || data[position + 2] !== 0x42 || data[position + 3] !== 0x32 || data[position + 4] !== 0x0D || data[position + 5] !== 0x0A || data[position + 6] !== 0x1A || data[position + 7] !== 0x0A) {
+            error('JBIG2 error: invalid header');
+          }
+          var header = {};
+          position += 8;
+          var flags = data[position++];
+          header.randomAccess = !(flags & 1);
+          if (!(flags & 2)) {
+            header.numberOfPages = readUint32(data, position);
+            position += 4;
+          }
+          var segments = readSegments(header, data, position, end);
+          error('Not implemented');
+        }
+        // processSegments(segments, new SimpleSegmentVisitor());
+        function parseJbig2Chunks(chunks) {
+          var visitor = new SimpleSegmentVisitor();
+          for (var i = 0, ii = chunks.length; i < ii; i++) {
+            var chunk = chunks[i];
+            var segments = readSegments({}, chunk.data, chunk.start, chunk.end);
+            processSegments(segments, visitor);
+          }
+          return visitor.buffer;
+        }
+        function SimpleSegmentVisitor() {
+        }
+        SimpleSegmentVisitor.prototype = {
+          onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) {
+            this.currentPageInfo = info;
+            var rowSize = info.width + 7 >> 3;
+            var buffer = new Uint8Array(rowSize * info.height);
+            // The contents of ArrayBuffers are initialized to 0.
+            // Fill the buffer with 0xFF only if info.defaultPixelValue is set
+            if (info.defaultPixelValue) {
+              for (var i = 0, ii = buffer.length; i < ii; i++) {
+                buffer[i] = 0xFF;
+              }
+            }
+            this.buffer = buffer;
+          },
+          drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) {
+            var pageInfo = this.currentPageInfo;
+            var width = regionInfo.width, height = regionInfo.height;
+            var rowSize = pageInfo.width + 7 >> 3;
+            var combinationOperator = pageInfo.combinationOperatorOverride ? regionInfo.combinationOperator : pageInfo.combinationOperator;
+            var buffer = this.buffer;
+            var mask0 = 128 >> (regionInfo.x & 7);
+            var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);
+            var i, j, mask, offset;
+            switch (combinationOperator) {
+            case 0:
+              // OR
+              for (i = 0; i < height; i++) {
+                mask = mask0;
+                offset = offset0;
+                for (j = 0; j < width; j++) {
+                  if (bitmap[i][j]) {
+                    buffer[offset] |= mask;
+                  }
+                  mask >>= 1;
+                  if (!mask) {
+                    mask = 128;
+                    offset++;
+                  }
+                }
+                offset0 += rowSize;
+              }
+              break;
+            case 2:
+              // XOR
+              for (i = 0; i < height; i++) {
+                mask = mask0;
+                offset = offset0;
+                for (j = 0; j < width; j++) {
+                  if (bitmap[i][j]) {
+                    buffer[offset] ^= mask;
+                  }
+                  mask >>= 1;
+                  if (!mask) {
+                    mask = 128;
+                    offset++;
+                  }
+                }
+                offset0 += rowSize;
+              }
+              break;
+            default:
+              error('JBIG2 error: operator ' + combinationOperator + ' is not supported');
+            }
+          },
+          onImmediateGenericRegion: function SimpleSegmentVisitor_onImmediateGenericRegion(region, data, start, end) {
+            var regionInfo = region.info;
+            var decodingContext = new DecodingContext(data, start, end);
+            var bitmap = decodeBitmap(region.mmr, regionInfo.width, regionInfo.height, region.template, region.prediction, null, region.at, decodingContext);
+            this.drawBitmap(regionInfo, bitmap);
+          },
+          onImmediateLosslessGenericRegion: function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() {
+            this.onImmediateGenericRegion.apply(this, arguments);
+          },
+          onSymbolDictionary: function SimpleSegmentVisitor_onSymbolDictionary(dictionary, currentSegment, referredSegments, data, start, end) {
+            var huffmanTables;
+            if (dictionary.huffman) {
+              error('JBIG2 error: huffman is not supported');
+            }
+            // Combines exported symbols from all referred segments
+            var symbols = this.symbols;
+            if (!symbols) {
+              this.symbols = symbols = {};
+            }
+            var inputSymbols = [];
+            for (var i = 0, ii = referredSegments.length; i < ii; i++) {
+              inputSymbols = inputSymbols.concat(symbols[referredSegments[i]]);
+            }
+            var decodingContext = new DecodingContext(data, start, end);
+            symbols[currentSegment] = decodeSymbolDictionary(dictionary.huffman, dictionary.refinement, inputSymbols, dictionary.numberOfNewSymbols, dictionary.numberOfExportedSymbols, huffmanTables, dictionary.template, dictionary.at, dictionary.refinementTemplate, dictionary.refinementAt, decodingContext);
+          },
+          onImmediateTextRegion: function SimpleSegmentVisitor_onImmediateTextRegion(region, referredSegments, data, start, end) {
+            var regionInfo = region.info;
+            var huffmanTables;
+            // Combines exported symbols from all referred segments
+            var symbols = this.symbols;
+            var inputSymbols = [];
+            for (var i = 0, ii = referredSegments.length; i < ii; i++) {
+              inputSymbols = inputSymbols.concat(symbols[referredSegments[i]]);
+            }
+            var symbolCodeLength = log2(inputSymbols.length);
+            var decodingContext = new DecodingContext(data, start, end);
+            var bitmap = decodeTextRegion(region.huffman, region.refinement, regionInfo.width, regionInfo.height, region.defaultPixelValue, region.numberOfSymbolInstances, region.stripSize, inputSymbols, symbolCodeLength, region.transposed, region.dsOffset, region.referenceCorner, region.combinationOperator, huffmanTables, region.refinementTemplate, region.refinementAt, decodingContext);
+            this.drawBitmap(regionInfo, bitmap);
+          },
+          onImmediateLosslessTextRegion: function SimpleSegmentVisitor_onImmediateLosslessTextRegion() {
+            this.onImmediateTextRegion.apply(this, arguments);
+          }
+        };
+        function Jbig2Image() {
+        }
+        Jbig2Image.prototype = {
+          parseChunks: function Jbig2Image_parseChunks(chunks) {
+            return parseJbig2Chunks(chunks);
+          }
+        };
+        return Jbig2Image;
+      }();
+      exports.Jbig2Image = Jbig2Image;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreJpg = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var error = sharedUtil.error;
+      /**
+       * This code was forked from https://github.com/notmasteryet/jpgjs.
+       * The original version was created by GitHub user notmasteryet.
+       *
+       * - The JPEG specification can be found in the ITU CCITT Recommendation T.81
+       *   (www.w3.org/Graphics/JPEG/itu-t81.pdf)
+       * - The JFIF specification can be found in the JPEG File Interchange Format
+       *   (www.w3.org/Graphics/JPEG/jfif3.pdf)
+       * - The Adobe Application-Specific JPEG markers in the
+       *   Supporting the DCT Filters in PostScript Level 2, Technical Note #5116
+       *   (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf)
+       */
+      var JpegImage = function JpegImageClosure() {
+        var dctZigZag = new Uint8Array([
+          0,
+          1,
+          8,
+          16,
+          9,
+          2,
+          3,
+          10,
+          17,
+          24,
+          32,
+          25,
+          18,
+          11,
+          4,
+          5,
+          12,
+          19,
+          26,
+          33,
+          40,
+          48,
+          41,
+          34,
+          27,
+          20,
+          13,
+          6,
+          7,
+          14,
+          21,
+          28,
+          35,
+          42,
+          49,
+          56,
+          57,
+          50,
+          43,
+          36,
+          29,
+          22,
+          15,
+          23,
+          30,
+          37,
+          44,
+          51,
+          58,
+          59,
+          52,
+          45,
+          38,
+          31,
+          39,
+          46,
+          53,
+          60,
+          61,
+          54,
+          47,
+          55,
+          62,
+          63
+        ]);
+        var dctCos1 = 4017;
+        // cos(pi/16)
+        var dctSin1 = 799;
+        // sin(pi/16)
+        var dctCos3 = 3406;
+        // cos(3*pi/16)
+        var dctSin3 = 2276;
+        // sin(3*pi/16)
+        var dctCos6 = 1567;
+        // cos(6*pi/16)
+        var dctSin6 = 3784;
+        // sin(6*pi/16)
+        var dctSqrt2 = 5793;
+        // sqrt(2)
+        var dctSqrt1d2 = 2896;
+        // sqrt(2) / 2
+        function JpegImage() {
+          this.decodeTransform = null;
+          this.colorTransform = -1;
+        }
+        function buildHuffmanTable(codeLengths, values) {
+          var k = 0, code = [], i, j, length = 16;
+          while (length > 0 && !codeLengths[length - 1]) {
+            length--;
+          }
+          code.push({
+            children: [],
+            index: 0
+          });
+          var p = code[0], q;
+          for (i = 0; i < length; i++) {
+            for (j = 0; j < codeLengths[i]; j++) {
+              p = code.pop();
+              p.children[p.index] = values[k];
+              while (p.index > 0) {
+                p = code.pop();
+              }
+              p.index++;
+              code.push(p);
+              while (code.length <= i) {
+                code.push(q = {
+                  children: [],
+                  index: 0
+                });
+                p.children[p.index] = q.children;
+                p = q;
+              }
+              k++;
+            }
+            if (i + 1 < length) {
+              // p here points to last code
+              code.push(q = {
+                children: [],
+                index: 0
+              });
+              p.children[p.index] = q.children;
+              p = q;
+            }
+          }
+          return code[0].children;
+        }
+        function getBlockBufferOffset(component, row, col) {
+          return 64 * ((component.blocksPerLine + 1) * row + col);
+        }
+        function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
+          var mcusPerLine = frame.mcusPerLine;
+          var progressive = frame.progressive;
+          var startOffset = offset, bitsData = 0, bitsCount = 0;
+          function readBit() {
+            if (bitsCount > 0) {
+              bitsCount--;
+              return bitsData >> bitsCount & 1;
+            }
+            bitsData = data[offset++];
+            if (bitsData === 0xFF) {
+              var nextByte = data[offset++];
+              if (nextByte) {
+                error('JPEG error: unexpected marker ' + (bitsData << 8 | nextByte).toString(16));
+              }
+            }
+            // unstuff 0
+            bitsCount = 7;
+            return bitsData >>> 7;
+          }
+          function decodeHuffman(tree) {
+            var node = tree;
+            while (true) {
+              node = node[readBit()];
+              if (typeof node === 'number') {
+                return node;
+              }
+              if (typeof node !== 'object') {
+                error('JPEG error: invalid huffman sequence');
+              }
+            }
+          }
+          function receive(length) {
+            var n = 0;
+            while (length > 0) {
+              n = n << 1 | readBit();
+              length--;
+            }
+            return n;
+          }
+          function receiveAndExtend(length) {
+            if (length === 1) {
+              return readBit() === 1 ? 1 : -1;
+            }
+            var n = receive(length);
+            if (n >= 1 << length - 1) {
+              return n;
+            }
+            return n + (-1 << length) + 1;
+          }
+          function decodeBaseline(component, offset) {
+            var t = decodeHuffman(component.huffmanTableDC);
+            var diff = t === 0 ? 0 : receiveAndExtend(t);
+            component.blockData[offset] = component.pred += diff;
+            var k = 1;
+            while (k < 64) {
+              var rs = decodeHuffman(component.huffmanTableAC);
+              var s = rs & 15, r = rs >> 4;
+              if (s === 0) {
+                if (r < 15) {
+                  break;
+                }
+                k += 16;
+                continue;
+              }
+              k += r;
+              var z = dctZigZag[k];
+              component.blockData[offset + z] = receiveAndExtend(s);
+              k++;
+            }
+          }
+          function decodeDCFirst(component, offset) {
+            var t = decodeHuffman(component.huffmanTableDC);
+            var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
+            component.blockData[offset] = component.pred += diff;
+          }
+          function decodeDCSuccessive(component, offset) {
+            component.blockData[offset] |= readBit() << successive;
+          }
+          var eobrun = 0;
+          function decodeACFirst(component, offset) {
+            if (eobrun > 0) {
+              eobrun--;
+              return;
+            }
+            var k = spectralStart, e = spectralEnd;
+            while (k <= e) {
+              var rs = decodeHuffman(component.huffmanTableAC);
+              var s = rs & 15, r = rs >> 4;
+              if (s === 0) {
+                if (r < 15) {
+                  eobrun = receive(r) + (1 << r) - 1;
+                  break;
+                }
+                k += 16;
+                continue;
+              }
+              k += r;
+              var z = dctZigZag[k];
+              component.blockData[offset + z] = receiveAndExtend(s) * (1 << successive);
+              k++;
+            }
+          }
+          var successiveACState = 0, successiveACNextValue;
+          function decodeACSuccessive(component, offset) {
+            var k = spectralStart;
+            var e = spectralEnd;
+            var r = 0;
+            var s;
+            var rs;
+            while (k <= e) {
+              var z = dctZigZag[k];
+              switch (successiveACState) {
+              case 0:
+                // initial state
+                rs = decodeHuffman(component.huffmanTableAC);
+                s = rs & 15;
+                r = rs >> 4;
+                if (s === 0) {
+                  if (r < 15) {
+                    eobrun = receive(r) + (1 << r);
+                    successiveACState = 4;
+                  } else {
+                    r = 16;
+                    successiveACState = 1;
+                  }
+                } else {
+                  if (s !== 1) {
+                    error('JPEG error: invalid ACn encoding');
+                  }
+                  successiveACNextValue = receiveAndExtend(s);
+                  successiveACState = r ? 2 : 3;
+                }
+                continue;
+              case 1:
+              // skipping r zero items
+              case 2:
+                if (component.blockData[offset + z]) {
+                  component.blockData[offset + z] += readBit() << successive;
+                } else {
+                  r--;
+                  if (r === 0) {
+                    successiveACState = successiveACState === 2 ? 3 : 0;
+                  }
+                }
+                break;
+              case 3:
+                // set value for a zero item
+                if (component.blockData[offset + z]) {
+                  component.blockData[offset + z] += readBit() << successive;
+                } else {
+                  component.blockData[offset + z] = successiveACNextValue << successive;
+                  successiveACState = 0;
+                }
+                break;
+              case 4:
+                // eob
+                if (component.blockData[offset + z]) {
+                  component.blockData[offset + z] += readBit() << successive;
+                }
+                break;
+              }
+              k++;
+            }
+            if (successiveACState === 4) {
+              eobrun--;
+              if (eobrun === 0) {
+                successiveACState = 0;
+              }
+            }
+          }
+          function decodeMcu(component, decode, mcu, row, col) {
+            var mcuRow = mcu / mcusPerLine | 0;
+            var mcuCol = mcu % mcusPerLine;
+            var blockRow = mcuRow * component.v + row;
+            var blockCol = mcuCol * component.h + col;
+            var offset = getBlockBufferOffset(component, blockRow, blockCol);
+            decode(component, offset);
+          }
+          function decodeBlock(component, decode, mcu) {
+            var blockRow = mcu / component.blocksPerLine | 0;
+            var blockCol = mcu % component.blocksPerLine;
+            var offset = getBlockBufferOffset(component, blockRow, blockCol);
+            decode(component, offset);
+          }
+          var componentsLength = components.length;
+          var component, i, j, k, n;
+          var decodeFn;
+          if (progressive) {
+            if (spectralStart === 0) {
+              decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+            } else {
+              decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+            }
+          } else {
+            decodeFn = decodeBaseline;
+          }
+          var mcu = 0, marker;
+          var mcuExpected;
+          if (componentsLength === 1) {
+            mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+          } else {
+            mcuExpected = mcusPerLine * frame.mcusPerColumn;
+          }
+          if (!resetInterval) {
+            resetInterval = mcuExpected;
+          }
+          var h, v;
+          while (mcu < mcuExpected) {
+            // reset interval stuff
+            for (i = 0; i < componentsLength; i++) {
+              components[i].pred = 0;
+            }
+            eobrun = 0;
+            if (componentsLength === 1) {
+              component = components[0];
+              for (n = 0; n < resetInterval; n++) {
+                decodeBlock(component, decodeFn, mcu);
+                mcu++;
+              }
+            } else {
+              for (n = 0; n < resetInterval; n++) {
+                for (i = 0; i < componentsLength; i++) {
+                  component = components[i];
+                  h = component.h;
+                  v = component.v;
+                  for (j = 0; j < v; j++) {
+                    for (k = 0; k < h; k++) {
+                      decodeMcu(component, decodeFn, mcu, j, k);
+                    }
+                  }
+                }
+                mcu++;
+              }
+            }
+            // find marker
+            bitsCount = 0;
+            marker = data[offset] << 8 | data[offset + 1];
+            // Some bad images seem to pad Scan blocks with zero bytes, skip past
+            // those to attempt to find a valid marker (fixes issue4090.pdf).
+            while (data[offset] === 0x00 && offset < data.length - 1) {
+              offset++;
+              marker = data[offset] << 8 | data[offset + 1];
+            }
+            if (marker <= 0xFF00) {
+              error('JPEG error: marker was not found');
+            }
+            if (marker >= 0xFFD0 && marker <= 0xFFD7) {
+              // RSTx
+              offset += 2;
+            } else {
+              break;
+            }
+          }
+          return offset - startOffset;
+        }
+        // A port of poppler's IDCT method which in turn is taken from:
+        //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,
+        //   'Practical Fast 1-D DCT Algorithms with 11 Multiplications',
+        //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
+        //   988-991.
+        function quantizeAndInverse(component, blockBufferOffset, p) {
+          var qt = component.quantizationTable, blockData = component.blockData;
+          var v0, v1, v2, v3, v4, v5, v6, v7;
+          var p0, p1, p2, p3, p4, p5, p6, p7;
+          var t;
+          if (!qt) {
+            error('JPEG error: missing required Quantization Table.');
+          }
+          // inverse DCT on rows
+          for (var row = 0; row < 64; row += 8) {
+            // gather block data
+            p0 = blockData[blockBufferOffset + row];
+            p1 = blockData[blockBufferOffset + row + 1];
+            p2 = blockData[blockBufferOffset + row + 2];
+            p3 = blockData[blockBufferOffset + row + 3];
+            p4 = blockData[blockBufferOffset + row + 4];
+            p5 = blockData[blockBufferOffset + row + 5];
+            p6 = blockData[blockBufferOffset + row + 6];
+            p7 = blockData[blockBufferOffset + row + 7];
+            // dequant p0
+            p0 *= qt[row];
+            // check for all-zero AC coefficients
+            if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
+              t = dctSqrt2 * p0 + 512 >> 10;
+              p[row] = t;
+              p[row + 1] = t;
+              p[row + 2] = t;
+              p[row + 3] = t;
+              p[row + 4] = t;
+              p[row + 5] = t;
+              p[row + 6] = t;
+              p[row + 7] = t;
+              continue;
+            }
+            // dequant p1 ... p7
+            p1 *= qt[row + 1];
+            p2 *= qt[row + 2];
+            p3 *= qt[row + 3];
+            p4 *= qt[row + 4];
+            p5 *= qt[row + 5];
+            p6 *= qt[row + 6];
+            p7 *= qt[row + 7];
+            // stage 4
+            v0 = dctSqrt2 * p0 + 128 >> 8;
+            v1 = dctSqrt2 * p4 + 128 >> 8;
+            v2 = p2;
+            v3 = p6;
+            v4 = dctSqrt1d2 * (p1 - p7) + 128 >> 8;
+            v7 = dctSqrt1d2 * (p1 + p7) + 128 >> 8;
+            v5 = p3 << 4;
+            v6 = p5 << 4;
+            // stage 3
+            v0 = v0 + v1 + 1 >> 1;
+            v1 = v0 - v1;
+            t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;
+            v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;
+            v3 = t;
+            v4 = v4 + v6 + 1 >> 1;
+            v6 = v4 - v6;
+            v7 = v7 + v5 + 1 >> 1;
+            v5 = v7 - v5;
+            // stage 2
+            v0 = v0 + v3 + 1 >> 1;
+            v3 = v0 - v3;
+            v1 = v1 + v2 + 1 >> 1;
+            v2 = v1 - v2;
+            t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+            v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+            v7 = t;
+            t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+            v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+            v6 = t;
+            // stage 1
+            p[row] = v0 + v7;
+            p[row + 7] = v0 - v7;
+            p[row + 1] = v1 + v6;
+            p[row + 6] = v1 - v6;
+            p[row + 2] = v2 + v5;
+            p[row + 5] = v2 - v5;
+            p[row + 3] = v3 + v4;
+            p[row + 4] = v3 - v4;
+          }
+          // inverse DCT on columns
+          for (var col = 0; col < 8; ++col) {
+            p0 = p[col];
+            p1 = p[col + 8];
+            p2 = p[col + 16];
+            p3 = p[col + 24];
+            p4 = p[col + 32];
+            p5 = p[col + 40];
+            p6 = p[col + 48];
+            p7 = p[col + 56];
+            // check for all-zero AC coefficients
+            if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
+              t = dctSqrt2 * p0 + 8192 >> 14;
+              // convert to 8 bit
+              t = t < -2040 ? 0 : t >= 2024 ? 255 : t + 2056 >> 4;
+              blockData[blockBufferOffset + col] = t;
+              blockData[blockBufferOffset + col + 8] = t;
+              blockData[blockBufferOffset + col + 16] = t;
+              blockData[blockBufferOffset + col + 24] = t;
+              blockData[blockBufferOffset + col + 32] = t;
+              blockData[blockBufferOffset + col + 40] = t;
+              blockData[blockBufferOffset + col + 48] = t;
+              blockData[blockBufferOffset + col + 56] = t;
+              continue;
+            }
+            // stage 4
+            v0 = dctSqrt2 * p0 + 2048 >> 12;
+            v1 = dctSqrt2 * p4 + 2048 >> 12;
+            v2 = p2;
+            v3 = p6;
+            v4 = dctSqrt1d2 * (p1 - p7) + 2048 >> 12;
+            v7 = dctSqrt1d2 * (p1 + p7) + 2048 >> 12;
+            v5 = p3;
+            v6 = p5;
+            // stage 3
+            // Shift v0 by 128.5 << 5 here, so we don't need to shift p0...p7 when
+            // converting to UInt8 range later.
+            v0 = (v0 + v1 + 1 >> 1) + 4112;
+            v1 = v0 - v1;
+            t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;
+            v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;
+            v3 = t;
+            v4 = v4 + v6 + 1 >> 1;
+            v6 = v4 - v6;
+            v7 = v7 + v5 + 1 >> 1;
+            v5 = v7 - v5;
+            // stage 2
+            v0 = v0 + v3 + 1 >> 1;
+            v3 = v0 - v3;
+            v1 = v1 + v2 + 1 >> 1;
+            v2 = v1 - v2;
+            t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+            v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+            v7 = t;
+            t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+            v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+            v6 = t;
+            // stage 1
+            p0 = v0 + v7;
+            p7 = v0 - v7;
+            p1 = v1 + v6;
+            p6 = v1 - v6;
+            p2 = v2 + v5;
+            p5 = v2 - v5;
+            p3 = v3 + v4;
+            p4 = v3 - v4;
+            // convert to 8-bit integers
+            p0 = p0 < 16 ? 0 : p0 >= 4080 ? 255 : p0 >> 4;
+            p1 = p1 < 16 ? 0 : p1 >= 4080 ? 255 : p1 >> 4;
+            p2 = p2 < 16 ? 0 : p2 >= 4080 ? 255 : p2 >> 4;
+            p3 = p3 < 16 ? 0 : p3 >= 4080 ? 255 : p3 >> 4;
+            p4 = p4 < 16 ? 0 : p4 >= 4080 ? 255 : p4 >> 4;
+            p5 = p5 < 16 ? 0 : p5 >= 4080 ? 255 : p5 >> 4;
+            p6 = p6 < 16 ? 0 : p6 >= 4080 ? 255 : p6 >> 4;
+            p7 = p7 < 16 ? 0 : p7 >= 4080 ? 255 : p7 >> 4;
+            // store block data
+            blockData[blockBufferOffset + col] = p0;
+            blockData[blockBufferOffset + col + 8] = p1;
+            blockData[blockBufferOffset + col + 16] = p2;
+            blockData[blockBufferOffset + col + 24] = p3;
+            blockData[blockBufferOffset + col + 32] = p4;
+            blockData[blockBufferOffset + col + 40] = p5;
+            blockData[blockBufferOffset + col + 48] = p6;
+            blockData[blockBufferOffset + col + 56] = p7;
+          }
+        }
+        function buildComponentData(frame, component) {
+          var blocksPerLine = component.blocksPerLine;
+          var blocksPerColumn = component.blocksPerColumn;
+          var computationBuffer = new Int16Array(64);
+          for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+            for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+              var offset = getBlockBufferOffset(component, blockRow, blockCol);
+              quantizeAndInverse(component, offset, computationBuffer);
+            }
+          }
+          return component.blockData;
+        }
+        function clamp0to255(a) {
+          return a <= 0 ? 0 : a >= 255 ? 255 : a;
+        }
+        JpegImage.prototype = {
+          parse: function parse(data) {
+            function readUint16() {
+              var value = data[offset] << 8 | data[offset + 1];
+              offset += 2;
+              return value;
+            }
+            function readDataBlock() {
+              var length = readUint16();
+              var array = data.subarray(offset, offset + length - 2);
+              offset += array.length;
+              return array;
+            }
+            function prepareComponents(frame) {
+              var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);
+              var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);
+              for (var i = 0; i < frame.components.length; i++) {
+                component = frame.components[i];
+                var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / frame.maxH);
+                var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / frame.maxV);
+                var blocksPerLineForMcu = mcusPerLine * component.h;
+                var blocksPerColumnForMcu = mcusPerColumn * component.v;
+                var blocksBufferSize = 64 * blocksPerColumnForMcu * (blocksPerLineForMcu + 1);
+                component.blockData = new Int16Array(blocksBufferSize);
+                component.blocksPerLine = blocksPerLine;
+                component.blocksPerColumn = blocksPerColumn;
+              }
+              frame.mcusPerLine = mcusPerLine;
+              frame.mcusPerColumn = mcusPerColumn;
+            }
+            var offset = 0;
+            var jfif = null;
+            var adobe = null;
+            var frame, resetInterval;
+            var quantizationTables = [];
+            var huffmanTablesAC = [], huffmanTablesDC = [];
+            var fileMarker = readUint16();
+            if (fileMarker !== 0xFFD8) {
+              // SOI (Start of Image)
+              error('JPEG error: SOI not found');
+            }
+            fileMarker = readUint16();
+            while (fileMarker !== 0xFFD9) {
+              // EOI (End of image)
+              var i, j, l;
+              switch (fileMarker) {
+              case 0xFFE0:
+              // APP0 (Application Specific)
+              case 0xFFE1:
+              // APP1
+              case 0xFFE2:
+              // APP2
+              case 0xFFE3:
+              // APP3
+              case 0xFFE4:
+              // APP4
+              case 0xFFE5:
+              // APP5
+              case 0xFFE6:
+              // APP6
+              case 0xFFE7:
+              // APP7
+              case 0xFFE8:
+              // APP8
+              case 0xFFE9:
+              // APP9
+              case 0xFFEA:
+              // APP10
+              case 0xFFEB:
+              // APP11
+              case 0xFFEC:
+              // APP12
+              case 0xFFED:
+              // APP13
+              case 0xFFEE:
+              // APP14
+              case 0xFFEF:
+              // APP15
+              case 0xFFFE:
+                // COM (Comment)
+                var appData = readDataBlock();
+                if (fileMarker === 0xFFE0) {
+                  if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 && appData[3] === 0x46 && appData[4] === 0) {
+                    // 'JFIF\x00'
+                    jfif = {
+                      version: {
+                        major: appData[5],
+                        minor: appData[6]
+                      },
+                      densityUnits: appData[7],
+                      xDensity: appData[8] << 8 | appData[9],
+                      yDensity: appData[10] << 8 | appData[11],
+                      thumbWidth: appData[12],
+                      thumbHeight: appData[13],
+                      thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
+                    };
+                  }
+                }
+                // TODO APP1 - Exif
+                if (fileMarker === 0xFFEE) {
+                  if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F && appData[3] === 0x62 && appData[4] === 0x65) {
+                    // 'Adobe'
+                    adobe = {
+                      version: appData[5] << 8 | appData[6],
+                      flags0: appData[7] << 8 | appData[8],
+                      flags1: appData[9] << 8 | appData[10],
+                      transformCode: appData[11]
+                    };
+                  }
+                }
+                break;
+              case 0xFFDB:
+                // DQT (Define Quantization Tables)
+                var quantizationTablesLength = readUint16();
+                var quantizationTablesEnd = quantizationTablesLength + offset - 2;
+                var z;
+                while (offset < quantizationTablesEnd) {
+                  var quantizationTableSpec = data[offset++];
+                  var tableData = new Uint16Array(64);
+                  if (quantizationTableSpec >> 4 === 0) {
+                    // 8 bit values
+                    for (j = 0; j < 64; j++) {
+                      z = dctZigZag[j];
+                      tableData[z] = data[offset++];
+                    }
+                  } else if (quantizationTableSpec >> 4 === 1) {
+                    //16 bit
+                    for (j = 0; j < 64; j++) {
+                      z = dctZigZag[j];
+                      tableData[z] = readUint16();
+                    }
+                  } else {
+                    error('JPEG error: DQT - invalid table spec');
+                  }
+                  quantizationTables[quantizationTableSpec & 15] = tableData;
+                }
+                break;
+              case 0xFFC0:
+              // SOF0 (Start of Frame, Baseline DCT)
+              case 0xFFC1:
+              // SOF1 (Start of Frame, Extended DCT)
+              case 0xFFC2:
+                // SOF2 (Start of Frame, Progressive DCT)
+                if (frame) {
+                  error('JPEG error: Only single frame JPEGs supported');
+                }
+                readUint16();
+                // skip data length
+                frame = {};
+                frame.extended = fileMarker === 0xFFC1;
+                frame.progressive = fileMarker === 0xFFC2;
+                frame.precision = data[offset++];
+                frame.scanLines = readUint16();
+                frame.samplesPerLine = readUint16();
+                frame.components = [];
+                frame.componentIds = {};
+                var componentsCount = data[offset++], componentId;
+                var maxH = 0, maxV = 0;
+                for (i = 0; i < componentsCount; i++) {
+                  componentId = data[offset];
+                  var h = data[offset + 1] >> 4;
+                  var v = data[offset + 1] & 15;
+                  if (maxH < h) {
+                    maxH = h;
+                  }
+                  if (maxV < v) {
+                    maxV = v;
+                  }
+                  var qId = data[offset + 2];
+                  l = frame.components.push({
+                    h: h,
+                    v: v,
+                    quantizationId: qId,
+                    quantizationTable: null
+                  });
+                  // See comment below.
+                  frame.componentIds[componentId] = l - 1;
+                  offset += 3;
+                }
+                frame.maxH = maxH;
+                frame.maxV = maxV;
+                prepareComponents(frame);
+                break;
+              case 0xFFC4:
+                // DHT (Define Huffman Tables)
+                var huffmanLength = readUint16();
+                for (i = 2; i < huffmanLength;) {
+                  var huffmanTableSpec = data[offset++];
+                  var codeLengths = new Uint8Array(16);
+                  var codeLengthSum = 0;
+                  for (j = 0; j < 16; j++, offset++) {
+                    codeLengthSum += codeLengths[j] = data[offset];
+                  }
+                  var huffmanValues = new Uint8Array(codeLengthSum);
+                  for (j = 0; j < codeLengthSum; j++, offset++) {
+                    huffmanValues[j] = data[offset];
+                  }
+                  i += 17 + codeLengthSum;
+                  (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable(codeLengths, huffmanValues);
+                }
+                break;
+              case 0xFFDD:
+                // DRI (Define Restart Interval)
+                readUint16();
+                // skip data length
+                resetInterval = readUint16();
+                break;
+              case 0xFFDA:
+                // SOS (Start of Scan)
+                var scanLength = readUint16();
+                var selectorsCount = data[offset++];
+                var components = [], component;
+                for (i = 0; i < selectorsCount; i++) {
+                  var componentIndex = frame.componentIds[data[offset++]];
+                  component = frame.components[componentIndex];
+                  var tableSpec = data[offset++];
+                  component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+                  component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+                  components.push(component);
+                }
+                var spectralStart = data[offset++];
+                var spectralEnd = data[offset++];
+                var successiveApproximation = data[offset++];
+                var processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15);
+                offset += processed;
+                break;
+              case 0xFFFF:
+                // Fill bytes
+                if (data[offset] !== 0xFF) {
+                  // Avoid skipping a valid marker.
+                  offset--;
+                }
+                break;
+              default:
+                if (data[offset - 3] === 0xFF && data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
+                  // could be incorrect encoding -- last 0xFF byte of the previous
+                  // block was eaten by the encoder
+                  offset -= 3;
+                  break;
+                }
+                error('JPEG error: unknown marker ' + fileMarker.toString(16));
+              }
+              fileMarker = readUint16();
+            }
+            this.width = frame.samplesPerLine;
+            this.height = frame.scanLines;
+            this.jfif = jfif;
+            this.adobe = adobe;
+            this.components = [];
+            for (i = 0; i < frame.components.length; i++) {
+              component = frame.components[i];
+              // Prevent errors when DQT markers are placed after SOF{n} markers,
+              // by assigning the `quantizationTable` entry after the entire image
+              // has been parsed (fixes issue7406.pdf).
+              var quantizationTable = quantizationTables[component.quantizationId];
+              if (quantizationTable) {
+                component.quantizationTable = quantizationTable;
+              }
+              this.components.push({
+                output: buildComponentData(frame, component),
+                scaleX: component.h / frame.maxH,
+                scaleY: component.v / frame.maxV,
+                blocksPerLine: component.blocksPerLine,
+                blocksPerColumn: component.blocksPerColumn
+              });
+            }
+            this.numComponents = this.components.length;
+          },
+          _getLinearizedBlockData: function getLinearizedBlockData(width, height) {
+            var scaleX = this.width / width, scaleY = this.height / height;
+            var component, componentScaleX, componentScaleY, blocksPerScanline;
+            var x, y, i, j, k;
+            var index;
+            var offset = 0;
+            var output;
+            var numComponents = this.components.length;
+            var dataLength = width * height * numComponents;
+            var data = new Uint8Array(dataLength);
+            var xScaleBlockOffset = new Uint32Array(width);
+            var mask3LSB = 0xfffffff8;
+            // used to clear the 3 LSBs
+            for (i = 0; i < numComponents; i++) {
+              component = this.components[i];
+              componentScaleX = component.scaleX * scaleX;
+              componentScaleY = component.scaleY * scaleY;
+              offset = i;
+              output = component.output;
+              blocksPerScanline = component.blocksPerLine + 1 << 3;
+              // precalculate the xScaleBlockOffset
+              for (x = 0; x < width; x++) {
+                j = 0 | x * componentScaleX;
+                xScaleBlockOffset[x] = (j & mask3LSB) << 3 | j & 7;
+              }
+              // linearize the blocks of the component
+              for (y = 0; y < height; y++) {
+                j = 0 | y * componentScaleY;
+                index = blocksPerScanline * (j & mask3LSB) | (j & 7) << 3;
+                for (x = 0; x < width; x++) {
+                  data[offset] = output[index + xScaleBlockOffset[x]];
+                  offset += numComponents;
+                }
+              }
+            }
+            // decodeTransform contains pairs of multiplier (-256..256) and additive
+            var transform = this.decodeTransform;
+            if (transform) {
+              for (i = 0; i < dataLength;) {
+                for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {
+                  data[i] = (data[i] * transform[k] >> 8) + transform[k + 1];
+                }
+              }
+            }
+            return data;
+          },
+          _isColorConversionNeeded: function isColorConversionNeeded() {
+            if (this.adobe && this.adobe.transformCode) {
+              // The adobe transform marker overrides any previous setting
+              return true;
+            } else if (this.numComponents === 3) {
+              if (!this.adobe && this.colorTransform === 0) {
+                // If the Adobe transform marker is not present and the image
+                // dictionary has a 'ColorTransform' entry, explicitly set to `0`,
+                // then the colours should *not* be transformed.
+                return false;
+              }
+              return true;
+            } else {
+              // `this.numComponents !== 3`
+              if (!this.adobe && this.colorTransform === 1) {
+                // If the Adobe transform marker is not present and the image
+                // dictionary has a 'ColorTransform' entry, explicitly set to `1`,
+                // then the colours should be transformed.
+                return true;
+              }
+              return false;
+            }
+          },
+          _convertYccToRgb: function convertYccToRgb(data) {
+            var Y, Cb, Cr;
+            for (var i = 0, length = data.length; i < length; i += 3) {
+              Y = data[i];
+              Cb = data[i + 1];
+              Cr = data[i + 2];
+              data[i] = clamp0to255(Y - 179.456 + 1.402 * Cr);
+              data[i + 1] = clamp0to255(Y + 135.459 - 0.344 * Cb - 0.714 * Cr);
+              data[i + 2] = clamp0to255(Y - 226.816 + 1.772 * Cb);
+            }
+            return data;
+          },
+          _convertYcckToRgb: function convertYcckToRgb(data) {
+            var Y, Cb, Cr, k;
+            var offset = 0;
+            for (var i = 0, length = data.length; i < length; i += 4) {
+              Y = data[i];
+              Cb = data[i + 1];
+              Cr = data[i + 2];
+              k = data[i + 3];
+              var r = -122.67195406894 + Cb * (-6.60635669420364e-5 * Cb + 0.000437130475926232 * Cr - 5.4080610064599e-5 * Y + 0.00048449797120281 * k - 0.154362151871126) + Cr * (-0.000957964378445773 * Cr + 0.000817076911346625 * Y - 0.00477271405408747 * k + 1.53380253221734) + Y * (0.000961250184130688 * Y - 0.00266257332283933 * k + 0.48357088451265) + k * (-0.000336197177618394 * k + 0.484791561490776);
+              var g = 107.268039397724 + Cb * (2.19927104525741e-5 * Cb - 0.000640992018297945 * Cr + 0.000659397001245577 * Y + 0.000426105652938837 * k - 0.176491792462875) + Cr * (-0.000778269941513683 * Cr + 0.00130872261408275 * Y + 0.000770482631801132 * k - 0.151051492775562) + Y * (0.00126935368114843 * Y - 0.00265090189010898 * k + 0.25802910206845) + k * (-0.000318913117588328 * k - 0.213742400323665);
+              var b = -20.810012546947 + Cb * (-0.000570115196973677 * Cb - 2.63409051004589e-5 * Cr + 0.0020741088115012 * Y - 0.00288260236853442 * k + 0.814272968359295) + Cr * (-1.53496057440975e-5 * Cr - 0.000132689043961446 * Y + 0.000560833691242812 * k - 0.195152027534049) + Y * (0.00174418132927582 * Y - 0.00255243321439347 * k + 0.116935020465145) + k * (-0.000343531996510555 * k + 0.24165260232407);
+              data[offset++] = clamp0to255(r);
+              data[offset++] = clamp0to255(g);
+              data[offset++] = clamp0to255(b);
+            }
+            return data;
+          },
+          _convertYcckToCmyk: function convertYcckToCmyk(data) {
+            var Y, Cb, Cr;
+            for (var i = 0, length = data.length; i < length; i += 4) {
+              Y = data[i];
+              Cb = data[i + 1];
+              Cr = data[i + 2];
+              data[i] = clamp0to255(434.456 - Y - 1.402 * Cr);
+              data[i + 1] = clamp0to255(119.541 - Y + 0.344 * Cb + 0.714 * Cr);
+              data[i + 2] = clamp0to255(481.816 - Y - 1.772 * Cb);
+            }
+            // K in data[i + 3] is unchanged
+            return data;
+          },
+          _convertCmykToRgb: function convertCmykToRgb(data) {
+            var c, m, y, k;
+            var offset = 0;
+            var min = -255 * 255 * 255;
+            var scale = 1 / 255 / 255;
+            for (var i = 0, length = data.length; i < length; i += 4) {
+              c = data[i];
+              m = data[i + 1];
+              y = data[i + 2];
+              k = data[i + 3];
+              var r = c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k - 72734.4411664936) + m * (1.7149763477362134 * m - 5.6096736904047315 * y - 17.873870861415444 * k - 1401.7366389350734) + y * (-2.5217340131683033 * y - 21.248923337353073 * k + 4465.541406466231) - k * (21.86122147463605 * k + 48317.86113160301);
+              var g = c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 20220.756542821975) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 48691.05921601825) + y * (4.444339102852739 * y + 9.8632861493405 * k - 6341.191035517494) - k * (20.737325471181034 * k + 47890.15695978492);
+              var b = c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 3616.812083916688) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 28620.90484698408) + y * (0.03296041114873217 * y + 115.60384449646641 * k - 49363.43385999684) - k * (22.33816807309886 * k + 45932.16563550634);
+              data[offset++] = r >= 0 ? 255 : r <= min ? 0 : 255 + r * scale | 0;
+              data[offset++] = g >= 0 ? 255 : g <= min ? 0 : 255 + g * scale | 0;
+              data[offset++] = b >= 0 ? 255 : b <= min ? 0 : 255 + b * scale | 0;
+            }
+            return data;
+          },
+          getData: function getData(width, height, forceRGBoutput) {
+            if (this.numComponents > 4) {
+              error('JPEG error: Unsupported color mode');
+            }
+            // type of data: Uint8Array(width * height * numComponents)
+            var data = this._getLinearizedBlockData(width, height);
+            if (this.numComponents === 1 && forceRGBoutput) {
+              var dataLength = data.length;
+              var rgbData = new Uint8Array(dataLength * 3);
+              var offset = 0;
+              for (var i = 0; i < dataLength; i++) {
+                var grayColor = data[i];
+                rgbData[offset++] = grayColor;
+                rgbData[offset++] = grayColor;
+                rgbData[offset++] = grayColor;
+              }
+              return rgbData;
+            } else if (this.numComponents === 3 && this._isColorConversionNeeded()) {
+              return this._convertYccToRgb(data);
+            } else if (this.numComponents === 4) {
+              if (this._isColorConversionNeeded()) {
+                if (forceRGBoutput) {
+                  return this._convertYcckToRgb(data);
+                } else {
+                  return this._convertYcckToCmyk(data);
+                }
+              } else if (forceRGBoutput) {
+                return this._convertCmykToRgb(data);
+              }
+            }
+            return data;
+          }
+        };
+        return JpegImage;
+      }();
+      exports.JpegImage = JpegImage;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreJpx = {}, root.pdfjsSharedUtil, root.pdfjsCoreArithmeticDecoder);
+    }(this, function (exports, sharedUtil, coreArithmeticDecoder) {
+      var info = sharedUtil.info;
+      var warn = sharedUtil.warn;
+      var error = sharedUtil.error;
+      var log2 = sharedUtil.log2;
+      var readUint16 = sharedUtil.readUint16;
+      var readUint32 = sharedUtil.readUint32;
+      var ArithmeticDecoder = coreArithmeticDecoder.ArithmeticDecoder;
+      var JpxImage = function JpxImageClosure() {
+        // Table E.1
+        var SubbandsGainLog2 = {
+          'LL': 0,
+          'LH': 1,
+          'HL': 1,
+          'HH': 2
+        };
+        function JpxImage() {
+          this.failOnCorruptedImage = false;
+        }
+        JpxImage.prototype = {
+          parse: function JpxImage_parse(data) {
+            var head = readUint16(data, 0);
+            // No box header, immediate start of codestream (SOC)
+            if (head === 0xFF4F) {
+              this.parseCodestream(data, 0, data.length);
+              return;
+            }
+            var position = 0, length = data.length;
+            while (position < length) {
+              var headerSize = 8;
+              var lbox = readUint32(data, position);
+              var tbox = readUint32(data, position + 4);
+              position += headerSize;
+              if (lbox === 1) {
+                // XLBox: read UInt64 according to spec.
+                // JavaScript's int precision of 53 bit should be sufficient here.
+                lbox = readUint32(data, position) * 4294967296 + readUint32(data, position + 4);
+                position += 8;
+                headerSize += 8;
+              }
+              if (lbox === 0) {
+                lbox = length - position + headerSize;
+              }
+              if (lbox < headerSize) {
+                error('JPX Error: Invalid box field size');
+              }
+              var dataLength = lbox - headerSize;
+              var jumpDataLength = true;
+              switch (tbox) {
+              case 0x6A703268:
+                // 'jp2h'
+                jumpDataLength = false;
+                // parsing child boxes
+                break;
+              case 0x636F6C72:
+                // 'colr'
+                // Colorspaces are not used, the CS from the PDF is used.
+                var method = data[position];
+                if (method === 1) {
+                  // enumerated colorspace
+                  var colorspace = readUint32(data, position + 3);
+                  switch (colorspace) {
+                  case 16:
+                  // this indicates a sRGB colorspace
+                  case 17:
+                  // this indicates a grayscale colorspace
+                  case 18:
+                    // this indicates a YUV colorspace
+                    break;
+                  default:
+                    warn('Unknown colorspace ' + colorspace);
+                    break;
+                  }
+                } else if (method === 2) {
+                  info('ICC profile not supported');
+                }
+                break;
+              case 0x6A703263:
+                // 'jp2c'
+                this.parseCodestream(data, position, position + dataLength);
+                break;
+              case 0x6A502020:
+                // 'jP\024\024'
+                if (0x0d0a870a !== readUint32(data, position)) {
+                  warn('Invalid JP2 signature');
+                }
+                break;
+              // The following header types are valid but currently not used:
+              case 0x6A501A1A:
+              // 'jP\032\032'
+              case 0x66747970:
+              // 'ftyp'
+              case 0x72726571:
+              // 'rreq'
+              case 0x72657320:
+              // 'res '
+              case 0x69686472:
+                // 'ihdr'
+                break;
+              default:
+                var headerType = String.fromCharCode(tbox >> 24 & 0xFF, tbox >> 16 & 0xFF, tbox >> 8 & 0xFF, tbox & 0xFF);
+                warn('Unsupported header type ' + tbox + ' (' + headerType + ')');
+                break;
+              }
+              if (jumpDataLength) {
+                position += dataLength;
+              }
+            }
+          },
+          parseImageProperties: function JpxImage_parseImageProperties(stream) {
+            var newByte = stream.getByte();
+            while (newByte >= 0) {
+              var oldByte = newByte;
+              newByte = stream.getByte();
+              var code = oldByte << 8 | newByte;
+              // Image and tile size (SIZ)
+              if (code === 0xFF51) {
+                stream.skip(4);
+                var Xsiz = stream.getInt32() >>> 0;
+                // Byte 4
+                var Ysiz = stream.getInt32() >>> 0;
+                // Byte 8
+                var XOsiz = stream.getInt32() >>> 0;
+                // Byte 12
+                var YOsiz = stream.getInt32() >>> 0;
+                // Byte 16
+                stream.skip(16);
+                var Csiz = stream.getUint16();
+                // Byte 36
+                this.width = Xsiz - XOsiz;
+                this.height = Ysiz - YOsiz;
+                this.componentsCount = Csiz;
+                // Results are always returned as Uint8Arrays
+                this.bitsPerComponent = 8;
+                return;
+              }
+            }
+            error('JPX Error: No size marker found in JPX stream');
+          },
+          parseCodestream: function JpxImage_parseCodestream(data, start, end) {
+            var context = {};
+            var doNotRecover = false;
+            try {
+              var position = start;
+              while (position + 1 < end) {
+                var code = readUint16(data, position);
+                position += 2;
+                var length = 0, j, sqcd, spqcds, spqcdSize, scalarExpounded, tile;
+                switch (code) {
+                case 0xFF4F:
+                  // Start of codestream (SOC)
+                  context.mainHeader = true;
+                  break;
+                case 0xFFD9:
+                  // End of codestream (EOC)
+                  break;
+                case 0xFF51:
+                  // Image and tile size (SIZ)
+                  length = readUint16(data, position);
+                  var siz = {};
+                  siz.Xsiz = readUint32(data, position + 4);
+                  siz.Ysiz = readUint32(data, position + 8);
+                  siz.XOsiz = readUint32(data, position + 12);
+                  siz.YOsiz = readUint32(data, position + 16);
+                  siz.XTsiz = readUint32(data, position + 20);
+                  siz.YTsiz = readUint32(data, position + 24);
+                  siz.XTOsiz = readUint32(data, position + 28);
+                  siz.YTOsiz = readUint32(data, position + 32);
+                  var componentsCount = readUint16(data, position + 36);
+                  siz.Csiz = componentsCount;
+                  var components = [];
+                  j = position + 38;
+                  for (var i = 0; i < componentsCount; i++) {
+                    var component = {
+                      precision: (data[j] & 0x7F) + 1,
+                      isSigned: !!(data[j] & 0x80),
+                      XRsiz: data[j + 1],
+                      YRsiz: data[j + 1]
+                    };
+                    calculateComponentDimensions(component, siz);
+                    components.push(component);
+                  }
+                  context.SIZ = siz;
+                  context.components = components;
+                  calculateTileGrids(context, components);
+                  context.QCC = [];
+                  context.COC = [];
+                  break;
+                case 0xFF5C:
+                  // Quantization default (QCD)
+                  length = readUint16(data, position);
+                  var qcd = {};
+                  j = position + 2;
+                  sqcd = data[j++];
+                  switch (sqcd & 0x1F) {
+                  case 0:
+                    spqcdSize = 8;
+                    scalarExpounded = true;
+                    break;
+                  case 1:
+                    spqcdSize = 16;
+                    scalarExpounded = false;
+                    break;
+                  case 2:
+                    spqcdSize = 16;
+                    scalarExpounded = true;
+                    break;
+                  default:
+                    throw new Error('Invalid SQcd value ' + sqcd);
+                  }
+                  qcd.noQuantization = spqcdSize === 8;
+                  qcd.scalarExpounded = scalarExpounded;
+                  qcd.guardBits = sqcd >> 5;
+                  spqcds = [];
+                  while (j < length + position) {
+                    var spqcd = {};
+                    if (spqcdSize === 8) {
+                      spqcd.epsilon = data[j++] >> 3;
+                      spqcd.mu = 0;
+                    } else {
+                      spqcd.epsilon = data[j] >> 3;
+                      spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
+                      j += 2;
+                    }
+                    spqcds.push(spqcd);
+                  }
+                  qcd.SPqcds = spqcds;
+                  if (context.mainHeader) {
+                    context.QCD = qcd;
+                  } else {
+                    context.currentTile.QCD = qcd;
+                    context.currentTile.QCC = [];
+                  }
+                  break;
+                case 0xFF5D:
+                  // Quantization component (QCC)
+                  length = readUint16(data, position);
+                  var qcc = {};
+                  j = position + 2;
+                  var cqcc;
+                  if (context.SIZ.Csiz < 257) {
+                    cqcc = data[j++];
+                  } else {
+                    cqcc = readUint16(data, j);
+                    j += 2;
+                  }
+                  sqcd = data[j++];
+                  switch (sqcd & 0x1F) {
+                  case 0:
+                    spqcdSize = 8;
+                    scalarExpounded = true;
+                    break;
+                  case 1:
+                    spqcdSize = 16;
+                    scalarExpounded = false;
+                    break;
+                  case 2:
+                    spqcdSize = 16;
+                    scalarExpounded = true;
+                    break;
+                  default:
+                    throw new Error('Invalid SQcd value ' + sqcd);
+                  }
+                  qcc.noQuantization = spqcdSize === 8;
+                  qcc.scalarExpounded = scalarExpounded;
+                  qcc.guardBits = sqcd >> 5;
+                  spqcds = [];
+                  while (j < length + position) {
+                    spqcd = {};
+                    if (spqcdSize === 8) {
+                      spqcd.epsilon = data[j++] >> 3;
+                      spqcd.mu = 0;
+                    } else {
+                      spqcd.epsilon = data[j] >> 3;
+                      spqcd.mu = (data[j] & 0x7) << 8 | data[j + 1];
+                      j += 2;
+                    }
+                    spqcds.push(spqcd);
+                  }
+                  qcc.SPqcds = spqcds;
+                  if (context.mainHeader) {
+                    context.QCC[cqcc] = qcc;
+                  } else {
+                    context.currentTile.QCC[cqcc] = qcc;
+                  }
+                  break;
+                case 0xFF52:
+                  // Coding style default (COD)
+                  length = readUint16(data, position);
+                  var cod = {};
+                  j = position + 2;
+                  var scod = data[j++];
+                  cod.entropyCoderWithCustomPrecincts = !!(scod & 1);
+                  cod.sopMarkerUsed = !!(scod & 2);
+                  cod.ephMarkerUsed = !!(scod & 4);
+                  cod.progressionOrder = data[j++];
+                  cod.layersCount = readUint16(data, j);
+                  j += 2;
+                  cod.multipleComponentTransform = data[j++];
+                  cod.decompositionLevelsCount = data[j++];
+                  cod.xcb = (data[j++] & 0xF) + 2;
+                  cod.ycb = (data[j++] & 0xF) + 2;
+                  var blockStyle = data[j++];
+                  cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1);
+                  cod.resetContextProbabilities = !!(blockStyle & 2);
+                  cod.terminationOnEachCodingPass = !!(blockStyle & 4);
+                  cod.verticalyStripe = !!(blockStyle & 8);
+                  cod.predictableTermination = !!(blockStyle & 16);
+                  cod.segmentationSymbolUsed = !!(blockStyle & 32);
+                  cod.reversibleTransformation = data[j++];
+                  if (cod.entropyCoderWithCustomPrecincts) {
+                    var precinctsSizes = [];
+                    while (j < length + position) {
+                      var precinctsSize = data[j++];
+                      precinctsSizes.push({
+                        PPx: precinctsSize & 0xF,
+                        PPy: precinctsSize >> 4
+                      });
+                    }
+                    cod.precinctsSizes = precinctsSizes;
+                  }
+                  var unsupported = [];
+                  if (cod.selectiveArithmeticCodingBypass) {
+                    unsupported.push('selectiveArithmeticCodingBypass');
+                  }
+                  if (cod.resetContextProbabilities) {
+                    unsupported.push('resetContextProbabilities');
+                  }
+                  if (cod.terminationOnEachCodingPass) {
+                    unsupported.push('terminationOnEachCodingPass');
+                  }
+                  if (cod.verticalyStripe) {
+                    unsupported.push('verticalyStripe');
+                  }
+                  if (cod.predictableTermination) {
+                    unsupported.push('predictableTermination');
+                  }
+                  if (unsupported.length > 0) {
+                    doNotRecover = true;
+                    throw new Error('Unsupported COD options (' + unsupported.join(', ') + ')');
+                  }
+                  if (context.mainHeader) {
+                    context.COD = cod;
+                  } else {
+                    context.currentTile.COD = cod;
+                    context.currentTile.COC = [];
+                  }
+                  break;
+                case 0xFF90:
+                  // Start of tile-part (SOT)
+                  length = readUint16(data, position);
+                  tile = {};
+                  tile.index = readUint16(data, position + 2);
+                  tile.length = readUint32(data, position + 4);
+                  tile.dataEnd = tile.length + position - 2;
+                  tile.partIndex = data[position + 8];
+                  tile.partsCount = data[position + 9];
+                  context.mainHeader = false;
+                  if (tile.partIndex === 0) {
+                    // reset component specific settings
+                    tile.COD = context.COD;
+                    tile.COC = context.COC.slice(0);
+                    // clone of the global COC
+                    tile.QCD = context.QCD;
+                    tile.QCC = context.QCC.slice(0);
+                  }
+                  // clone of the global COC
+                  context.currentTile = tile;
+                  break;
+                case 0xFF93:
+                  // Start of data (SOD)
+                  tile = context.currentTile;
+                  if (tile.partIndex === 0) {
+                    initializeTile(context, tile.index);
+                    buildPackets(context);
+                  }
+                  // moving to the end of the data
+                  length = tile.dataEnd - position;
+                  parseTilePackets(context, data, position, length);
+                  break;
+                case 0xFF55:
+                // Tile-part lengths, main header (TLM)
+                case 0xFF57:
+                // Packet length, main header (PLM)
+                case 0xFF58:
+                // Packet length, tile-part header (PLT)
+                case 0xFF64:
+                  // Comment (COM)
+                  length = readUint16(data, position);
+                  // skipping content
+                  break;
+                case 0xFF53:
+                  // Coding style component (COC)
+                  throw new Error('Codestream code 0xFF53 (COC) is ' + 'not implemented');
+                default:
+                  throw new Error('Unknown codestream code: ' + code.toString(16));
+                }
+                position += length;
+              }
+            } catch (e) {
+              if (doNotRecover || this.failOnCorruptedImage) {
+                error('JPX Error: ' + e.message);
+              } else {
+                warn('JPX: Trying to recover from: ' + e.message);
+              }
+            }
+            this.tiles = transformComponents(context);
+            this.width = context.SIZ.Xsiz - context.SIZ.XOsiz;
+            this.height = context.SIZ.Ysiz - context.SIZ.YOsiz;
+            this.componentsCount = context.SIZ.Csiz;
+          }
+        };
+        function calculateComponentDimensions(component, siz) {
+          // Section B.2 Component mapping
+          component.x0 = Math.ceil(siz.XOsiz / component.XRsiz);
+          component.x1 = Math.ceil(siz.Xsiz / component.XRsiz);
+          component.y0 = Math.ceil(siz.YOsiz / component.YRsiz);
+          component.y1 = Math.ceil(siz.Ysiz / component.YRsiz);
+          component.width = component.x1 - component.x0;
+          component.height = component.y1 - component.y0;
+        }
+        function calculateTileGrids(context, components) {
+          var siz = context.SIZ;
+          // Section B.3 Division into tile and tile-components
+          var tile, tiles = [];
+          var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz);
+          var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz);
+          for (var q = 0; q < numYtiles; q++) {
+            for (var p = 0; p < numXtiles; p++) {
+              tile = {};
+              tile.tx0 = Math.max(siz.XTOsiz + p * siz.XTsiz, siz.XOsiz);
+              tile.ty0 = Math.max(siz.YTOsiz + q * siz.YTsiz, siz.YOsiz);
+              tile.tx1 = Math.min(siz.XTOsiz + (p + 1) * siz.XTsiz, siz.Xsiz);
+              tile.ty1 = Math.min(siz.YTOsiz + (q + 1) * siz.YTsiz, siz.Ysiz);
+              tile.width = tile.tx1 - tile.tx0;
+              tile.height = tile.ty1 - tile.ty0;
+              tile.components = [];
+              tiles.push(tile);
+            }
+          }
+          context.tiles = tiles;
+          var componentsCount = siz.Csiz;
+          for (var i = 0, ii = componentsCount; i < ii; i++) {
+            var component = components[i];
+            for (var j = 0, jj = tiles.length; j < jj; j++) {
+              var tileComponent = {};
+              tile = tiles[j];
+              tileComponent.tcx0 = Math.ceil(tile.tx0 / component.XRsiz);
+              tileComponent.tcy0 = Math.ceil(tile.ty0 / component.YRsiz);
+              tileComponent.tcx1 = Math.ceil(tile.tx1 / component.XRsiz);
+              tileComponent.tcy1 = Math.ceil(tile.ty1 / component.YRsiz);
+              tileComponent.width = tileComponent.tcx1 - tileComponent.tcx0;
+              tileComponent.height = tileComponent.tcy1 - tileComponent.tcy0;
+              tile.components[i] = tileComponent;
+            }
+          }
+        }
+        function getBlocksDimensions(context, component, r) {
+          var codOrCoc = component.codingStyleParameters;
+          var result = {};
+          if (!codOrCoc.entropyCoderWithCustomPrecincts) {
+            result.PPx = 15;
+            result.PPy = 15;
+          } else {
+            result.PPx = codOrCoc.precinctsSizes[r].PPx;
+            result.PPy = codOrCoc.precinctsSizes[r].PPy;
+          }
+          // calculate codeblock size as described in section B.7
+          result.xcb_ = r > 0 ? Math.min(codOrCoc.xcb, result.PPx - 1) : Math.min(codOrCoc.xcb, result.PPx);
+          result.ycb_ = r > 0 ? Math.min(codOrCoc.ycb, result.PPy - 1) : Math.min(codOrCoc.ycb, result.PPy);
+          return result;
+        }
+        function buildPrecincts(context, resolution, dimensions) {
+          // Section B.6 Division resolution to precincts
+          var precinctWidth = 1 << dimensions.PPx;
+          var precinctHeight = 1 << dimensions.PPy;
+          // Jasper introduces codeblock groups for mapping each subband codeblocks
+          // to precincts. Precinct partition divides a resolution according to width
+          // and height parameters. The subband that belongs to the resolution level
+          // has a different size than the level, unless it is the zero resolution.
+          // From Jasper documentation: jpeg2000.pdf, section K: Tier-2 coding:
+          // The precinct partitioning for a particular subband is derived from a
+          // partitioning of its parent LL band (i.e., the LL band at the next higher
+          // resolution level)... The LL band associated with each resolution level is
+          // divided into precincts... Each of the resulting precinct regions is then
+          // mapped into its child subbands (if any) at the next lower resolution
+          // level. This is accomplished by using the coordinate transformation
+          // (u, v) = (ceil(x/2), ceil(y/2)) where (x, y) and (u, v) are the
+          // coordinates of a point in the LL band and child subband, respectively.
+          var isZeroRes = resolution.resLevel === 0;
+          var precinctWidthInSubband = 1 << dimensions.PPx + (isZeroRes ? 0 : -1);
+          var precinctHeightInSubband = 1 << dimensions.PPy + (isZeroRes ? 0 : -1);
+          var numprecinctswide = resolution.trx1 > resolution.trx0 ? Math.ceil(resolution.trx1 / precinctWidth) - Math.floor(resolution.trx0 / precinctWidth) : 0;
+          var numprecinctshigh = resolution.try1 > resolution.try0 ? Math.ceil(resolution.try1 / precinctHeight) - Math.floor(resolution.try0 / precinctHeight) : 0;
+          var numprecincts = numprecinctswide * numprecinctshigh;
+          resolution.precinctParameters = {
+            precinctWidth: precinctWidth,
+            precinctHeight: precinctHeight,
+            numprecinctswide: numprecinctswide,
+            numprecinctshigh: numprecinctshigh,
+            numprecincts: numprecincts,
+            precinctWidthInSubband: precinctWidthInSubband,
+            precinctHeightInSubband: precinctHeightInSubband
+          };
+        }
+        function buildCodeblocks(context, subband, dimensions) {
+          // Section B.7 Division sub-band into code-blocks
+          var xcb_ = dimensions.xcb_;
+          var ycb_ = dimensions.ycb_;
+          var codeblockWidth = 1 << xcb_;
+          var codeblockHeight = 1 << ycb_;
+          var cbx0 = subband.tbx0 >> xcb_;
+          var cby0 = subband.tby0 >> ycb_;
+          var cbx1 = subband.tbx1 + codeblockWidth - 1 >> xcb_;
+          var cby1 = subband.tby1 + codeblockHeight - 1 >> ycb_;
+          var precinctParameters = subband.resolution.precinctParameters;
+          var codeblocks = [];
+          var precincts = [];
+          var i, j, codeblock, precinctNumber;
+          for (j = cby0; j < cby1; j++) {
+            for (i = cbx0; i < cbx1; i++) {
+              codeblock = {
+                cbx: i,
+                cby: j,
+                tbx0: codeblockWidth * i,
+                tby0: codeblockHeight * j,
+                tbx1: codeblockWidth * (i + 1),
+                tby1: codeblockHeight * (j + 1)
+              };
+              codeblock.tbx0_ = Math.max(subband.tbx0, codeblock.tbx0);
+              codeblock.tby0_ = Math.max(subband.tby0, codeblock.tby0);
+              codeblock.tbx1_ = Math.min(subband.tbx1, codeblock.tbx1);
+              codeblock.tby1_ = Math.min(subband.tby1, codeblock.tby1);
+              // Calculate precinct number for this codeblock, codeblock position
+              // should be relative to its subband, use actual dimension and position
+              // See comment about codeblock group width and height
+              var pi = Math.floor((codeblock.tbx0_ - subband.tbx0) / precinctParameters.precinctWidthInSubband);
+              var pj = Math.floor((codeblock.tby0_ - subband.tby0) / precinctParameters.precinctHeightInSubband);
+              precinctNumber = pi + pj * precinctParameters.numprecinctswide;
+              codeblock.precinctNumber = precinctNumber;
+              codeblock.subbandType = subband.type;
+              codeblock.Lblock = 3;
+              if (codeblock.tbx1_ <= codeblock.tbx0_ || codeblock.tby1_ <= codeblock.tby0_) {
+                continue;
+              }
+              codeblocks.push(codeblock);
+              // building precinct for the sub-band
+              var precinct = precincts[precinctNumber];
+              if (precinct !== undefined) {
+                if (i < precinct.cbxMin) {
+                  precinct.cbxMin = i;
+                } else if (i > precinct.cbxMax) {
+                  precinct.cbxMax = i;
+                }
+                if (j < precinct.cbyMin) {
+                  precinct.cbxMin = j;
+                } else if (j > precinct.cbyMax) {
+                  precinct.cbyMax = j;
+                }
+              } else {
+                precincts[precinctNumber] = precinct = {
+                  cbxMin: i,
+                  cbyMin: j,
+                  cbxMax: i,
+                  cbyMax: j
+                };
+              }
+              codeblock.precinct = precinct;
+            }
+          }
+          subband.codeblockParameters = {
+            codeblockWidth: xcb_,
+            codeblockHeight: ycb_,
+            numcodeblockwide: cbx1 - cbx0 + 1,
+            numcodeblockhigh: cby1 - cby0 + 1
+          };
+          subband.codeblocks = codeblocks;
+          subband.precincts = precincts;
+        }
+        function createPacket(resolution, precinctNumber, layerNumber) {
+          var precinctCodeblocks = [];
+          // Section B.10.8 Order of info in packet
+          var subbands = resolution.subbands;
+          // sub-bands already ordered in 'LL', 'HL', 'LH', and 'HH' sequence
+          for (var i = 0, ii = subbands.length; i < ii; i++) {
+            var subband = subbands[i];
+            var codeblocks = subband.codeblocks;
+            for (var j = 0, jj = codeblocks.length; j < jj; j++) {
+              var codeblock = codeblocks[j];
+              if (codeblock.precinctNumber !== precinctNumber) {
+                continue;
+              }
+              precinctCodeblocks.push(codeblock);
+            }
+          }
+          return {
+            layerNumber: layerNumber,
+            codeblocks: precinctCodeblocks
+          };
+        }
+        function LayerResolutionComponentPositionIterator(context) {
+          var siz = context.SIZ;
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var layersCount = tile.codingStyleDefaultParameters.layersCount;
+          var componentsCount = siz.Csiz;
+          var maxDecompositionLevelsCount = 0;
+          for (var q = 0; q < componentsCount; q++) {
+            maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, tile.components[q].codingStyleParameters.decompositionLevelsCount);
+          }
+          var l = 0, r = 0, i = 0, k = 0;
+          this.nextPacket = function JpxImage_nextPacket() {
+            // Section B.12.1.1 Layer-resolution-component-position
+            for (; l < layersCount; l++) {
+              for (; r <= maxDecompositionLevelsCount; r++) {
+                for (; i < componentsCount; i++) {
+                  var component = tile.components[i];
+                  if (r > component.codingStyleParameters.decompositionLevelsCount) {
+                    continue;
+                  }
+                  var resolution = component.resolutions[r];
+                  var numprecincts = resolution.precinctParameters.numprecincts;
+                  for (; k < numprecincts;) {
+                    var packet = createPacket(resolution, k, l);
+                    k++;
+                    return packet;
+                  }
+                  k = 0;
+                }
+                i = 0;
+              }
+              r = 0;
+            }
+            error('JPX Error: Out of packets');
+          };
+        }
+        function ResolutionLayerComponentPositionIterator(context) {
+          var siz = context.SIZ;
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var layersCount = tile.codingStyleDefaultParameters.layersCount;
+          var componentsCount = siz.Csiz;
+          var maxDecompositionLevelsCount = 0;
+          for (var q = 0; q < componentsCount; q++) {
+            maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, tile.components[q].codingStyleParameters.decompositionLevelsCount);
+          }
+          var r = 0, l = 0, i = 0, k = 0;
+          this.nextPacket = function JpxImage_nextPacket() {
+            // Section B.12.1.2 Resolution-layer-component-position
+            for (; r <= maxDecompositionLevelsCount; r++) {
+              for (; l < layersCount; l++) {
+                for (; i < componentsCount; i++) {
+                  var component = tile.components[i];
+                  if (r > component.codingStyleParameters.decompositionLevelsCount) {
+                    continue;
+                  }
+                  var resolution = component.resolutions[r];
+                  var numprecincts = resolution.precinctParameters.numprecincts;
+                  for (; k < numprecincts;) {
+                    var packet = createPacket(resolution, k, l);
+                    k++;
+                    return packet;
+                  }
+                  k = 0;
+                }
+                i = 0;
+              }
+              l = 0;
+            }
+            error('JPX Error: Out of packets');
+          };
+        }
+        function ResolutionPositionComponentLayerIterator(context) {
+          var siz = context.SIZ;
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var layersCount = tile.codingStyleDefaultParameters.layersCount;
+          var componentsCount = siz.Csiz;
+          var l, r, c, p;
+          var maxDecompositionLevelsCount = 0;
+          for (c = 0; c < componentsCount; c++) {
+            var component = tile.components[c];
+            maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, component.codingStyleParameters.decompositionLevelsCount);
+          }
+          var maxNumPrecinctsInLevel = new Int32Array(maxDecompositionLevelsCount + 1);
+          for (r = 0; r <= maxDecompositionLevelsCount; ++r) {
+            var maxNumPrecincts = 0;
+            for (c = 0; c < componentsCount; ++c) {
+              var resolutions = tile.components[c].resolutions;
+              if (r < resolutions.length) {
+                maxNumPrecincts = Math.max(maxNumPrecincts, resolutions[r].precinctParameters.numprecincts);
+              }
+            }
+            maxNumPrecinctsInLevel[r] = maxNumPrecincts;
+          }
+          l = 0;
+          r = 0;
+          c = 0;
+          p = 0;
+          this.nextPacket = function JpxImage_nextPacket() {
+            // Section B.12.1.3 Resolution-position-component-layer
+            for (; r <= maxDecompositionLevelsCount; r++) {
+              for (; p < maxNumPrecinctsInLevel[r]; p++) {
+                for (; c < componentsCount; c++) {
+                  var component = tile.components[c];
+                  if (r > component.codingStyleParameters.decompositionLevelsCount) {
+                    continue;
+                  }
+                  var resolution = component.resolutions[r];
+                  var numprecincts = resolution.precinctParameters.numprecincts;
+                  if (p >= numprecincts) {
+                    continue;
+                  }
+                  for (; l < layersCount;) {
+                    var packet = createPacket(resolution, p, l);
+                    l++;
+                    return packet;
+                  }
+                  l = 0;
+                }
+                c = 0;
+              }
+              p = 0;
+            }
+            error('JPX Error: Out of packets');
+          };
+        }
+        function PositionComponentResolutionLayerIterator(context) {
+          var siz = context.SIZ;
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var layersCount = tile.codingStyleDefaultParameters.layersCount;
+          var componentsCount = siz.Csiz;
+          var precinctsSizes = getPrecinctSizesInImageScale(tile);
+          var precinctsIterationSizes = precinctsSizes;
+          var l = 0, r = 0, c = 0, px = 0, py = 0;
+          this.nextPacket = function JpxImage_nextPacket() {
+            // Section B.12.1.4 Position-component-resolution-layer
+            for (; py < precinctsIterationSizes.maxNumHigh; py++) {
+              for (; px < precinctsIterationSizes.maxNumWide; px++) {
+                for (; c < componentsCount; c++) {
+                  var component = tile.components[c];
+                  var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+                  for (; r <= decompositionLevelsCount; r++) {
+                    var resolution = component.resolutions[r];
+                    var sizeInImageScale = precinctsSizes.components[c].resolutions[r];
+                    var k = getPrecinctIndexIfExist(px, py, sizeInImageScale, precinctsIterationSizes, resolution);
+                    if (k === null) {
+                      continue;
+                    }
+                    for (; l < layersCount;) {
+                      var packet = createPacket(resolution, k, l);
+                      l++;
+                      return packet;
+                    }
+                    l = 0;
+                  }
+                  r = 0;
+                }
+                c = 0;
+              }
+              px = 0;
+            }
+            error('JPX Error: Out of packets');
+          };
+        }
+        function ComponentPositionResolutionLayerIterator(context) {
+          var siz = context.SIZ;
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var layersCount = tile.codingStyleDefaultParameters.layersCount;
+          var componentsCount = siz.Csiz;
+          var precinctsSizes = getPrecinctSizesInImageScale(tile);
+          var l = 0, r = 0, c = 0, px = 0, py = 0;
+          this.nextPacket = function JpxImage_nextPacket() {
+            // Section B.12.1.5 Component-position-resolution-layer
+            for (; c < componentsCount; ++c) {
+              var component = tile.components[c];
+              var precinctsIterationSizes = precinctsSizes.components[c];
+              var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+              for (; py < precinctsIterationSizes.maxNumHigh; py++) {
+                for (; px < precinctsIterationSizes.maxNumWide; px++) {
+                  for (; r <= decompositionLevelsCount; r++) {
+                    var resolution = component.resolutions[r];
+                    var sizeInImageScale = precinctsIterationSizes.resolutions[r];
+                    var k = getPrecinctIndexIfExist(px, py, sizeInImageScale, precinctsIterationSizes, resolution);
+                    if (k === null) {
+                      continue;
+                    }
+                    for (; l < layersCount;) {
+                      var packet = createPacket(resolution, k, l);
+                      l++;
+                      return packet;
+                    }
+                    l = 0;
+                  }
+                  r = 0;
+                }
+                px = 0;
+              }
+              py = 0;
+            }
+            error('JPX Error: Out of packets');
+          };
+        }
+        function getPrecinctIndexIfExist(pxIndex, pyIndex, sizeInImageScale, precinctIterationSizes, resolution) {
+          var posX = pxIndex * precinctIterationSizes.minWidth;
+          var posY = pyIndex * precinctIterationSizes.minHeight;
+          if (posX % sizeInImageScale.width !== 0 || posY % sizeInImageScale.height !== 0) {
+            return null;
+          }
+          var startPrecinctRowIndex = posY / sizeInImageScale.width * resolution.precinctParameters.numprecinctswide;
+          return posX / sizeInImageScale.height + startPrecinctRowIndex;
+        }
+        function getPrecinctSizesInImageScale(tile) {
+          var componentsCount = tile.components.length;
+          var minWidth = Number.MAX_VALUE;
+          var minHeight = Number.MAX_VALUE;
+          var maxNumWide = 0;
+          var maxNumHigh = 0;
+          var sizePerComponent = new Array(componentsCount);
+          for (var c = 0; c < componentsCount; c++) {
+            var component = tile.components[c];
+            var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+            var sizePerResolution = new Array(decompositionLevelsCount + 1);
+            var minWidthCurrentComponent = Number.MAX_VALUE;
+            var minHeightCurrentComponent = Number.MAX_VALUE;
+            var maxNumWideCurrentComponent = 0;
+            var maxNumHighCurrentComponent = 0;
+            var scale = 1;
+            for (var r = decompositionLevelsCount; r >= 0; --r) {
+              var resolution = component.resolutions[r];
+              var widthCurrentResolution = scale * resolution.precinctParameters.precinctWidth;
+              var heightCurrentResolution = scale * resolution.precinctParameters.precinctHeight;
+              minWidthCurrentComponent = Math.min(minWidthCurrentComponent, widthCurrentResolution);
+              minHeightCurrentComponent = Math.min(minHeightCurrentComponent, heightCurrentResolution);
+              maxNumWideCurrentComponent = Math.max(maxNumWideCurrentComponent, resolution.precinctParameters.numprecinctswide);
+              maxNumHighCurrentComponent = Math.max(maxNumHighCurrentComponent, resolution.precinctParameters.numprecinctshigh);
+              sizePerResolution[r] = {
+                width: widthCurrentResolution,
+                height: heightCurrentResolution
+              };
+              scale <<= 1;
+            }
+            minWidth = Math.min(minWidth, minWidthCurrentComponent);
+            minHeight = Math.min(minHeight, minHeightCurrentComponent);
+            maxNumWide = Math.max(maxNumWide, maxNumWideCurrentComponent);
+            maxNumHigh = Math.max(maxNumHigh, maxNumHighCurrentComponent);
+            sizePerComponent[c] = {
+              resolutions: sizePerResolution,
+              minWidth: minWidthCurrentComponent,
+              minHeight: minHeightCurrentComponent,
+              maxNumWide: maxNumWideCurrentComponent,
+              maxNumHigh: maxNumHighCurrentComponent
+            };
+          }
+          return {
+            components: sizePerComponent,
+            minWidth: minWidth,
+            minHeight: minHeight,
+            maxNumWide: maxNumWide,
+            maxNumHigh: maxNumHigh
+          };
+        }
+        function buildPackets(context) {
+          var siz = context.SIZ;
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var componentsCount = siz.Csiz;
+          // Creating resolutions and sub-bands for each component
+          for (var c = 0; c < componentsCount; c++) {
+            var component = tile.components[c];
+            var decompositionLevelsCount = component.codingStyleParameters.decompositionLevelsCount;
+            // Section B.5 Resolution levels and sub-bands
+            var resolutions = [];
+            var subbands = [];
+            for (var r = 0; r <= decompositionLevelsCount; r++) {
+              var blocksDimensions = getBlocksDimensions(context, component, r);
+              var resolution = {};
+              var scale = 1 << decompositionLevelsCount - r;
+              resolution.trx0 = Math.ceil(component.tcx0 / scale);
+              resolution.try0 = Math.ceil(component.tcy0 / scale);
+              resolution.trx1 = Math.ceil(component.tcx1 / scale);
+              resolution.try1 = Math.ceil(component.tcy1 / scale);
+              resolution.resLevel = r;
+              buildPrecincts(context, resolution, blocksDimensions);
+              resolutions.push(resolution);
+              var subband;
+              if (r === 0) {
+                // one sub-band (LL) with last decomposition
+                subband = {};
+                subband.type = 'LL';
+                subband.tbx0 = Math.ceil(component.tcx0 / scale);
+                subband.tby0 = Math.ceil(component.tcy0 / scale);
+                subband.tbx1 = Math.ceil(component.tcx1 / scale);
+                subband.tby1 = Math.ceil(component.tcy1 / scale);
+                subband.resolution = resolution;
+                buildCodeblocks(context, subband, blocksDimensions);
+                subbands.push(subband);
+                resolution.subbands = [subband];
+              } else {
+                var bscale = 1 << decompositionLevelsCount - r + 1;
+                var resolutionSubbands = [];
+                // three sub-bands (HL, LH and HH) with rest of decompositions
+                subband = {};
+                subband.type = 'HL';
+                subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
+                subband.tby0 = Math.ceil(component.tcy0 / bscale);
+                subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
+                subband.tby1 = Math.ceil(component.tcy1 / bscale);
+                subband.resolution = resolution;
+                buildCodeblocks(context, subband, blocksDimensions);
+                subbands.push(subband);
+                resolutionSubbands.push(subband);
+                subband = {};
+                subband.type = 'LH';
+                subband.tbx0 = Math.ceil(component.tcx0 / bscale);
+                subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
+                subband.tbx1 = Math.ceil(component.tcx1 / bscale);
+                subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);
+                subband.resolution = resolution;
+                buildCodeblocks(context, subband, blocksDimensions);
+                subbands.push(subband);
+                resolutionSubbands.push(subband);
+                subband = {};
+                subband.type = 'HH';
+                subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);
+                subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);
+                subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);
+                subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);
+                subband.resolution = resolution;
+                buildCodeblocks(context, subband, blocksDimensions);
+                subbands.push(subband);
+                resolutionSubbands.push(subband);
+                resolution.subbands = resolutionSubbands;
+              }
+            }
+            component.resolutions = resolutions;
+            component.subbands = subbands;
+          }
+          // Generate the packets sequence
+          var progressionOrder = tile.codingStyleDefaultParameters.progressionOrder;
+          switch (progressionOrder) {
+          case 0:
+            tile.packetsIterator = new LayerResolutionComponentPositionIterator(context);
+            break;
+          case 1:
+            tile.packetsIterator = new ResolutionLayerComponentPositionIterator(context);
+            break;
+          case 2:
+            tile.packetsIterator = new ResolutionPositionComponentLayerIterator(context);
+            break;
+          case 3:
+            tile.packetsIterator = new PositionComponentResolutionLayerIterator(context);
+            break;
+          case 4:
+            tile.packetsIterator = new ComponentPositionResolutionLayerIterator(context);
+            break;
+          default:
+            error('JPX Error: Unsupported progression order ' + progressionOrder);
+          }
+        }
+        function parseTilePackets(context, data, offset, dataLength) {
+          var position = 0;
+          var buffer, bufferSize = 0, skipNextBit = false;
+          function readBits(count) {
+            while (bufferSize < count) {
+              var b = data[offset + position];
+              position++;
+              if (skipNextBit) {
+                buffer = buffer << 7 | b;
+                bufferSize += 7;
+                skipNextBit = false;
+              } else {
+                buffer = buffer << 8 | b;
+                bufferSize += 8;
+              }
+              if (b === 0xFF) {
+                skipNextBit = true;
+              }
+            }
+            bufferSize -= count;
+            return buffer >>> bufferSize & (1 << count) - 1;
+          }
+          function skipMarkerIfEqual(value) {
+            if (data[offset + position - 1] === 0xFF && data[offset + position] === value) {
+              skipBytes(1);
+              return true;
+            } else if (data[offset + position] === 0xFF && data[offset + position + 1] === value) {
+              skipBytes(2);
+              return true;
+            }
+            return false;
+          }
+          function skipBytes(count) {
+            position += count;
+          }
+          function alignToByte() {
+            bufferSize = 0;
+            if (skipNextBit) {
+              position++;
+              skipNextBit = false;
+            }
+          }
+          function readCodingpasses() {
+            if (readBits(1) === 0) {
+              return 1;
+            }
+            if (readBits(1) === 0) {
+              return 2;
+            }
+            var value = readBits(2);
+            if (value < 3) {
+              return value + 3;
+            }
+            value = readBits(5);
+            if (value < 31) {
+              return value + 6;
+            }
+            value = readBits(7);
+            return value + 37;
+          }
+          var tileIndex = context.currentTile.index;
+          var tile = context.tiles[tileIndex];
+          var sopMarkerUsed = context.COD.sopMarkerUsed;
+          var ephMarkerUsed = context.COD.ephMarkerUsed;
+          var packetsIterator = tile.packetsIterator;
+          while (position < dataLength) {
+            alignToByte();
+            if (sopMarkerUsed && skipMarkerIfEqual(0x91)) {
+              // Skip also marker segment length and packet sequence ID
+              skipBytes(4);
+            }
+            var packet = packetsIterator.nextPacket();
+            if (!readBits(1)) {
+              continue;
+            }
+            var layerNumber = packet.layerNumber;
+            var queue = [], codeblock;
+            for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) {
+              codeblock = packet.codeblocks[i];
+              var precinct = codeblock.precinct;
+              var codeblockColumn = codeblock.cbx - precinct.cbxMin;
+              var codeblockRow = codeblock.cby - precinct.cbyMin;
+              var codeblockIncluded = false;
+              var firstTimeInclusion = false;
+              var valueReady;
+              if (codeblock['included'] !== undefined) {
+                codeblockIncluded = !!readBits(1);
+              } else {
+                // reading inclusion tree
+                precinct = codeblock.precinct;
+                var inclusionTree, zeroBitPlanesTree;
+                if (precinct['inclusionTree'] !== undefined) {
+                  inclusionTree = precinct.inclusionTree;
+                } else {
+                  // building inclusion and zero bit-planes trees
+                  var width = precinct.cbxMax - precinct.cbxMin + 1;
+                  var height = precinct.cbyMax - precinct.cbyMin + 1;
+                  inclusionTree = new InclusionTree(width, height, layerNumber);
+                  zeroBitPlanesTree = new TagTree(width, height);
+                  precinct.inclusionTree = inclusionTree;
+                  precinct.zeroBitPlanesTree = zeroBitPlanesTree;
+                }
+                if (inclusionTree.reset(codeblockColumn, codeblockRow, layerNumber)) {
+                  while (true) {
+                    if (readBits(1)) {
+                      valueReady = !inclusionTree.nextLevel();
+                      if (valueReady) {
+                        codeblock.included = true;
+                        codeblockIncluded = firstTimeInclusion = true;
+                        break;
+                      }
+                    } else {
+                      inclusionTree.incrementValue(layerNumber);
+                      break;
+                    }
+                  }
+                }
+              }
+              if (!codeblockIncluded) {
+                continue;
+              }
+              if (firstTimeInclusion) {
+                zeroBitPlanesTree = precinct.zeroBitPlanesTree;
+                zeroBitPlanesTree.reset(codeblockColumn, codeblockRow);
+                while (true) {
+                  if (readBits(1)) {
+                    valueReady = !zeroBitPlanesTree.nextLevel();
+                    if (valueReady) {
+                      break;
+                    }
+                  } else {
+                    zeroBitPlanesTree.incrementValue();
+                  }
+                }
+                codeblock.zeroBitPlanes = zeroBitPlanesTree.value;
+              }
+              var codingpasses = readCodingpasses();
+              while (readBits(1)) {
+                codeblock.Lblock++;
+              }
+              var codingpassesLog2 = log2(codingpasses);
+              // rounding down log2
+              var bits = (codingpasses < 1 << codingpassesLog2 ? codingpassesLog2 - 1 : codingpassesLog2) + codeblock.Lblock;
+              var codedDataLength = readBits(bits);
+              queue.push({
+                codeblock: codeblock,
+                codingpasses: codingpasses,
+                dataLength: codedDataLength
+              });
+            }
+            alignToByte();
+            if (ephMarkerUsed) {
+              skipMarkerIfEqual(0x92);
+            }
+            while (queue.length > 0) {
+              var packetItem = queue.shift();
+              codeblock = packetItem.codeblock;
+              if (codeblock['data'] === undefined) {
+                codeblock.data = [];
+              }
+              codeblock.data.push({
+                data: data,
+                start: offset + position,
+                end: offset + position + packetItem.dataLength,
+                codingpasses: packetItem.codingpasses
+              });
+              position += packetItem.dataLength;
+            }
+          }
+          return position;
+        }
+        function copyCoefficients(coefficients, levelWidth, levelHeight, subband, delta, mb, reversible, segmentationSymbolUsed) {
+          var x0 = subband.tbx0;
+          var y0 = subband.tby0;
+          var width = subband.tbx1 - subband.tbx0;
+          var codeblocks = subband.codeblocks;
+          var right = subband.type.charAt(0) === 'H' ? 1 : 0;
+          var bottom = subband.type.charAt(1) === 'H' ? levelWidth : 0;
+          for (var i = 0, ii = codeblocks.length; i < ii; ++i) {
+            var codeblock = codeblocks[i];
+            var blockWidth = codeblock.tbx1_ - codeblock.tbx0_;
+            var blockHeight = codeblock.tby1_ - codeblock.tby0_;
+            if (blockWidth === 0 || blockHeight === 0) {
+              continue;
+            }
+            if (codeblock['data'] === undefined) {
+              continue;
+            }
+            var bitModel, currentCodingpassType;
+            bitModel = new BitModel(blockWidth, blockHeight, codeblock.subbandType, codeblock.zeroBitPlanes, mb);
+            currentCodingpassType = 2;
+            // first bit plane starts from cleanup
+            // collect data
+            var data = codeblock.data, totalLength = 0, codingpasses = 0;
+            var j, jj, dataItem;
+            for (j = 0, jj = data.length; j < jj; j++) {
+              dataItem = data[j];
+              totalLength += dataItem.end - dataItem.start;
+              codingpasses += dataItem.codingpasses;
+            }
+            var encodedData = new Uint8Array(totalLength);
+            var position = 0;
+            for (j = 0, jj = data.length; j < jj; j++) {
+              dataItem = data[j];
+              var chunk = dataItem.data.subarray(dataItem.start, dataItem.end);
+              encodedData.set(chunk, position);
+              position += chunk.length;
+            }
+            // decoding the item
+            var decoder = new ArithmeticDecoder(encodedData, 0, totalLength);
+            bitModel.setDecoder(decoder);
+            for (j = 0; j < codingpasses; j++) {
+              switch (currentCodingpassType) {
+              case 0:
+                bitModel.runSignificancePropagationPass();
+                break;
+              case 1:
+                bitModel.runMagnitudeRefinementPass();
+                break;
+              case 2:
+                bitModel.runCleanupPass();
+                if (segmentationSymbolUsed) {
+                  bitModel.checkSegmentationSymbol();
+                }
+                break;
+              }
+              currentCodingpassType = (currentCodingpassType + 1) % 3;
+            }
+            var offset = codeblock.tbx0_ - x0 + (codeblock.tby0_ - y0) * width;
+            var sign = bitModel.coefficentsSign;
+            var magnitude = bitModel.coefficentsMagnitude;
+            var bitsDecoded = bitModel.bitsDecoded;
+            var magnitudeCorrection = reversible ? 0 : 0.5;
+            var k, n, nb;
+            position = 0;
+            // Do the interleaving of Section F.3.3 here, so we do not need
+            // to copy later. LL level is not interleaved, just copied.
+            var interleave = subband.type !== 'LL';
+            for (j = 0; j < blockHeight; j++) {
+              var row = offset / width | 0;
+              // row in the non-interleaved subband
+              var levelOffset = 2 * row * (levelWidth - width) + right + bottom;
+              for (k = 0; k < blockWidth; k++) {
+                n = magnitude[position];
+                if (n !== 0) {
+                  n = (n + magnitudeCorrection) * delta;
+                  if (sign[position] !== 0) {
+                    n = -n;
+                  }
+                  nb = bitsDecoded[position];
+                  var pos = interleave ? levelOffset + (offset << 1) : offset;
+                  if (reversible && nb >= mb) {
+                    coefficients[pos] = n;
+                  } else {
+                    coefficients[pos] = n * (1 << mb - nb);
+                  }
+                }
+                offset++;
+                position++;
+              }
+              offset += width - blockWidth;
+            }
+          }
+        }
+        function transformTile(context, tile, c) {
+          var component = tile.components[c];
+          var codingStyleParameters = component.codingStyleParameters;
+          var quantizationParameters = component.quantizationParameters;
+          var decompositionLevelsCount = codingStyleParameters.decompositionLevelsCount;
+          var spqcds = quantizationParameters.SPqcds;
+          var scalarExpounded = quantizationParameters.scalarExpounded;
+          var guardBits = quantizationParameters.guardBits;
+          var segmentationSymbolUsed = codingStyleParameters.segmentationSymbolUsed;
+          var precision = context.components[c].precision;
+          var reversible = codingStyleParameters.reversibleTransformation;
+          var transform = reversible ? new ReversibleTransform() : new IrreversibleTransform();
+          var subbandCoefficients = [];
+          var b = 0;
+          for (var i = 0; i <= decompositionLevelsCount; i++) {
+            var resolution = component.resolutions[i];
+            var width = resolution.trx1 - resolution.trx0;
+            var height = resolution.try1 - resolution.try0;
+            // Allocate space for the whole sublevel.
+            var coefficients = new Float32Array(width * height);
+            for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {
+              var mu, epsilon;
+              if (!scalarExpounded) {
+                // formula E-5
+                mu = spqcds[0].mu;
+                epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0);
+              } else {
+                mu = spqcds[b].mu;
+                epsilon = spqcds[b].epsilon;
+                b++;
+              }
+              var subband = resolution.subbands[j];
+              var gainLog2 = SubbandsGainLog2[subband.type];
+              // calculate quantization coefficient (Section E.1.1.1)
+              var delta = reversible ? 1 : Math.pow(2, precision + gainLog2 - epsilon) * (1 + mu / 2048);
+              var mb = guardBits + epsilon - 1;
+              // In the first resolution level, copyCoefficients will fill the
+              // whole array with coefficients. In the succeeding passes,
+              // copyCoefficients will consecutively fill in the values that belong
+              // to the interleaved positions of the HL, LH, and HH coefficients.
+              // The LL coefficients will then be interleaved in Transform.iterate().
+              copyCoefficients(coefficients, width, height, subband, delta, mb, reversible, segmentationSymbolUsed);
+            }
+            subbandCoefficients.push({
+              width: width,
+              height: height,
+              items: coefficients
+            });
+          }
+          var result = transform.calculate(subbandCoefficients, component.tcx0, component.tcy0);
+          return {
+            left: component.tcx0,
+            top: component.tcy0,
+            width: result.width,
+            height: result.height,
+            items: result.items
+          };
+        }
+        function transformComponents(context) {
+          var siz = context.SIZ;
+          var components = context.components;
+          var componentsCount = siz.Csiz;
+          var resultImages = [];
+          for (var i = 0, ii = context.tiles.length; i < ii; i++) {
+            var tile = context.tiles[i];
+            var transformedTiles = [];
+            var c;
+            for (c = 0; c < componentsCount; c++) {
+              transformedTiles[c] = transformTile(context, tile, c);
+            }
+            var tile0 = transformedTiles[0];
+            var out = new Uint8Array(tile0.items.length * componentsCount);
+            var result = {
+              left: tile0.left,
+              top: tile0.top,
+              width: tile0.width,
+              height: tile0.height,
+              items: out
+            };
+            // Section G.2.2 Inverse multi component transform
+            var shift, offset, max, min, maxK;
+            var pos = 0, j, jj, y0, y1, y2, r, g, b, k, val;
+            if (tile.codingStyleDefaultParameters.multipleComponentTransform) {
+              var fourComponents = componentsCount === 4;
+              var y0items = transformedTiles[0].items;
+              var y1items = transformedTiles[1].items;
+              var y2items = transformedTiles[2].items;
+              var y3items = fourComponents ? transformedTiles[3].items : null;
+              // HACK: The multiple component transform formulas below assume that
+              // all components have the same precision. With this in mind, we
+              // compute shift and offset only once.
+              shift = components[0].precision - 8;
+              offset = (128 << shift) + 0.5;
+              max = 255 * (1 << shift);
+              maxK = max * 0.5;
+              min = -maxK;
+              var component0 = tile.components[0];
+              var alpha01 = componentsCount - 3;
+              jj = y0items.length;
+              if (!component0.codingStyleParameters.reversibleTransformation) {
+                // inverse irreversible multiple component transform
+                for (j = 0; j < jj; j++, pos += alpha01) {
+                  y0 = y0items[j] + offset;
+                  y1 = y1items[j];
+                  y2 = y2items[j];
+                  r = y0 + 1.402 * y2;
+                  g = y0 - 0.34413 * y1 - 0.71414 * y2;
+                  b = y0 + 1.772 * y1;
+                  out[pos++] = r <= 0 ? 0 : r >= max ? 255 : r >> shift;
+                  out[pos++] = g <= 0 ? 0 : g >= max ? 255 : g >> shift;
+                  out[pos++] = b <= 0 ? 0 : b >= max ? 255 : b >> shift;
+                }
+              } else {
+                // inverse reversible multiple component transform
+                for (j = 0; j < jj; j++, pos += alpha01) {
+                  y0 = y0items[j] + offset;
+                  y1 = y1items[j];
+                  y2 = y2items[j];
+                  g = y0 - (y2 + y1 >> 2);
+                  r = g + y2;
+                  b = g + y1;
+                  out[pos++] = r <= 0 ? 0 : r >= max ? 255 : r >> shift;
+                  out[pos++] = g <= 0 ? 0 : g >= max ? 255 : g >> shift;
+                  out[pos++] = b <= 0 ? 0 : b >= max ? 255 : b >> shift;
+                }
+              }
+              if (fourComponents) {
+                for (j = 0, pos = 3; j < jj; j++, pos += 4) {
+                  k = y3items[j];
+                  out[pos] = k <= min ? 0 : k >= maxK ? 255 : k + offset >> shift;
+                }
+              }
+            } else {
+              // no multi-component transform
+              for (c = 0; c < componentsCount; c++) {
+                var items = transformedTiles[c].items;
+                shift = components[c].precision - 8;
+                offset = (128 << shift) + 0.5;
+                max = 127.5 * (1 << shift);
+                min = -max;
+                for (pos = c, j = 0, jj = items.length; j < jj; j++) {
+                  val = items[j];
+                  out[pos] = val <= min ? 0 : val >= max ? 255 : val + offset >> shift;
+                  pos += componentsCount;
+                }
+              }
+            }
+            resultImages.push(result);
+          }
+          return resultImages;
+        }
+        function initializeTile(context, tileIndex) {
+          var siz = context.SIZ;
+          var componentsCount = siz.Csiz;
+          var tile = context.tiles[tileIndex];
+          for (var c = 0; c < componentsCount; c++) {
+            var component = tile.components[c];
+            var qcdOrQcc = context.currentTile.QCC[c] !== undefined ? context.currentTile.QCC[c] : context.currentTile.QCD;
+            component.quantizationParameters = qcdOrQcc;
+            var codOrCoc = context.currentTile.COC[c] !== undefined ? context.currentTile.COC[c] : context.currentTile.COD;
+            component.codingStyleParameters = codOrCoc;
+          }
+          tile.codingStyleDefaultParameters = context.currentTile.COD;
+        }
+        // Section B.10.2 Tag trees
+        var TagTree = function TagTreeClosure() {
+          function TagTree(width, height) {
+            var levelsLength = log2(Math.max(width, height)) + 1;
+            this.levels = [];
+            for (var i = 0; i < levelsLength; i++) {
+              var level = {
+                width: width,
+                height: height,
+                items: []
+              };
+              this.levels.push(level);
+              width = Math.ceil(width / 2);
+              height = Math.ceil(height / 2);
+            }
+          }
+          TagTree.prototype = {
+            reset: function TagTree_reset(i, j) {
+              var currentLevel = 0, value = 0, level;
+              while (currentLevel < this.levels.length) {
+                level = this.levels[currentLevel];
+                var index = i + j * level.width;
+                if (level.items[index] !== undefined) {
+                  value = level.items[index];
+                  break;
+                }
+                level.index = index;
+                i >>= 1;
+                j >>= 1;
+                currentLevel++;
+              }
+              currentLevel--;
+              level = this.levels[currentLevel];
+              level.items[level.index] = value;
+              this.currentLevel = currentLevel;
+              delete this.value;
+            },
+            incrementValue: function TagTree_incrementValue() {
+              var level = this.levels[this.currentLevel];
+              level.items[level.index]++;
+            },
+            nextLevel: function TagTree_nextLevel() {
+              var currentLevel = this.currentLevel;
+              var level = this.levels[currentLevel];
+              var value = level.items[level.index];
+              currentLevel--;
+              if (currentLevel < 0) {
+                this.value = value;
+                return false;
+              }
+              this.currentLevel = currentLevel;
+              level = this.levels[currentLevel];
+              level.items[level.index] = value;
+              return true;
+            }
+          };
+          return TagTree;
+        }();
+        var InclusionTree = function InclusionTreeClosure() {
+          function InclusionTree(width, height, defaultValue) {
+            var levelsLength = log2(Math.max(width, height)) + 1;
+            this.levels = [];
+            for (var i = 0; i < levelsLength; i++) {
+              var items = new Uint8Array(width * height);
+              for (var j = 0, jj = items.length; j < jj; j++) {
+                items[j] = defaultValue;
+              }
+              var level = {
+                width: width,
+                height: height,
+                items: items
+              };
+              this.levels.push(level);
+              width = Math.ceil(width / 2);
+              height = Math.ceil(height / 2);
+            }
+          }
+          InclusionTree.prototype = {
+            reset: function InclusionTree_reset(i, j, stopValue) {
+              var currentLevel = 0;
+              while (currentLevel < this.levels.length) {
+                var level = this.levels[currentLevel];
+                var index = i + j * level.width;
+                level.index = index;
+                var value = level.items[index];
+                if (value === 0xFF) {
+                  break;
+                }
+                if (value > stopValue) {
+                  this.currentLevel = currentLevel;
+                  // already know about this one, propagating the value to top levels
+                  this.propagateValues();
+                  return false;
+                }
+                i >>= 1;
+                j >>= 1;
+                currentLevel++;
+              }
+              this.currentLevel = currentLevel - 1;
+              return true;
+            },
+            incrementValue: function InclusionTree_incrementValue(stopValue) {
+              var level = this.levels[this.currentLevel];
+              level.items[level.index] = stopValue + 1;
+              this.propagateValues();
+            },
+            propagateValues: function InclusionTree_propagateValues() {
+              var levelIndex = this.currentLevel;
+              var level = this.levels[levelIndex];
+              var currentValue = level.items[level.index];
+              while (--levelIndex >= 0) {
+                level = this.levels[levelIndex];
+                level.items[level.index] = currentValue;
+              }
+            },
+            nextLevel: function InclusionTree_nextLevel() {
+              var currentLevel = this.currentLevel;
+              var level = this.levels[currentLevel];
+              var value = level.items[level.index];
+              level.items[level.index] = 0xFF;
+              currentLevel--;
+              if (currentLevel < 0) {
+                return false;
+              }
+              this.currentLevel = currentLevel;
+              level = this.levels[currentLevel];
+              level.items[level.index] = value;
+              return true;
+            }
+          };
+          return InclusionTree;
+        }();
+        // Section D. Coefficient bit modeling
+        var BitModel = function BitModelClosure() {
+          var UNIFORM_CONTEXT = 17;
+          var RUNLENGTH_CONTEXT = 18;
+          // Table D-1
+          // The index is binary presentation: 0dddvvhh, ddd - sum of Di (0..4),
+          // vv - sum of Vi (0..2), and hh - sum of Hi (0..2)
+          var LLAndLHContextsLabel = new Uint8Array([
+            0,
+            5,
+            8,
+            0,
+            3,
+            7,
+            8,
+            0,
+            4,
+            7,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            1,
+            6,
+            8,
+            0,
+            3,
+            7,
+            8,
+            0,
+            4,
+            7,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            2,
+            6,
+            8,
+            0,
+            3,
+            7,
+            8,
+            0,
+            4,
+            7,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            2,
+            6,
+            8,
+            0,
+            3,
+            7,
+            8,
+            0,
+            4,
+            7,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            2,
+            6,
+            8,
+            0,
+            3,
+            7,
+            8,
+            0,
+            4,
+            7,
+            8
+          ]);
+          var HLContextLabel = new Uint8Array([
+            0,
+            3,
+            4,
+            0,
+            5,
+            7,
+            7,
+            0,
+            8,
+            8,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            1,
+            3,
+            4,
+            0,
+            6,
+            7,
+            7,
+            0,
+            8,
+            8,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            2,
+            3,
+            4,
+            0,
+            6,
+            7,
+            7,
+            0,
+            8,
+            8,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            2,
+            3,
+            4,
+            0,
+            6,
+            7,
+            7,
+            0,
+            8,
+            8,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            2,
+            3,
+            4,
+            0,
+            6,
+            7,
+            7,
+            0,
+            8,
+            8,
+            8
+          ]);
+          var HHContextLabel = new Uint8Array([
+            0,
+            1,
+            2,
+            0,
+            1,
+            2,
+            2,
+            0,
+            2,
+            2,
+            2,
+            0,
+            0,
+            0,
+            0,
+            0,
+            3,
+            4,
+            5,
+            0,
+            4,
+            5,
+            5,
+            0,
+            5,
+            5,
+            5,
+            0,
+            0,
+            0,
+            0,
+            0,
+            6,
+            7,
+            7,
+            0,
+            7,
+            7,
+            7,
+            0,
+            7,
+            7,
+            7,
+            0,
+            0,
+            0,
+            0,
+            0,
+            8,
+            8,
+            8,
+            0,
+            8,
+            8,
+            8,
+            0,
+            8,
+            8,
+            8,
+            0,
+            0,
+            0,
+            0,
+            0,
+            8,
+            8,
+            8,
+            0,
+            8,
+            8,
+            8,
+            0,
+            8,
+            8,
+            8
+          ]);
+          function BitModel(width, height, subband, zeroBitPlanes, mb) {
+            this.width = width;
+            this.height = height;
+            this.contextLabelTable = subband === 'HH' ? HHContextLabel : subband === 'HL' ? HLContextLabel : LLAndLHContextsLabel;
+            var coefficientCount = width * height;
+            // coefficients outside the encoding region treated as insignificant
+            // add border state cells for significanceState
+            this.neighborsSignificance = new Uint8Array(coefficientCount);
+            this.coefficentsSign = new Uint8Array(coefficientCount);
+            this.coefficentsMagnitude = mb > 14 ? new Uint32Array(coefficientCount) : mb > 6 ? new Uint16Array(coefficientCount) : new Uint8Array(coefficientCount);
+            this.processingFlags = new Uint8Array(coefficientCount);
+            var bitsDecoded = new Uint8Array(coefficientCount);
+            if (zeroBitPlanes !== 0) {
+              for (var i = 0; i < coefficientCount; i++) {
+                bitsDecoded[i] = zeroBitPlanes;
+              }
+            }
+            this.bitsDecoded = bitsDecoded;
+            this.reset();
+          }
+          BitModel.prototype = {
+            setDecoder: function BitModel_setDecoder(decoder) {
+              this.decoder = decoder;
+            },
+            reset: function BitModel_reset() {
+              // We have 17 contexts that are accessed via context labels,
+              // plus the uniform and runlength context.
+              this.contexts = new Int8Array(19);
+              // Contexts are packed into 1 byte:
+              // highest 7 bits carry the index, lowest bit carries mps
+              this.contexts[0] = 4 << 1 | 0;
+              this.contexts[UNIFORM_CONTEXT] = 46 << 1 | 0;
+              this.contexts[RUNLENGTH_CONTEXT] = 3 << 1 | 0;
+            },
+            setNeighborsSignificance: function BitModel_setNeighborsSignificance(row, column, index) {
+              var neighborsSignificance = this.neighborsSignificance;
+              var width = this.width, height = this.height;
+              var left = column > 0;
+              var right = column + 1 < width;
+              var i;
+              if (row > 0) {
+                i = index - width;
+                if (left) {
+                  neighborsSignificance[i - 1] += 0x10;
+                }
+                if (right) {
+                  neighborsSignificance[i + 1] += 0x10;
+                }
+                neighborsSignificance[i] += 0x04;
+              }
+              if (row + 1 < height) {
+                i = index + width;
+                if (left) {
+                  neighborsSignificance[i - 1] += 0x10;
+                }
+                if (right) {
+                  neighborsSignificance[i + 1] += 0x10;
+                }
+                neighborsSignificance[i] += 0x04;
+              }
+              if (left) {
+                neighborsSignificance[index - 1] += 0x01;
+              }
+              if (right) {
+                neighborsSignificance[index + 1] += 0x01;
+              }
+              neighborsSignificance[index] |= 0x80;
+            },
+            runSignificancePropagationPass: function BitModel_runSignificancePropagationPass() {
+              var decoder = this.decoder;
+              var width = this.width, height = this.height;
+              var coefficentsMagnitude = this.coefficentsMagnitude;
+              var coefficentsSign = this.coefficentsSign;
+              var neighborsSignificance = this.neighborsSignificance;
+              var processingFlags = this.processingFlags;
+              var contexts = this.contexts;
+              var labels = this.contextLabelTable;
+              var bitsDecoded = this.bitsDecoded;
+              var processedInverseMask = ~1;
+              var processedMask = 1;
+              var firstMagnitudeBitMask = 2;
+              for (var i0 = 0; i0 < height; i0 += 4) {
+                for (var j = 0; j < width; j++) {
+                  var index = i0 * width + j;
+                  for (var i1 = 0; i1 < 4; i1++, index += width) {
+                    var i = i0 + i1;
+                    if (i >= height) {
+                      break;
+                    }
+                    // clear processed flag first
+                    processingFlags[index] &= processedInverseMask;
+                    if (coefficentsMagnitude[index] || !neighborsSignificance[index]) {
+                      continue;
+                    }
+                    var contextLabel = labels[neighborsSignificance[index]];
+                    var decision = decoder.readBit(contexts, contextLabel);
+                    if (decision) {
+                      var sign = this.decodeSignBit(i, j, index);
+                      coefficentsSign[index] = sign;
+                      coefficentsMagnitude[index] = 1;
+                      this.setNeighborsSignificance(i, j, index);
+                      processingFlags[index] |= firstMagnitudeBitMask;
+                    }
+                    bitsDecoded[index]++;
+                    processingFlags[index] |= processedMask;
+                  }
+                }
+              }
+            },
+            decodeSignBit: function BitModel_decodeSignBit(row, column, index) {
+              var width = this.width, height = this.height;
+              var coefficentsMagnitude = this.coefficentsMagnitude;
+              var coefficentsSign = this.coefficentsSign;
+              var contribution, sign0, sign1, significance1;
+              var contextLabel, decoded;
+              // calculate horizontal contribution
+              significance1 = column > 0 && coefficentsMagnitude[index - 1] !== 0;
+              if (column + 1 < width && coefficentsMagnitude[index + 1] !== 0) {
+                sign1 = coefficentsSign[index + 1];
+                if (significance1) {
+                  sign0 = coefficentsSign[index - 1];
+                  contribution = 1 - sign1 - sign0;
+                } else {
+                  contribution = 1 - sign1 - sign1;
+                }
+              } else if (significance1) {
+                sign0 = coefficentsSign[index - 1];
+                contribution = 1 - sign0 - sign0;
+              } else {
+                contribution = 0;
+              }
+              var horizontalContribution = 3 * contribution;
+              // calculate vertical contribution and combine with the horizontal
+              significance1 = row > 0 && coefficentsMagnitude[index - width] !== 0;
+              if (row + 1 < height && coefficentsMagnitude[index + width] !== 0) {
+                sign1 = coefficentsSign[index + width];
+                if (significance1) {
+                  sign0 = coefficentsSign[index - width];
+                  contribution = 1 - sign1 - sign0 + horizontalContribution;
+                } else {
+                  contribution = 1 - sign1 - sign1 + horizontalContribution;
+                }
+              } else if (significance1) {
+                sign0 = coefficentsSign[index - width];
+                contribution = 1 - sign0 - sign0 + horizontalContribution;
+              } else {
+                contribution = horizontalContribution;
+              }
+              if (contribution >= 0) {
+                contextLabel = 9 + contribution;
+                decoded = this.decoder.readBit(this.contexts, contextLabel);
+              } else {
+                contextLabel = 9 - contribution;
+                decoded = this.decoder.readBit(this.contexts, contextLabel) ^ 1;
+              }
+              return decoded;
+            },
+            runMagnitudeRefinementPass: function BitModel_runMagnitudeRefinementPass() {
+              var decoder = this.decoder;
+              var width = this.width, height = this.height;
+              var coefficentsMagnitude = this.coefficentsMagnitude;
+              var neighborsSignificance = this.neighborsSignificance;
+              var contexts = this.contexts;
+              var bitsDecoded = this.bitsDecoded;
+              var processingFlags = this.processingFlags;
+              var processedMask = 1;
+              var firstMagnitudeBitMask = 2;
+              var length = width * height;
+              var width4 = width * 4;
+              for (var index0 = 0, indexNext; index0 < length; index0 = indexNext) {
+                indexNext = Math.min(length, index0 + width4);
+                for (var j = 0; j < width; j++) {
+                  for (var index = index0 + j; index < indexNext; index += width) {
+                    // significant but not those that have just become
+                    if (!coefficentsMagnitude[index] || (processingFlags[index] & processedMask) !== 0) {
+                      continue;
+                    }
+                    var contextLabel = 16;
+                    if ((processingFlags[index] & firstMagnitudeBitMask) !== 0) {
+                      processingFlags[index] ^= firstMagnitudeBitMask;
+                      // first refinement
+                      var significance = neighborsSignificance[index] & 127;
+                      contextLabel = significance === 0 ? 15 : 14;
+                    }
+                    var bit = decoder.readBit(contexts, contextLabel);
+                    coefficentsMagnitude[index] = coefficentsMagnitude[index] << 1 | bit;
+                    bitsDecoded[index]++;
+                    processingFlags[index] |= processedMask;
+                  }
+                }
+              }
+            },
+            runCleanupPass: function BitModel_runCleanupPass() {
+              var decoder = this.decoder;
+              var width = this.width, height = this.height;
+              var neighborsSignificance = this.neighborsSignificance;
+              var coefficentsMagnitude = this.coefficentsMagnitude;
+              var coefficentsSign = this.coefficentsSign;
+              var contexts = this.contexts;
+              var labels = this.contextLabelTable;
+              var bitsDecoded = this.bitsDecoded;
+              var processingFlags = this.processingFlags;
+              var processedMask = 1;
+              var firstMagnitudeBitMask = 2;
+              var oneRowDown = width;
+              var twoRowsDown = width * 2;
+              var threeRowsDown = width * 3;
+              var iNext;
+              for (var i0 = 0; i0 < height; i0 = iNext) {
+                iNext = Math.min(i0 + 4, height);
+                var indexBase = i0 * width;
+                var checkAllEmpty = i0 + 3 < height;
+                for (var j = 0; j < width; j++) {
+                  var index0 = indexBase + j;
+                  // using the property: labels[neighborsSignificance[index]] === 0
+                  // when neighborsSignificance[index] === 0
+                  var allEmpty = checkAllEmpty && processingFlags[index0] === 0 && processingFlags[index0 + oneRowDown] === 0 && processingFlags[index0 + twoRowsDown] === 0 && processingFlags[index0 + threeRowsDown] === 0 && neighborsSignificance[index0] === 0 && neighborsSignificance[index0 + oneRowDown] === 0 && neighborsSignificance[index0 + twoRowsDown] === 0 && neighborsSignificance[index0 + threeRowsDown] === 0;
+                  var i1 = 0, index = index0;
+                  var i = i0, sign;
+                  if (allEmpty) {
+                    var hasSignificantCoefficent = decoder.readBit(contexts, RUNLENGTH_CONTEXT);
+                    if (!hasSignificantCoefficent) {
+                      bitsDecoded[index0]++;
+                      bitsDecoded[index0 + oneRowDown]++;
+                      bitsDecoded[index0 + twoRowsDown]++;
+                      bitsDecoded[index0 + threeRowsDown]++;
+                      continue;
+                    }
+                    // next column
+                    i1 = decoder.readBit(contexts, UNIFORM_CONTEXT) << 1 | decoder.readBit(contexts, UNIFORM_CONTEXT);
+                    if (i1 !== 0) {
+                      i = i0 + i1;
+                      index += i1 * width;
+                    }
+                    sign = this.decodeSignBit(i, j, index);
+                    coefficentsSign[index] = sign;
+                    coefficentsMagnitude[index] = 1;
+                    this.setNeighborsSignificance(i, j, index);
+                    processingFlags[index] |= firstMagnitudeBitMask;
+                    index = index0;
+                    for (var i2 = i0; i2 <= i; i2++, index += width) {
+                      bitsDecoded[index]++;
+                    }
+                    i1++;
+                  }
+                  for (i = i0 + i1; i < iNext; i++, index += width) {
+                    if (coefficentsMagnitude[index] || (processingFlags[index] & processedMask) !== 0) {
+                      continue;
+                    }
+                    var contextLabel = labels[neighborsSignificance[index]];
+                    var decision = decoder.readBit(contexts, contextLabel);
+                    if (decision === 1) {
+                      sign = this.decodeSignBit(i, j, index);
+                      coefficentsSign[index] = sign;
+                      coefficentsMagnitude[index] = 1;
+                      this.setNeighborsSignificance(i, j, index);
+                      processingFlags[index] |= firstMagnitudeBitMask;
+                    }
+                    bitsDecoded[index]++;
+                  }
+                }
+              }
+            },
+            checkSegmentationSymbol: function BitModel_checkSegmentationSymbol() {
+              var decoder = this.decoder;
+              var contexts = this.contexts;
+              var symbol = decoder.readBit(contexts, UNIFORM_CONTEXT) << 3 | decoder.readBit(contexts, UNIFORM_CONTEXT) << 2 | decoder.readBit(contexts, UNIFORM_CONTEXT) << 1 | decoder.readBit(contexts, UNIFORM_CONTEXT);
+              if (symbol !== 0xA) {
+                error('JPX Error: Invalid segmentation symbol');
+              }
+            }
+          };
+          return BitModel;
+        }();
+        // Section F, Discrete wavelet transformation
+        var Transform = function TransformClosure() {
+          function Transform() {
+          }
+          Transform.prototype.calculate = function transformCalculate(subbands, u0, v0) {
+            var ll = subbands[0];
+            for (var i = 1, ii = subbands.length; i < ii; i++) {
+              ll = this.iterate(ll, subbands[i], u0, v0);
+            }
+            return ll;
+          };
+          Transform.prototype.extend = function extend(buffer, offset, size) {
+            // Section F.3.7 extending... using max extension of 4
+            var i1 = offset - 1, j1 = offset + 1;
+            var i2 = offset + size - 2, j2 = offset + size;
+            buffer[i1--] = buffer[j1++];
+            buffer[j2++] = buffer[i2--];
+            buffer[i1--] = buffer[j1++];
+            buffer[j2++] = buffer[i2--];
+            buffer[i1--] = buffer[j1++];
+            buffer[j2++] = buffer[i2--];
+            buffer[i1] = buffer[j1];
+            buffer[j2] = buffer[i2];
+          };
+          Transform.prototype.iterate = function Transform_iterate(ll, hl_lh_hh, u0, v0) {
+            var llWidth = ll.width, llHeight = ll.height, llItems = ll.items;
+            var width = hl_lh_hh.width;
+            var height = hl_lh_hh.height;
+            var items = hl_lh_hh.items;
+            var i, j, k, l, u, v;
+            // Interleave LL according to Section F.3.3
+            for (k = 0, i = 0; i < llHeight; i++) {
+              l = i * 2 * width;
+              for (j = 0; j < llWidth; j++, k++, l += 2) {
+                items[l] = llItems[k];
+              }
+            }
+            // The LL band is not needed anymore.
+            llItems = ll.items = null;
+            var bufferPadding = 4;
+            var rowBuffer = new Float32Array(width + 2 * bufferPadding);
+            // Section F.3.4 HOR_SR
+            if (width === 1) {
+              // if width = 1, when u0 even keep items as is, when odd divide by 2
+              if ((u0 & 1) !== 0) {
+                for (v = 0, k = 0; v < height; v++, k += width) {
+                  items[k] *= 0.5;
+                }
+              }
+            } else {
+              for (v = 0, k = 0; v < height; v++, k += width) {
+                rowBuffer.set(items.subarray(k, k + width), bufferPadding);
+                this.extend(rowBuffer, bufferPadding, width);
+                this.filter(rowBuffer, bufferPadding, width);
+                items.set(rowBuffer.subarray(bufferPadding, bufferPadding + width), k);
+              }
+            }
+            // Accesses to the items array can take long, because it may not fit into
+            // CPU cache and has to be fetched from main memory. Since subsequent
+            // accesses to the items array are not local when reading columns, we
+            // have a cache miss every time. To reduce cache misses, get up to
+            // 'numBuffers' items at a time and store them into the individual
+            // buffers. The colBuffers should be small enough to fit into CPU cache.
+            var numBuffers = 16;
+            var colBuffers = [];
+            for (i = 0; i < numBuffers; i++) {
+              colBuffers.push(new Float32Array(height + 2 * bufferPadding));
+            }
+            var b, currentBuffer = 0;
+            ll = bufferPadding + height;
+            // Section F.3.5 VER_SR
+            if (height === 1) {
+              // if height = 1, when v0 even keep items as is, when odd divide by 2
+              if ((v0 & 1) !== 0) {
+                for (u = 0; u < width; u++) {
+                  items[u] *= 0.5;
+                }
+              }
+            } else {
+              for (u = 0; u < width; u++) {
+                // if we ran out of buffers, copy several image columns at once
+                if (currentBuffer === 0) {
+                  numBuffers = Math.min(width - u, numBuffers);
+                  for (k = u, l = bufferPadding; l < ll; k += width, l++) {
+                    for (b = 0; b < numBuffers; b++) {
+                      colBuffers[b][l] = items[k + b];
+                    }
+                  }
+                  currentBuffer = numBuffers;
+                }
+                currentBuffer--;
+                var buffer = colBuffers[currentBuffer];
+                this.extend(buffer, bufferPadding, height);
+                this.filter(buffer, bufferPadding, height);
+                // If this is last buffer in this group of buffers, flush all buffers.
+                if (currentBuffer === 0) {
+                  k = u - numBuffers + 1;
+                  for (l = bufferPadding; l < ll; k += width, l++) {
+                    for (b = 0; b < numBuffers; b++) {
+                      items[k + b] = colBuffers[b][l];
+                    }
+                  }
+                }
+              }
+            }
+            return {
+              width: width,
+              height: height,
+              items: items
+            };
+          };
+          return Transform;
+        }();
+        // Section 3.8.2 Irreversible 9-7 filter
+        var IrreversibleTransform = function IrreversibleTransformClosure() {
+          function IrreversibleTransform() {
+            Transform.call(this);
+          }
+          IrreversibleTransform.prototype = Object.create(Transform.prototype);
+          IrreversibleTransform.prototype.filter = function irreversibleTransformFilter(x, offset, length) {
+            var len = length >> 1;
+            offset = offset | 0;
+            var j, n, current, next;
+            var alpha = -1.586134342059924;
+            var beta = -0.052980118572961;
+            var gamma = 0.882911075530934;
+            var delta = 0.443506852043971;
+            var K = 1.230174104914001;
+            var K_ = 1 / K;
+            // step 1 is combined with step 3
+            // step 2
+            j = offset - 3;
+            for (n = len + 4; n--; j += 2) {
+              x[j] *= K_;
+            }
+            // step 1 & 3
+            j = offset - 2;
+            current = delta * x[j - 1];
+            for (n = len + 3; n--; j += 2) {
+              next = delta * x[j + 1];
+              x[j] = K * x[j] - current - next;
+              if (n--) {
+                j += 2;
+                current = delta * x[j + 1];
+                x[j] = K * x[j] - current - next;
+              } else {
+                break;
+              }
+            }
+            // step 4
+            j = offset - 1;
+            current = gamma * x[j - 1];
+            for (n = len + 2; n--; j += 2) {
+              next = gamma * x[j + 1];
+              x[j] -= current + next;
+              if (n--) {
+                j += 2;
+                current = gamma * x[j + 1];
+                x[j] -= current + next;
+              } else {
+                break;
+              }
+            }
+            // step 5
+            j = offset;
+            current = beta * x[j - 1];
+            for (n = len + 1; n--; j += 2) {
+              next = beta * x[j + 1];
+              x[j] -= current + next;
+              if (n--) {
+                j += 2;
+                current = beta * x[j + 1];
+                x[j] -= current + next;
+              } else {
+                break;
+              }
+            }
+            // step 6
+            if (len !== 0) {
+              j = offset + 1;
+              current = alpha * x[j - 1];
+              for (n = len; n--; j += 2) {
+                next = alpha * x[j + 1];
+                x[j] -= current + next;
+                if (n--) {
+                  j += 2;
+                  current = alpha * x[j + 1];
+                  x[j] -= current + next;
+                } else {
+                  break;
+                }
+              }
+            }
+          };
+          return IrreversibleTransform;
+        }();
+        // Section 3.8.1 Reversible 5-3 filter
+        var ReversibleTransform = function ReversibleTransformClosure() {
+          function ReversibleTransform() {
+            Transform.call(this);
+          }
+          ReversibleTransform.prototype = Object.create(Transform.prototype);
+          ReversibleTransform.prototype.filter = function reversibleTransformFilter(x, offset, length) {
+            var len = length >> 1;
+            offset = offset | 0;
+            var j, n;
+            for (j = offset, n = len + 1; n--; j += 2) {
+              x[j] -= x[j - 1] + x[j + 1] + 2 >> 2;
+            }
+            for (j = offset + 1, n = len; n--; j += 2) {
+              x[j] += x[j - 1] + x[j + 1] >> 1;
+            }
+          };
+          return ReversibleTransform;
+        }();
+        return JpxImage;
+      }();
+      exports.JpxImage = JpxImage;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreMetrics = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var getLookupTableFactory = sharedUtil.getLookupTableFactory;
+      // The Metrics object contains glyph widths (in glyph space units).
+      // As per PDF spec, for most fonts (Type 3 being an exception) a glyph
+      // space unit corresponds to 1/1000th of text space unit.
+      var getMetrics = getLookupTableFactory(function (t) {
+        t['Courier'] = 600;
+        t['Courier-Bold'] = 600;
+        t['Courier-BoldOblique'] = 600;
+        t['Courier-Oblique'] = 600;
+        t['Helvetica'] = getLookupTableFactory(function (t) {
+          t['space'] = 278;
+          t['exclam'] = 278;
+          t['quotedbl'] = 355;
+          t['numbersign'] = 556;
+          t['dollar'] = 556;
+          t['percent'] = 889;
+          t['ampersand'] = 667;
+          t['quoteright'] = 222;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 389;
+          t['plus'] = 584;
+          t['comma'] = 278;
+          t['hyphen'] = 333;
+          t['period'] = 278;
+          t['slash'] = 278;
+          t['zero'] = 556;
+          t['one'] = 556;
+          t['two'] = 556;
+          t['three'] = 556;
+          t['four'] = 556;
+          t['five'] = 556;
+          t['six'] = 556;
+          t['seven'] = 556;
+          t['eight'] = 556;
+          t['nine'] = 556;
+          t['colon'] = 278;
+          t['semicolon'] = 278;
+          t['less'] = 584;
+          t['equal'] = 584;
+          t['greater'] = 584;
+          t['question'] = 556;
+          t['at'] = 1015;
+          t['A'] = 667;
+          t['B'] = 667;
+          t['C'] = 722;
+          t['D'] = 722;
+          t['E'] = 667;
+          t['F'] = 611;
+          t['G'] = 778;
+          t['H'] = 722;
+          t['I'] = 278;
+          t['J'] = 500;
+          t['K'] = 667;
+          t['L'] = 556;
+          t['M'] = 833;
+          t['N'] = 722;
+          t['O'] = 778;
+          t['P'] = 667;
+          t['Q'] = 778;
+          t['R'] = 722;
+          t['S'] = 667;
+          t['T'] = 611;
+          t['U'] = 722;
+          t['V'] = 667;
+          t['W'] = 944;
+          t['X'] = 667;
+          t['Y'] = 667;
+          t['Z'] = 611;
+          t['bracketleft'] = 278;
+          t['backslash'] = 278;
+          t['bracketright'] = 278;
+          t['asciicircum'] = 469;
+          t['underscore'] = 556;
+          t['quoteleft'] = 222;
+          t['a'] = 556;
+          t['b'] = 556;
+          t['c'] = 500;
+          t['d'] = 556;
+          t['e'] = 556;
+          t['f'] = 278;
+          t['g'] = 556;
+          t['h'] = 556;
+          t['i'] = 222;
+          t['j'] = 222;
+          t['k'] = 500;
+          t['l'] = 222;
+          t['m'] = 833;
+          t['n'] = 556;
+          t['o'] = 556;
+          t['p'] = 556;
+          t['q'] = 556;
+          t['r'] = 333;
+          t['s'] = 500;
+          t['t'] = 278;
+          t['u'] = 556;
+          t['v'] = 500;
+          t['w'] = 722;
+          t['x'] = 500;
+          t['y'] = 500;
+          t['z'] = 500;
+          t['braceleft'] = 334;
+          t['bar'] = 260;
+          t['braceright'] = 334;
+          t['asciitilde'] = 584;
+          t['exclamdown'] = 333;
+          t['cent'] = 556;
+          t['sterling'] = 556;
+          t['fraction'] = 167;
+          t['yen'] = 556;
+          t['florin'] = 556;
+          t['section'] = 556;
+          t['currency'] = 556;
+          t['quotesingle'] = 191;
+          t['quotedblleft'] = 333;
+          t['guillemotleft'] = 556;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 500;
+          t['fl'] = 500;
+          t['endash'] = 556;
+          t['dagger'] = 556;
+          t['daggerdbl'] = 556;
+          t['periodcentered'] = 278;
+          t['paragraph'] = 537;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 222;
+          t['quotedblbase'] = 333;
+          t['quotedblright'] = 333;
+          t['guillemotright'] = 556;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 611;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 1000;
+          t['ordfeminine'] = 370;
+          t['Lslash'] = 556;
+          t['Oslash'] = 778;
+          t['OE'] = 1000;
+          t['ordmasculine'] = 365;
+          t['ae'] = 889;
+          t['dotlessi'] = 278;
+          t['lslash'] = 222;
+          t['oslash'] = 611;
+          t['oe'] = 944;
+          t['germandbls'] = 611;
+          t['Idieresis'] = 278;
+          t['eacute'] = 556;
+          t['abreve'] = 556;
+          t['uhungarumlaut'] = 556;
+          t['ecaron'] = 556;
+          t['Ydieresis'] = 667;
+          t['divide'] = 584;
+          t['Yacute'] = 667;
+          t['Acircumflex'] = 667;
+          t['aacute'] = 556;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 500;
+          t['scommaaccent'] = 500;
+          t['ecircumflex'] = 556;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 556;
+          t['Uacute'] = 722;
+          t['uogonek'] = 556;
+          t['Edieresis'] = 667;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 737;
+          t['Emacron'] = 667;
+          t['ccaron'] = 500;
+          t['aring'] = 556;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 222;
+          t['agrave'] = 556;
+          t['Tcommaaccent'] = 611;
+          t['Cacute'] = 722;
+          t['atilde'] = 556;
+          t['Edotaccent'] = 667;
+          t['scaron'] = 500;
+          t['scedilla'] = 500;
+          t['iacute'] = 278;
+          t['lozenge'] = 471;
+          t['Rcaron'] = 722;
+          t['Gcommaaccent'] = 778;
+          t['ucircumflex'] = 556;
+          t['acircumflex'] = 556;
+          t['Amacron'] = 667;
+          t['rcaron'] = 333;
+          t['ccedilla'] = 500;
+          t['Zdotaccent'] = 611;
+          t['Thorn'] = 667;
+          t['Omacron'] = 778;
+          t['Racute'] = 722;
+          t['Sacute'] = 667;
+          t['dcaron'] = 643;
+          t['Umacron'] = 722;
+          t['uring'] = 556;
+          t['threesuperior'] = 333;
+          t['Ograve'] = 778;
+          t['Agrave'] = 667;
+          t['Abreve'] = 667;
+          t['multiply'] = 584;
+          t['uacute'] = 556;
+          t['Tcaron'] = 611;
+          t['partialdiff'] = 476;
+          t['ydieresis'] = 500;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 667;
+          t['adieresis'] = 556;
+          t['edieresis'] = 556;
+          t['cacute'] = 500;
+          t['nacute'] = 556;
+          t['umacron'] = 556;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 278;
+          t['plusminus'] = 584;
+          t['brokenbar'] = 260;
+          t['registered'] = 737;
+          t['Gbreve'] = 778;
+          t['Idotaccent'] = 278;
+          t['summation'] = 600;
+          t['Egrave'] = 667;
+          t['racute'] = 333;
+          t['omacron'] = 556;
+          t['Zacute'] = 611;
+          t['Zcaron'] = 611;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 722;
+          t['lcommaaccent'] = 222;
+          t['tcaron'] = 317;
+          t['eogonek'] = 556;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 667;
+          t['Adieresis'] = 667;
+          t['egrave'] = 556;
+          t['zacute'] = 500;
+          t['iogonek'] = 222;
+          t['Oacute'] = 778;
+          t['oacute'] = 556;
+          t['amacron'] = 556;
+          t['sacute'] = 500;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 778;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 556;
+          t['twosuperior'] = 333;
+          t['Odieresis'] = 778;
+          t['mu'] = 556;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 556;
+          t['Eogonek'] = 667;
+          t['dcroat'] = 556;
+          t['threequarters'] = 834;
+          t['Scedilla'] = 667;
+          t['lcaron'] = 299;
+          t['Kcommaaccent'] = 667;
+          t['Lacute'] = 556;
+          t['trademark'] = 1000;
+          t['edotaccent'] = 556;
+          t['Igrave'] = 278;
+          t['Imacron'] = 278;
+          t['Lcaron'] = 556;
+          t['onehalf'] = 834;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 556;
+          t['ntilde'] = 556;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 667;
+          t['emacron'] = 556;
+          t['gbreve'] = 556;
+          t['onequarter'] = 834;
+          t['Scaron'] = 667;
+          t['Scommaaccent'] = 667;
+          t['Ohungarumlaut'] = 778;
+          t['degree'] = 400;
+          t['ograve'] = 556;
+          t['Ccaron'] = 722;
+          t['ugrave'] = 556;
+          t['radical'] = 453;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 333;
+          t['Ntilde'] = 722;
+          t['otilde'] = 556;
+          t['Rcommaaccent'] = 722;
+          t['Lcommaaccent'] = 556;
+          t['Atilde'] = 667;
+          t['Aogonek'] = 667;
+          t['Aring'] = 667;
+          t['Otilde'] = 778;
+          t['zdotaccent'] = 500;
+          t['Ecaron'] = 667;
+          t['Iogonek'] = 278;
+          t['kcommaaccent'] = 500;
+          t['minus'] = 584;
+          t['Icircumflex'] = 278;
+          t['ncaron'] = 556;
+          t['tcommaaccent'] = 278;
+          t['logicalnot'] = 584;
+          t['odieresis'] = 556;
+          t['udieresis'] = 556;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 556;
+          t['eth'] = 556;
+          t['zcaron'] = 500;
+          t['ncommaaccent'] = 556;
+          t['onesuperior'] = 333;
+          t['imacron'] = 278;
+          t['Euro'] = 556;
+        });
+        t['Helvetica-Bold'] = getLookupTableFactory(function (t) {
+          t['space'] = 278;
+          t['exclam'] = 333;
+          t['quotedbl'] = 474;
+          t['numbersign'] = 556;
+          t['dollar'] = 556;
+          t['percent'] = 889;
+          t['ampersand'] = 722;
+          t['quoteright'] = 278;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 389;
+          t['plus'] = 584;
+          t['comma'] = 278;
+          t['hyphen'] = 333;
+          t['period'] = 278;
+          t['slash'] = 278;
+          t['zero'] = 556;
+          t['one'] = 556;
+          t['two'] = 556;
+          t['three'] = 556;
+          t['four'] = 556;
+          t['five'] = 556;
+          t['six'] = 556;
+          t['seven'] = 556;
+          t['eight'] = 556;
+          t['nine'] = 556;
+          t['colon'] = 333;
+          t['semicolon'] = 333;
+          t['less'] = 584;
+          t['equal'] = 584;
+          t['greater'] = 584;
+          t['question'] = 611;
+          t['at'] = 975;
+          t['A'] = 722;
+          t['B'] = 722;
+          t['C'] = 722;
+          t['D'] = 722;
+          t['E'] = 667;
+          t['F'] = 611;
+          t['G'] = 778;
+          t['H'] = 722;
+          t['I'] = 278;
+          t['J'] = 556;
+          t['K'] = 722;
+          t['L'] = 611;
+          t['M'] = 833;
+          t['N'] = 722;
+          t['O'] = 778;
+          t['P'] = 667;
+          t['Q'] = 778;
+          t['R'] = 722;
+          t['S'] = 667;
+          t['T'] = 611;
+          t['U'] = 722;
+          t['V'] = 667;
+          t['W'] = 944;
+          t['X'] = 667;
+          t['Y'] = 667;
+          t['Z'] = 611;
+          t['bracketleft'] = 333;
+          t['backslash'] = 278;
+          t['bracketright'] = 333;
+          t['asciicircum'] = 584;
+          t['underscore'] = 556;
+          t['quoteleft'] = 278;
+          t['a'] = 556;
+          t['b'] = 611;
+          t['c'] = 556;
+          t['d'] = 611;
+          t['e'] = 556;
+          t['f'] = 333;
+          t['g'] = 611;
+          t['h'] = 611;
+          t['i'] = 278;
+          t['j'] = 278;
+          t['k'] = 556;
+          t['l'] = 278;
+          t['m'] = 889;
+          t['n'] = 611;
+          t['o'] = 611;
+          t['p'] = 611;
+          t['q'] = 611;
+          t['r'] = 389;
+          t['s'] = 556;
+          t['t'] = 333;
+          t['u'] = 611;
+          t['v'] = 556;
+          t['w'] = 778;
+          t['x'] = 556;
+          t['y'] = 556;
+          t['z'] = 500;
+          t['braceleft'] = 389;
+          t['bar'] = 280;
+          t['braceright'] = 389;
+          t['asciitilde'] = 584;
+          t['exclamdown'] = 333;
+          t['cent'] = 556;
+          t['sterling'] = 556;
+          t['fraction'] = 167;
+          t['yen'] = 556;
+          t['florin'] = 556;
+          t['section'] = 556;
+          t['currency'] = 556;
+          t['quotesingle'] = 238;
+          t['quotedblleft'] = 500;
+          t['guillemotleft'] = 556;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 611;
+          t['fl'] = 611;
+          t['endash'] = 556;
+          t['dagger'] = 556;
+          t['daggerdbl'] = 556;
+          t['periodcentered'] = 278;
+          t['paragraph'] = 556;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 278;
+          t['quotedblbase'] = 500;
+          t['quotedblright'] = 500;
+          t['guillemotright'] = 556;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 611;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 1000;
+          t['ordfeminine'] = 370;
+          t['Lslash'] = 611;
+          t['Oslash'] = 778;
+          t['OE'] = 1000;
+          t['ordmasculine'] = 365;
+          t['ae'] = 889;
+          t['dotlessi'] = 278;
+          t['lslash'] = 278;
+          t['oslash'] = 611;
+          t['oe'] = 944;
+          t['germandbls'] = 611;
+          t['Idieresis'] = 278;
+          t['eacute'] = 556;
+          t['abreve'] = 556;
+          t['uhungarumlaut'] = 611;
+          t['ecaron'] = 556;
+          t['Ydieresis'] = 667;
+          t['divide'] = 584;
+          t['Yacute'] = 667;
+          t['Acircumflex'] = 722;
+          t['aacute'] = 556;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 556;
+          t['scommaaccent'] = 556;
+          t['ecircumflex'] = 556;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 556;
+          t['Uacute'] = 722;
+          t['uogonek'] = 611;
+          t['Edieresis'] = 667;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 737;
+          t['Emacron'] = 667;
+          t['ccaron'] = 556;
+          t['aring'] = 556;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 278;
+          t['agrave'] = 556;
+          t['Tcommaaccent'] = 611;
+          t['Cacute'] = 722;
+          t['atilde'] = 556;
+          t['Edotaccent'] = 667;
+          t['scaron'] = 556;
+          t['scedilla'] = 556;
+          t['iacute'] = 278;
+          t['lozenge'] = 494;
+          t['Rcaron'] = 722;
+          t['Gcommaaccent'] = 778;
+          t['ucircumflex'] = 611;
+          t['acircumflex'] = 556;
+          t['Amacron'] = 722;
+          t['rcaron'] = 389;
+          t['ccedilla'] = 556;
+          t['Zdotaccent'] = 611;
+          t['Thorn'] = 667;
+          t['Omacron'] = 778;
+          t['Racute'] = 722;
+          t['Sacute'] = 667;
+          t['dcaron'] = 743;
+          t['Umacron'] = 722;
+          t['uring'] = 611;
+          t['threesuperior'] = 333;
+          t['Ograve'] = 778;
+          t['Agrave'] = 722;
+          t['Abreve'] = 722;
+          t['multiply'] = 584;
+          t['uacute'] = 611;
+          t['Tcaron'] = 611;
+          t['partialdiff'] = 494;
+          t['ydieresis'] = 556;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 667;
+          t['adieresis'] = 556;
+          t['edieresis'] = 556;
+          t['cacute'] = 556;
+          t['nacute'] = 611;
+          t['umacron'] = 611;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 278;
+          t['plusminus'] = 584;
+          t['brokenbar'] = 280;
+          t['registered'] = 737;
+          t['Gbreve'] = 778;
+          t['Idotaccent'] = 278;
+          t['summation'] = 600;
+          t['Egrave'] = 667;
+          t['racute'] = 389;
+          t['omacron'] = 611;
+          t['Zacute'] = 611;
+          t['Zcaron'] = 611;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 722;
+          t['lcommaaccent'] = 278;
+          t['tcaron'] = 389;
+          t['eogonek'] = 556;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 722;
+          t['Adieresis'] = 722;
+          t['egrave'] = 556;
+          t['zacute'] = 500;
+          t['iogonek'] = 278;
+          t['Oacute'] = 778;
+          t['oacute'] = 611;
+          t['amacron'] = 556;
+          t['sacute'] = 556;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 778;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 611;
+          t['twosuperior'] = 333;
+          t['Odieresis'] = 778;
+          t['mu'] = 611;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 611;
+          t['Eogonek'] = 667;
+          t['dcroat'] = 611;
+          t['threequarters'] = 834;
+          t['Scedilla'] = 667;
+          t['lcaron'] = 400;
+          t['Kcommaaccent'] = 722;
+          t['Lacute'] = 611;
+          t['trademark'] = 1000;
+          t['edotaccent'] = 556;
+          t['Igrave'] = 278;
+          t['Imacron'] = 278;
+          t['Lcaron'] = 611;
+          t['onehalf'] = 834;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 611;
+          t['ntilde'] = 611;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 667;
+          t['emacron'] = 556;
+          t['gbreve'] = 611;
+          t['onequarter'] = 834;
+          t['Scaron'] = 667;
+          t['Scommaaccent'] = 667;
+          t['Ohungarumlaut'] = 778;
+          t['degree'] = 400;
+          t['ograve'] = 611;
+          t['Ccaron'] = 722;
+          t['ugrave'] = 611;
+          t['radical'] = 549;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 389;
+          t['Ntilde'] = 722;
+          t['otilde'] = 611;
+          t['Rcommaaccent'] = 722;
+          t['Lcommaaccent'] = 611;
+          t['Atilde'] = 722;
+          t['Aogonek'] = 722;
+          t['Aring'] = 722;
+          t['Otilde'] = 778;
+          t['zdotaccent'] = 500;
+          t['Ecaron'] = 667;
+          t['Iogonek'] = 278;
+          t['kcommaaccent'] = 556;
+          t['minus'] = 584;
+          t['Icircumflex'] = 278;
+          t['ncaron'] = 611;
+          t['tcommaaccent'] = 333;
+          t['logicalnot'] = 584;
+          t['odieresis'] = 611;
+          t['udieresis'] = 611;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 611;
+          t['eth'] = 611;
+          t['zcaron'] = 500;
+          t['ncommaaccent'] = 611;
+          t['onesuperior'] = 333;
+          t['imacron'] = 278;
+          t['Euro'] = 556;
+        });
+        t['Helvetica-BoldOblique'] = getLookupTableFactory(function (t) {
+          t['space'] = 278;
+          t['exclam'] = 333;
+          t['quotedbl'] = 474;
+          t['numbersign'] = 556;
+          t['dollar'] = 556;
+          t['percent'] = 889;
+          t['ampersand'] = 722;
+          t['quoteright'] = 278;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 389;
+          t['plus'] = 584;
+          t['comma'] = 278;
+          t['hyphen'] = 333;
+          t['period'] = 278;
+          t['slash'] = 278;
+          t['zero'] = 556;
+          t['one'] = 556;
+          t['two'] = 556;
+          t['three'] = 556;
+          t['four'] = 556;
+          t['five'] = 556;
+          t['six'] = 556;
+          t['seven'] = 556;
+          t['eight'] = 556;
+          t['nine'] = 556;
+          t['colon'] = 333;
+          t['semicolon'] = 333;
+          t['less'] = 584;
+          t['equal'] = 584;
+          t['greater'] = 584;
+          t['question'] = 611;
+          t['at'] = 975;
+          t['A'] = 722;
+          t['B'] = 722;
+          t['C'] = 722;
+          t['D'] = 722;
+          t['E'] = 667;
+          t['F'] = 611;
+          t['G'] = 778;
+          t['H'] = 722;
+          t['I'] = 278;
+          t['J'] = 556;
+          t['K'] = 722;
+          t['L'] = 611;
+          t['M'] = 833;
+          t['N'] = 722;
+          t['O'] = 778;
+          t['P'] = 667;
+          t['Q'] = 778;
+          t['R'] = 722;
+          t['S'] = 667;
+          t['T'] = 611;
+          t['U'] = 722;
+          t['V'] = 667;
+          t['W'] = 944;
+          t['X'] = 667;
+          t['Y'] = 667;
+          t['Z'] = 611;
+          t['bracketleft'] = 333;
+          t['backslash'] = 278;
+          t['bracketright'] = 333;
+          t['asciicircum'] = 584;
+          t['underscore'] = 556;
+          t['quoteleft'] = 278;
+          t['a'] = 556;
+          t['b'] = 611;
+          t['c'] = 556;
+          t['d'] = 611;
+          t['e'] = 556;
+          t['f'] = 333;
+          t['g'] = 611;
+          t['h'] = 611;
+          t['i'] = 278;
+          t['j'] = 278;
+          t['k'] = 556;
+          t['l'] = 278;
+          t['m'] = 889;
+          t['n'] = 611;
+          t['o'] = 611;
+          t['p'] = 611;
+          t['q'] = 611;
+          t['r'] = 389;
+          t['s'] = 556;
+          t['t'] = 333;
+          t['u'] = 611;
+          t['v'] = 556;
+          t['w'] = 778;
+          t['x'] = 556;
+          t['y'] = 556;
+          t['z'] = 500;
+          t['braceleft'] = 389;
+          t['bar'] = 280;
+          t['braceright'] = 389;
+          t['asciitilde'] = 584;
+          t['exclamdown'] = 333;
+          t['cent'] = 556;
+          t['sterling'] = 556;
+          t['fraction'] = 167;
+          t['yen'] = 556;
+          t['florin'] = 556;
+          t['section'] = 556;
+          t['currency'] = 556;
+          t['quotesingle'] = 238;
+          t['quotedblleft'] = 500;
+          t['guillemotleft'] = 556;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 611;
+          t['fl'] = 611;
+          t['endash'] = 556;
+          t['dagger'] = 556;
+          t['daggerdbl'] = 556;
+          t['periodcentered'] = 278;
+          t['paragraph'] = 556;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 278;
+          t['quotedblbase'] = 500;
+          t['quotedblright'] = 500;
+          t['guillemotright'] = 556;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 611;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 1000;
+          t['ordfeminine'] = 370;
+          t['Lslash'] = 611;
+          t['Oslash'] = 778;
+          t['OE'] = 1000;
+          t['ordmasculine'] = 365;
+          t['ae'] = 889;
+          t['dotlessi'] = 278;
+          t['lslash'] = 278;
+          t['oslash'] = 611;
+          t['oe'] = 944;
+          t['germandbls'] = 611;
+          t['Idieresis'] = 278;
+          t['eacute'] = 556;
+          t['abreve'] = 556;
+          t['uhungarumlaut'] = 611;
+          t['ecaron'] = 556;
+          t['Ydieresis'] = 667;
+          t['divide'] = 584;
+          t['Yacute'] = 667;
+          t['Acircumflex'] = 722;
+          t['aacute'] = 556;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 556;
+          t['scommaaccent'] = 556;
+          t['ecircumflex'] = 556;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 556;
+          t['Uacute'] = 722;
+          t['uogonek'] = 611;
+          t['Edieresis'] = 667;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 737;
+          t['Emacron'] = 667;
+          t['ccaron'] = 556;
+          t['aring'] = 556;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 278;
+          t['agrave'] = 556;
+          t['Tcommaaccent'] = 611;
+          t['Cacute'] = 722;
+          t['atilde'] = 556;
+          t['Edotaccent'] = 667;
+          t['scaron'] = 556;
+          t['scedilla'] = 556;
+          t['iacute'] = 278;
+          t['lozenge'] = 494;
+          t['Rcaron'] = 722;
+          t['Gcommaaccent'] = 778;
+          t['ucircumflex'] = 611;
+          t['acircumflex'] = 556;
+          t['Amacron'] = 722;
+          t['rcaron'] = 389;
+          t['ccedilla'] = 556;
+          t['Zdotaccent'] = 611;
+          t['Thorn'] = 667;
+          t['Omacron'] = 778;
+          t['Racute'] = 722;
+          t['Sacute'] = 667;
+          t['dcaron'] = 743;
+          t['Umacron'] = 722;
+          t['uring'] = 611;
+          t['threesuperior'] = 333;
+          t['Ograve'] = 778;
+          t['Agrave'] = 722;
+          t['Abreve'] = 722;
+          t['multiply'] = 584;
+          t['uacute'] = 611;
+          t['Tcaron'] = 611;
+          t['partialdiff'] = 494;
+          t['ydieresis'] = 556;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 667;
+          t['adieresis'] = 556;
+          t['edieresis'] = 556;
+          t['cacute'] = 556;
+          t['nacute'] = 611;
+          t['umacron'] = 611;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 278;
+          t['plusminus'] = 584;
+          t['brokenbar'] = 280;
+          t['registered'] = 737;
+          t['Gbreve'] = 778;
+          t['Idotaccent'] = 278;
+          t['summation'] = 600;
+          t['Egrave'] = 667;
+          t['racute'] = 389;
+          t['omacron'] = 611;
+          t['Zacute'] = 611;
+          t['Zcaron'] = 611;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 722;
+          t['lcommaaccent'] = 278;
+          t['tcaron'] = 389;
+          t['eogonek'] = 556;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 722;
+          t['Adieresis'] = 722;
+          t['egrave'] = 556;
+          t['zacute'] = 500;
+          t['iogonek'] = 278;
+          t['Oacute'] = 778;
+          t['oacute'] = 611;
+          t['amacron'] = 556;
+          t['sacute'] = 556;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 778;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 611;
+          t['twosuperior'] = 333;
+          t['Odieresis'] = 778;
+          t['mu'] = 611;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 611;
+          t['Eogonek'] = 667;
+          t['dcroat'] = 611;
+          t['threequarters'] = 834;
+          t['Scedilla'] = 667;
+          t['lcaron'] = 400;
+          t['Kcommaaccent'] = 722;
+          t['Lacute'] = 611;
+          t['trademark'] = 1000;
+          t['edotaccent'] = 556;
+          t['Igrave'] = 278;
+          t['Imacron'] = 278;
+          t['Lcaron'] = 611;
+          t['onehalf'] = 834;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 611;
+          t['ntilde'] = 611;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 667;
+          t['emacron'] = 556;
+          t['gbreve'] = 611;
+          t['onequarter'] = 834;
+          t['Scaron'] = 667;
+          t['Scommaaccent'] = 667;
+          t['Ohungarumlaut'] = 778;
+          t['degree'] = 400;
+          t['ograve'] = 611;
+          t['Ccaron'] = 722;
+          t['ugrave'] = 611;
+          t['radical'] = 549;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 389;
+          t['Ntilde'] = 722;
+          t['otilde'] = 611;
+          t['Rcommaaccent'] = 722;
+          t['Lcommaaccent'] = 611;
+          t['Atilde'] = 722;
+          t['Aogonek'] = 722;
+          t['Aring'] = 722;
+          t['Otilde'] = 778;
+          t['zdotaccent'] = 500;
+          t['Ecaron'] = 667;
+          t['Iogonek'] = 278;
+          t['kcommaaccent'] = 556;
+          t['minus'] = 584;
+          t['Icircumflex'] = 278;
+          t['ncaron'] = 611;
+          t['tcommaaccent'] = 333;
+          t['logicalnot'] = 584;
+          t['odieresis'] = 611;
+          t['udieresis'] = 611;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 611;
+          t['eth'] = 611;
+          t['zcaron'] = 500;
+          t['ncommaaccent'] = 611;
+          t['onesuperior'] = 333;
+          t['imacron'] = 278;
+          t['Euro'] = 556;
+        });
+        t['Helvetica-Oblique'] = getLookupTableFactory(function (t) {
+          t['space'] = 278;
+          t['exclam'] = 278;
+          t['quotedbl'] = 355;
+          t['numbersign'] = 556;
+          t['dollar'] = 556;
+          t['percent'] = 889;
+          t['ampersand'] = 667;
+          t['quoteright'] = 222;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 389;
+          t['plus'] = 584;
+          t['comma'] = 278;
+          t['hyphen'] = 333;
+          t['period'] = 278;
+          t['slash'] = 278;
+          t['zero'] = 556;
+          t['one'] = 556;
+          t['two'] = 556;
+          t['three'] = 556;
+          t['four'] = 556;
+          t['five'] = 556;
+          t['six'] = 556;
+          t['seven'] = 556;
+          t['eight'] = 556;
+          t['nine'] = 556;
+          t['colon'] = 278;
+          t['semicolon'] = 278;
+          t['less'] = 584;
+          t['equal'] = 584;
+          t['greater'] = 584;
+          t['question'] = 556;
+          t['at'] = 1015;
+          t['A'] = 667;
+          t['B'] = 667;
+          t['C'] = 722;
+          t['D'] = 722;
+          t['E'] = 667;
+          t['F'] = 611;
+          t['G'] = 778;
+          t['H'] = 722;
+          t['I'] = 278;
+          t['J'] = 500;
+          t['K'] = 667;
+          t['L'] = 556;
+          t['M'] = 833;
+          t['N'] = 722;
+          t['O'] = 778;
+          t['P'] = 667;
+          t['Q'] = 778;
+          t['R'] = 722;
+          t['S'] = 667;
+          t['T'] = 611;
+          t['U'] = 722;
+          t['V'] = 667;
+          t['W'] = 944;
+          t['X'] = 667;
+          t['Y'] = 667;
+          t['Z'] = 611;
+          t['bracketleft'] = 278;
+          t['backslash'] = 278;
+          t['bracketright'] = 278;
+          t['asciicircum'] = 469;
+          t['underscore'] = 556;
+          t['quoteleft'] = 222;
+          t['a'] = 556;
+          t['b'] = 556;
+          t['c'] = 500;
+          t['d'] = 556;
+          t['e'] = 556;
+          t['f'] = 278;
+          t['g'] = 556;
+          t['h'] = 556;
+          t['i'] = 222;
+          t['j'] = 222;
+          t['k'] = 500;
+          t['l'] = 222;
+          t['m'] = 833;
+          t['n'] = 556;
+          t['o'] = 556;
+          t['p'] = 556;
+          t['q'] = 556;
+          t['r'] = 333;
+          t['s'] = 500;
+          t['t'] = 278;
+          t['u'] = 556;
+          t['v'] = 500;
+          t['w'] = 722;
+          t['x'] = 500;
+          t['y'] = 500;
+          t['z'] = 500;
+          t['braceleft'] = 334;
+          t['bar'] = 260;
+          t['braceright'] = 334;
+          t['asciitilde'] = 584;
+          t['exclamdown'] = 333;
+          t['cent'] = 556;
+          t['sterling'] = 556;
+          t['fraction'] = 167;
+          t['yen'] = 556;
+          t['florin'] = 556;
+          t['section'] = 556;
+          t['currency'] = 556;
+          t['quotesingle'] = 191;
+          t['quotedblleft'] = 333;
+          t['guillemotleft'] = 556;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 500;
+          t['fl'] = 500;
+          t['endash'] = 556;
+          t['dagger'] = 556;
+          t['daggerdbl'] = 556;
+          t['periodcentered'] = 278;
+          t['paragraph'] = 537;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 222;
+          t['quotedblbase'] = 333;
+          t['quotedblright'] = 333;
+          t['guillemotright'] = 556;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 611;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 1000;
+          t['ordfeminine'] = 370;
+          t['Lslash'] = 556;
+          t['Oslash'] = 778;
+          t['OE'] = 1000;
+          t['ordmasculine'] = 365;
+          t['ae'] = 889;
+          t['dotlessi'] = 278;
+          t['lslash'] = 222;
+          t['oslash'] = 611;
+          t['oe'] = 944;
+          t['germandbls'] = 611;
+          t['Idieresis'] = 278;
+          t['eacute'] = 556;
+          t['abreve'] = 556;
+          t['uhungarumlaut'] = 556;
+          t['ecaron'] = 556;
+          t['Ydieresis'] = 667;
+          t['divide'] = 584;
+          t['Yacute'] = 667;
+          t['Acircumflex'] = 667;
+          t['aacute'] = 556;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 500;
+          t['scommaaccent'] = 500;
+          t['ecircumflex'] = 556;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 556;
+          t['Uacute'] = 722;
+          t['uogonek'] = 556;
+          t['Edieresis'] = 667;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 737;
+          t['Emacron'] = 667;
+          t['ccaron'] = 500;
+          t['aring'] = 556;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 222;
+          t['agrave'] = 556;
+          t['Tcommaaccent'] = 611;
+          t['Cacute'] = 722;
+          t['atilde'] = 556;
+          t['Edotaccent'] = 667;
+          t['scaron'] = 500;
+          t['scedilla'] = 500;
+          t['iacute'] = 278;
+          t['lozenge'] = 471;
+          t['Rcaron'] = 722;
+          t['Gcommaaccent'] = 778;
+          t['ucircumflex'] = 556;
+          t['acircumflex'] = 556;
+          t['Amacron'] = 667;
+          t['rcaron'] = 333;
+          t['ccedilla'] = 500;
+          t['Zdotaccent'] = 611;
+          t['Thorn'] = 667;
+          t['Omacron'] = 778;
+          t['Racute'] = 722;
+          t['Sacute'] = 667;
+          t['dcaron'] = 643;
+          t['Umacron'] = 722;
+          t['uring'] = 556;
+          t['threesuperior'] = 333;
+          t['Ograve'] = 778;
+          t['Agrave'] = 667;
+          t['Abreve'] = 667;
+          t['multiply'] = 584;
+          t['uacute'] = 556;
+          t['Tcaron'] = 611;
+          t['partialdiff'] = 476;
+          t['ydieresis'] = 500;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 667;
+          t['adieresis'] = 556;
+          t['edieresis'] = 556;
+          t['cacute'] = 500;
+          t['nacute'] = 556;
+          t['umacron'] = 556;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 278;
+          t['plusminus'] = 584;
+          t['brokenbar'] = 260;
+          t['registered'] = 737;
+          t['Gbreve'] = 778;
+          t['Idotaccent'] = 278;
+          t['summation'] = 600;
+          t['Egrave'] = 667;
+          t['racute'] = 333;
+          t['omacron'] = 556;
+          t['Zacute'] = 611;
+          t['Zcaron'] = 611;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 722;
+          t['lcommaaccent'] = 222;
+          t['tcaron'] = 317;
+          t['eogonek'] = 556;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 667;
+          t['Adieresis'] = 667;
+          t['egrave'] = 556;
+          t['zacute'] = 500;
+          t['iogonek'] = 222;
+          t['Oacute'] = 778;
+          t['oacute'] = 556;
+          t['amacron'] = 556;
+          t['sacute'] = 500;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 778;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 556;
+          t['twosuperior'] = 333;
+          t['Odieresis'] = 778;
+          t['mu'] = 556;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 556;
+          t['Eogonek'] = 667;
+          t['dcroat'] = 556;
+          t['threequarters'] = 834;
+          t['Scedilla'] = 667;
+          t['lcaron'] = 299;
+          t['Kcommaaccent'] = 667;
+          t['Lacute'] = 556;
+          t['trademark'] = 1000;
+          t['edotaccent'] = 556;
+          t['Igrave'] = 278;
+          t['Imacron'] = 278;
+          t['Lcaron'] = 556;
+          t['onehalf'] = 834;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 556;
+          t['ntilde'] = 556;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 667;
+          t['emacron'] = 556;
+          t['gbreve'] = 556;
+          t['onequarter'] = 834;
+          t['Scaron'] = 667;
+          t['Scommaaccent'] = 667;
+          t['Ohungarumlaut'] = 778;
+          t['degree'] = 400;
+          t['ograve'] = 556;
+          t['Ccaron'] = 722;
+          t['ugrave'] = 556;
+          t['radical'] = 453;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 333;
+          t['Ntilde'] = 722;
+          t['otilde'] = 556;
+          t['Rcommaaccent'] = 722;
+          t['Lcommaaccent'] = 556;
+          t['Atilde'] = 667;
+          t['Aogonek'] = 667;
+          t['Aring'] = 667;
+          t['Otilde'] = 778;
+          t['zdotaccent'] = 500;
+          t['Ecaron'] = 667;
+          t['Iogonek'] = 278;
+          t['kcommaaccent'] = 500;
+          t['minus'] = 584;
+          t['Icircumflex'] = 278;
+          t['ncaron'] = 556;
+          t['tcommaaccent'] = 278;
+          t['logicalnot'] = 584;
+          t['odieresis'] = 556;
+          t['udieresis'] = 556;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 556;
+          t['eth'] = 556;
+          t['zcaron'] = 500;
+          t['ncommaaccent'] = 556;
+          t['onesuperior'] = 333;
+          t['imacron'] = 278;
+          t['Euro'] = 556;
+        });
+        t['Symbol'] = getLookupTableFactory(function (t) {
+          t['space'] = 250;
+          t['exclam'] = 333;
+          t['universal'] = 713;
+          t['numbersign'] = 500;
+          t['existential'] = 549;
+          t['percent'] = 833;
+          t['ampersand'] = 778;
+          t['suchthat'] = 439;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asteriskmath'] = 500;
+          t['plus'] = 549;
+          t['comma'] = 250;
+          t['minus'] = 549;
+          t['period'] = 250;
+          t['slash'] = 278;
+          t['zero'] = 500;
+          t['one'] = 500;
+          t['two'] = 500;
+          t['three'] = 500;
+          t['four'] = 500;
+          t['five'] = 500;
+          t['six'] = 500;
+          t['seven'] = 500;
+          t['eight'] = 500;
+          t['nine'] = 500;
+          t['colon'] = 278;
+          t['semicolon'] = 278;
+          t['less'] = 549;
+          t['equal'] = 549;
+          t['greater'] = 549;
+          t['question'] = 444;
+          t['congruent'] = 549;
+          t['Alpha'] = 722;
+          t['Beta'] = 667;
+          t['Chi'] = 722;
+          t['Delta'] = 612;
+          t['Epsilon'] = 611;
+          t['Phi'] = 763;
+          t['Gamma'] = 603;
+          t['Eta'] = 722;
+          t['Iota'] = 333;
+          t['theta1'] = 631;
+          t['Kappa'] = 722;
+          t['Lambda'] = 686;
+          t['Mu'] = 889;
+          t['Nu'] = 722;
+          t['Omicron'] = 722;
+          t['Pi'] = 768;
+          t['Theta'] = 741;
+          t['Rho'] = 556;
+          t['Sigma'] = 592;
+          t['Tau'] = 611;
+          t['Upsilon'] = 690;
+          t['sigma1'] = 439;
+          t['Omega'] = 768;
+          t['Xi'] = 645;
+          t['Psi'] = 795;
+          t['Zeta'] = 611;
+          t['bracketleft'] = 333;
+          t['therefore'] = 863;
+          t['bracketright'] = 333;
+          t['perpendicular'] = 658;
+          t['underscore'] = 500;
+          t['radicalex'] = 500;
+          t['alpha'] = 631;
+          t['beta'] = 549;
+          t['chi'] = 549;
+          t['delta'] = 494;
+          t['epsilon'] = 439;
+          t['phi'] = 521;
+          t['gamma'] = 411;
+          t['eta'] = 603;
+          t['iota'] = 329;
+          t['phi1'] = 603;
+          t['kappa'] = 549;
+          t['lambda'] = 549;
+          t['mu'] = 576;
+          t['nu'] = 521;
+          t['omicron'] = 549;
+          t['pi'] = 549;
+          t['theta'] = 521;
+          t['rho'] = 549;
+          t['sigma'] = 603;
+          t['tau'] = 439;
+          t['upsilon'] = 576;
+          t['omega1'] = 713;
+          t['omega'] = 686;
+          t['xi'] = 493;
+          t['psi'] = 686;
+          t['zeta'] = 494;
+          t['braceleft'] = 480;
+          t['bar'] = 200;
+          t['braceright'] = 480;
+          t['similar'] = 549;
+          t['Euro'] = 750;
+          t['Upsilon1'] = 620;
+          t['minute'] = 247;
+          t['lessequal'] = 549;
+          t['fraction'] = 167;
+          t['infinity'] = 713;
+          t['florin'] = 500;
+          t['club'] = 753;
+          t['diamond'] = 753;
+          t['heart'] = 753;
+          t['spade'] = 753;
+          t['arrowboth'] = 1042;
+          t['arrowleft'] = 987;
+          t['arrowup'] = 603;
+          t['arrowright'] = 987;
+          t['arrowdown'] = 603;
+          t['degree'] = 400;
+          t['plusminus'] = 549;
+          t['second'] = 411;
+          t['greaterequal'] = 549;
+          t['multiply'] = 549;
+          t['proportional'] = 713;
+          t['partialdiff'] = 494;
+          t['bullet'] = 460;
+          t['divide'] = 549;
+          t['notequal'] = 549;
+          t['equivalence'] = 549;
+          t['approxequal'] = 549;
+          t['ellipsis'] = 1000;
+          t['arrowvertex'] = 603;
+          t['arrowhorizex'] = 1000;
+          t['carriagereturn'] = 658;
+          t['aleph'] = 823;
+          t['Ifraktur'] = 686;
+          t['Rfraktur'] = 795;
+          t['weierstrass'] = 987;
+          t['circlemultiply'] = 768;
+          t['circleplus'] = 768;
+          t['emptyset'] = 823;
+          t['intersection'] = 768;
+          t['union'] = 768;
+          t['propersuperset'] = 713;
+          t['reflexsuperset'] = 713;
+          t['notsubset'] = 713;
+          t['propersubset'] = 713;
+          t['reflexsubset'] = 713;
+          t['element'] = 713;
+          t['notelement'] = 713;
+          t['angle'] = 768;
+          t['gradient'] = 713;
+          t['registerserif'] = 790;
+          t['copyrightserif'] = 790;
+          t['trademarkserif'] = 890;
+          t['product'] = 823;
+          t['radical'] = 549;
+          t['dotmath'] = 250;
+          t['logicalnot'] = 713;
+          t['logicaland'] = 603;
+          t['logicalor'] = 603;
+          t['arrowdblboth'] = 1042;
+          t['arrowdblleft'] = 987;
+          t['arrowdblup'] = 603;
+          t['arrowdblright'] = 987;
+          t['arrowdbldown'] = 603;
+          t['lozenge'] = 494;
+          t['angleleft'] = 329;
+          t['registersans'] = 790;
+          t['copyrightsans'] = 790;
+          t['trademarksans'] = 786;
+          t['summation'] = 713;
+          t['parenlefttp'] = 384;
+          t['parenleftex'] = 384;
+          t['parenleftbt'] = 384;
+          t['bracketlefttp'] = 384;
+          t['bracketleftex'] = 384;
+          t['bracketleftbt'] = 384;
+          t['bracelefttp'] = 494;
+          t['braceleftmid'] = 494;
+          t['braceleftbt'] = 494;
+          t['braceex'] = 494;
+          t['angleright'] = 329;
+          t['integral'] = 274;
+          t['integraltp'] = 686;
+          t['integralex'] = 686;
+          t['integralbt'] = 686;
+          t['parenrighttp'] = 384;
+          t['parenrightex'] = 384;
+          t['parenrightbt'] = 384;
+          t['bracketrighttp'] = 384;
+          t['bracketrightex'] = 384;
+          t['bracketrightbt'] = 384;
+          t['bracerighttp'] = 494;
+          t['bracerightmid'] = 494;
+          t['bracerightbt'] = 494;
+          t['apple'] = 790;
+        });
+        t['Times-Roman'] = getLookupTableFactory(function (t) {
+          t['space'] = 250;
+          t['exclam'] = 333;
+          t['quotedbl'] = 408;
+          t['numbersign'] = 500;
+          t['dollar'] = 500;
+          t['percent'] = 833;
+          t['ampersand'] = 778;
+          t['quoteright'] = 333;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 500;
+          t['plus'] = 564;
+          t['comma'] = 250;
+          t['hyphen'] = 333;
+          t['period'] = 250;
+          t['slash'] = 278;
+          t['zero'] = 500;
+          t['one'] = 500;
+          t['two'] = 500;
+          t['three'] = 500;
+          t['four'] = 500;
+          t['five'] = 500;
+          t['six'] = 500;
+          t['seven'] = 500;
+          t['eight'] = 500;
+          t['nine'] = 500;
+          t['colon'] = 278;
+          t['semicolon'] = 278;
+          t['less'] = 564;
+          t['equal'] = 564;
+          t['greater'] = 564;
+          t['question'] = 444;
+          t['at'] = 921;
+          t['A'] = 722;
+          t['B'] = 667;
+          t['C'] = 667;
+          t['D'] = 722;
+          t['E'] = 611;
+          t['F'] = 556;
+          t['G'] = 722;
+          t['H'] = 722;
+          t['I'] = 333;
+          t['J'] = 389;
+          t['K'] = 722;
+          t['L'] = 611;
+          t['M'] = 889;
+          t['N'] = 722;
+          t['O'] = 722;
+          t['P'] = 556;
+          t['Q'] = 722;
+          t['R'] = 667;
+          t['S'] = 556;
+          t['T'] = 611;
+          t['U'] = 722;
+          t['V'] = 722;
+          t['W'] = 944;
+          t['X'] = 722;
+          t['Y'] = 722;
+          t['Z'] = 611;
+          t['bracketleft'] = 333;
+          t['backslash'] = 278;
+          t['bracketright'] = 333;
+          t['asciicircum'] = 469;
+          t['underscore'] = 500;
+          t['quoteleft'] = 333;
+          t['a'] = 444;
+          t['b'] = 500;
+          t['c'] = 444;
+          t['d'] = 500;
+          t['e'] = 444;
+          t['f'] = 333;
+          t['g'] = 500;
+          t['h'] = 500;
+          t['i'] = 278;
+          t['j'] = 278;
+          t['k'] = 500;
+          t['l'] = 278;
+          t['m'] = 778;
+          t['n'] = 500;
+          t['o'] = 500;
+          t['p'] = 500;
+          t['q'] = 500;
+          t['r'] = 333;
+          t['s'] = 389;
+          t['t'] = 278;
+          t['u'] = 500;
+          t['v'] = 500;
+          t['w'] = 722;
+          t['x'] = 500;
+          t['y'] = 500;
+          t['z'] = 444;
+          t['braceleft'] = 480;
+          t['bar'] = 200;
+          t['braceright'] = 480;
+          t['asciitilde'] = 541;
+          t['exclamdown'] = 333;
+          t['cent'] = 500;
+          t['sterling'] = 500;
+          t['fraction'] = 167;
+          t['yen'] = 500;
+          t['florin'] = 500;
+          t['section'] = 500;
+          t['currency'] = 500;
+          t['quotesingle'] = 180;
+          t['quotedblleft'] = 444;
+          t['guillemotleft'] = 500;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 556;
+          t['fl'] = 556;
+          t['endash'] = 500;
+          t['dagger'] = 500;
+          t['daggerdbl'] = 500;
+          t['periodcentered'] = 250;
+          t['paragraph'] = 453;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 333;
+          t['quotedblbase'] = 444;
+          t['quotedblright'] = 444;
+          t['guillemotright'] = 500;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 444;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 889;
+          t['ordfeminine'] = 276;
+          t['Lslash'] = 611;
+          t['Oslash'] = 722;
+          t['OE'] = 889;
+          t['ordmasculine'] = 310;
+          t['ae'] = 667;
+          t['dotlessi'] = 278;
+          t['lslash'] = 278;
+          t['oslash'] = 500;
+          t['oe'] = 722;
+          t['germandbls'] = 500;
+          t['Idieresis'] = 333;
+          t['eacute'] = 444;
+          t['abreve'] = 444;
+          t['uhungarumlaut'] = 500;
+          t['ecaron'] = 444;
+          t['Ydieresis'] = 722;
+          t['divide'] = 564;
+          t['Yacute'] = 722;
+          t['Acircumflex'] = 722;
+          t['aacute'] = 444;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 500;
+          t['scommaaccent'] = 389;
+          t['ecircumflex'] = 444;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 444;
+          t['Uacute'] = 722;
+          t['uogonek'] = 500;
+          t['Edieresis'] = 611;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 760;
+          t['Emacron'] = 611;
+          t['ccaron'] = 444;
+          t['aring'] = 444;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 278;
+          t['agrave'] = 444;
+          t['Tcommaaccent'] = 611;
+          t['Cacute'] = 667;
+          t['atilde'] = 444;
+          t['Edotaccent'] = 611;
+          t['scaron'] = 389;
+          t['scedilla'] = 389;
+          t['iacute'] = 278;
+          t['lozenge'] = 471;
+          t['Rcaron'] = 667;
+          t['Gcommaaccent'] = 722;
+          t['ucircumflex'] = 500;
+          t['acircumflex'] = 444;
+          t['Amacron'] = 722;
+          t['rcaron'] = 333;
+          t['ccedilla'] = 444;
+          t['Zdotaccent'] = 611;
+          t['Thorn'] = 556;
+          t['Omacron'] = 722;
+          t['Racute'] = 667;
+          t['Sacute'] = 556;
+          t['dcaron'] = 588;
+          t['Umacron'] = 722;
+          t['uring'] = 500;
+          t['threesuperior'] = 300;
+          t['Ograve'] = 722;
+          t['Agrave'] = 722;
+          t['Abreve'] = 722;
+          t['multiply'] = 564;
+          t['uacute'] = 500;
+          t['Tcaron'] = 611;
+          t['partialdiff'] = 476;
+          t['ydieresis'] = 500;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 611;
+          t['adieresis'] = 444;
+          t['edieresis'] = 444;
+          t['cacute'] = 444;
+          t['nacute'] = 500;
+          t['umacron'] = 500;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 333;
+          t['plusminus'] = 564;
+          t['brokenbar'] = 200;
+          t['registered'] = 760;
+          t['Gbreve'] = 722;
+          t['Idotaccent'] = 333;
+          t['summation'] = 600;
+          t['Egrave'] = 611;
+          t['racute'] = 333;
+          t['omacron'] = 500;
+          t['Zacute'] = 611;
+          t['Zcaron'] = 611;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 667;
+          t['lcommaaccent'] = 278;
+          t['tcaron'] = 326;
+          t['eogonek'] = 444;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 722;
+          t['Adieresis'] = 722;
+          t['egrave'] = 444;
+          t['zacute'] = 444;
+          t['iogonek'] = 278;
+          t['Oacute'] = 722;
+          t['oacute'] = 500;
+          t['amacron'] = 444;
+          t['sacute'] = 389;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 722;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 500;
+          t['twosuperior'] = 300;
+          t['Odieresis'] = 722;
+          t['mu'] = 500;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 500;
+          t['Eogonek'] = 611;
+          t['dcroat'] = 500;
+          t['threequarters'] = 750;
+          t['Scedilla'] = 556;
+          t['lcaron'] = 344;
+          t['Kcommaaccent'] = 722;
+          t['Lacute'] = 611;
+          t['trademark'] = 980;
+          t['edotaccent'] = 444;
+          t['Igrave'] = 333;
+          t['Imacron'] = 333;
+          t['Lcaron'] = 611;
+          t['onehalf'] = 750;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 500;
+          t['ntilde'] = 500;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 611;
+          t['emacron'] = 444;
+          t['gbreve'] = 500;
+          t['onequarter'] = 750;
+          t['Scaron'] = 556;
+          t['Scommaaccent'] = 556;
+          t['Ohungarumlaut'] = 722;
+          t['degree'] = 400;
+          t['ograve'] = 500;
+          t['Ccaron'] = 667;
+          t['ugrave'] = 500;
+          t['radical'] = 453;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 333;
+          t['Ntilde'] = 722;
+          t['otilde'] = 500;
+          t['Rcommaaccent'] = 667;
+          t['Lcommaaccent'] = 611;
+          t['Atilde'] = 722;
+          t['Aogonek'] = 722;
+          t['Aring'] = 722;
+          t['Otilde'] = 722;
+          t['zdotaccent'] = 444;
+          t['Ecaron'] = 611;
+          t['Iogonek'] = 333;
+          t['kcommaaccent'] = 500;
+          t['minus'] = 564;
+          t['Icircumflex'] = 333;
+          t['ncaron'] = 500;
+          t['tcommaaccent'] = 278;
+          t['logicalnot'] = 564;
+          t['odieresis'] = 500;
+          t['udieresis'] = 500;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 500;
+          t['eth'] = 500;
+          t['zcaron'] = 444;
+          t['ncommaaccent'] = 500;
+          t['onesuperior'] = 300;
+          t['imacron'] = 278;
+          t['Euro'] = 500;
+        });
+        t['Times-Bold'] = getLookupTableFactory(function (t) {
+          t['space'] = 250;
+          t['exclam'] = 333;
+          t['quotedbl'] = 555;
+          t['numbersign'] = 500;
+          t['dollar'] = 500;
+          t['percent'] = 1000;
+          t['ampersand'] = 833;
+          t['quoteright'] = 333;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 500;
+          t['plus'] = 570;
+          t['comma'] = 250;
+          t['hyphen'] = 333;
+          t['period'] = 250;
+          t['slash'] = 278;
+          t['zero'] = 500;
+          t['one'] = 500;
+          t['two'] = 500;
+          t['three'] = 500;
+          t['four'] = 500;
+          t['five'] = 500;
+          t['six'] = 500;
+          t['seven'] = 500;
+          t['eight'] = 500;
+          t['nine'] = 500;
+          t['colon'] = 333;
+          t['semicolon'] = 333;
+          t['less'] = 570;
+          t['equal'] = 570;
+          t['greater'] = 570;
+          t['question'] = 500;
+          t['at'] = 930;
+          t['A'] = 722;
+          t['B'] = 667;
+          t['C'] = 722;
+          t['D'] = 722;
+          t['E'] = 667;
+          t['F'] = 611;
+          t['G'] = 778;
+          t['H'] = 778;
+          t['I'] = 389;
+          t['J'] = 500;
+          t['K'] = 778;
+          t['L'] = 667;
+          t['M'] = 944;
+          t['N'] = 722;
+          t['O'] = 778;
+          t['P'] = 611;
+          t['Q'] = 778;
+          t['R'] = 722;
+          t['S'] = 556;
+          t['T'] = 667;
+          t['U'] = 722;
+          t['V'] = 722;
+          t['W'] = 1000;
+          t['X'] = 722;
+          t['Y'] = 722;
+          t['Z'] = 667;
+          t['bracketleft'] = 333;
+          t['backslash'] = 278;
+          t['bracketright'] = 333;
+          t['asciicircum'] = 581;
+          t['underscore'] = 500;
+          t['quoteleft'] = 333;
+          t['a'] = 500;
+          t['b'] = 556;
+          t['c'] = 444;
+          t['d'] = 556;
+          t['e'] = 444;
+          t['f'] = 333;
+          t['g'] = 500;
+          t['h'] = 556;
+          t['i'] = 278;
+          t['j'] = 333;
+          t['k'] = 556;
+          t['l'] = 278;
+          t['m'] = 833;
+          t['n'] = 556;
+          t['o'] = 500;
+          t['p'] = 556;
+          t['q'] = 556;
+          t['r'] = 444;
+          t['s'] = 389;
+          t['t'] = 333;
+          t['u'] = 556;
+          t['v'] = 500;
+          t['w'] = 722;
+          t['x'] = 500;
+          t['y'] = 500;
+          t['z'] = 444;
+          t['braceleft'] = 394;
+          t['bar'] = 220;
+          t['braceright'] = 394;
+          t['asciitilde'] = 520;
+          t['exclamdown'] = 333;
+          t['cent'] = 500;
+          t['sterling'] = 500;
+          t['fraction'] = 167;
+          t['yen'] = 500;
+          t['florin'] = 500;
+          t['section'] = 500;
+          t['currency'] = 500;
+          t['quotesingle'] = 278;
+          t['quotedblleft'] = 500;
+          t['guillemotleft'] = 500;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 556;
+          t['fl'] = 556;
+          t['endash'] = 500;
+          t['dagger'] = 500;
+          t['daggerdbl'] = 500;
+          t['periodcentered'] = 250;
+          t['paragraph'] = 540;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 333;
+          t['quotedblbase'] = 500;
+          t['quotedblright'] = 500;
+          t['guillemotright'] = 500;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 500;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 1000;
+          t['ordfeminine'] = 300;
+          t['Lslash'] = 667;
+          t['Oslash'] = 778;
+          t['OE'] = 1000;
+          t['ordmasculine'] = 330;
+          t['ae'] = 722;
+          t['dotlessi'] = 278;
+          t['lslash'] = 278;
+          t['oslash'] = 500;
+          t['oe'] = 722;
+          t['germandbls'] = 556;
+          t['Idieresis'] = 389;
+          t['eacute'] = 444;
+          t['abreve'] = 500;
+          t['uhungarumlaut'] = 556;
+          t['ecaron'] = 444;
+          t['Ydieresis'] = 722;
+          t['divide'] = 570;
+          t['Yacute'] = 722;
+          t['Acircumflex'] = 722;
+          t['aacute'] = 500;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 500;
+          t['scommaaccent'] = 389;
+          t['ecircumflex'] = 444;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 500;
+          t['Uacute'] = 722;
+          t['uogonek'] = 556;
+          t['Edieresis'] = 667;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 747;
+          t['Emacron'] = 667;
+          t['ccaron'] = 444;
+          t['aring'] = 500;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 278;
+          t['agrave'] = 500;
+          t['Tcommaaccent'] = 667;
+          t['Cacute'] = 722;
+          t['atilde'] = 500;
+          t['Edotaccent'] = 667;
+          t['scaron'] = 389;
+          t['scedilla'] = 389;
+          t['iacute'] = 278;
+          t['lozenge'] = 494;
+          t['Rcaron'] = 722;
+          t['Gcommaaccent'] = 778;
+          t['ucircumflex'] = 556;
+          t['acircumflex'] = 500;
+          t['Amacron'] = 722;
+          t['rcaron'] = 444;
+          t['ccedilla'] = 444;
+          t['Zdotaccent'] = 667;
+          t['Thorn'] = 611;
+          t['Omacron'] = 778;
+          t['Racute'] = 722;
+          t['Sacute'] = 556;
+          t['dcaron'] = 672;
+          t['Umacron'] = 722;
+          t['uring'] = 556;
+          t['threesuperior'] = 300;
+          t['Ograve'] = 778;
+          t['Agrave'] = 722;
+          t['Abreve'] = 722;
+          t['multiply'] = 570;
+          t['uacute'] = 556;
+          t['Tcaron'] = 667;
+          t['partialdiff'] = 494;
+          t['ydieresis'] = 500;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 667;
+          t['adieresis'] = 500;
+          t['edieresis'] = 444;
+          t['cacute'] = 444;
+          t['nacute'] = 556;
+          t['umacron'] = 556;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 389;
+          t['plusminus'] = 570;
+          t['brokenbar'] = 220;
+          t['registered'] = 747;
+          t['Gbreve'] = 778;
+          t['Idotaccent'] = 389;
+          t['summation'] = 600;
+          t['Egrave'] = 667;
+          t['racute'] = 444;
+          t['omacron'] = 500;
+          t['Zacute'] = 667;
+          t['Zcaron'] = 667;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 722;
+          t['lcommaaccent'] = 278;
+          t['tcaron'] = 416;
+          t['eogonek'] = 444;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 722;
+          t['Adieresis'] = 722;
+          t['egrave'] = 444;
+          t['zacute'] = 444;
+          t['iogonek'] = 278;
+          t['Oacute'] = 778;
+          t['oacute'] = 500;
+          t['amacron'] = 500;
+          t['sacute'] = 389;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 778;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 556;
+          t['twosuperior'] = 300;
+          t['Odieresis'] = 778;
+          t['mu'] = 556;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 500;
+          t['Eogonek'] = 667;
+          t['dcroat'] = 556;
+          t['threequarters'] = 750;
+          t['Scedilla'] = 556;
+          t['lcaron'] = 394;
+          t['Kcommaaccent'] = 778;
+          t['Lacute'] = 667;
+          t['trademark'] = 1000;
+          t['edotaccent'] = 444;
+          t['Igrave'] = 389;
+          t['Imacron'] = 389;
+          t['Lcaron'] = 667;
+          t['onehalf'] = 750;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 500;
+          t['ntilde'] = 556;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 667;
+          t['emacron'] = 444;
+          t['gbreve'] = 500;
+          t['onequarter'] = 750;
+          t['Scaron'] = 556;
+          t['Scommaaccent'] = 556;
+          t['Ohungarumlaut'] = 778;
+          t['degree'] = 400;
+          t['ograve'] = 500;
+          t['Ccaron'] = 722;
+          t['ugrave'] = 556;
+          t['radical'] = 549;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 444;
+          t['Ntilde'] = 722;
+          t['otilde'] = 500;
+          t['Rcommaaccent'] = 722;
+          t['Lcommaaccent'] = 667;
+          t['Atilde'] = 722;
+          t['Aogonek'] = 722;
+          t['Aring'] = 722;
+          t['Otilde'] = 778;
+          t['zdotaccent'] = 444;
+          t['Ecaron'] = 667;
+          t['Iogonek'] = 389;
+          t['kcommaaccent'] = 556;
+          t['minus'] = 570;
+          t['Icircumflex'] = 389;
+          t['ncaron'] = 556;
+          t['tcommaaccent'] = 333;
+          t['logicalnot'] = 570;
+          t['odieresis'] = 500;
+          t['udieresis'] = 556;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 500;
+          t['eth'] = 500;
+          t['zcaron'] = 444;
+          t['ncommaaccent'] = 556;
+          t['onesuperior'] = 300;
+          t['imacron'] = 278;
+          t['Euro'] = 500;
+        });
+        t['Times-BoldItalic'] = getLookupTableFactory(function (t) {
+          t['space'] = 250;
+          t['exclam'] = 389;
+          t['quotedbl'] = 555;
+          t['numbersign'] = 500;
+          t['dollar'] = 500;
+          t['percent'] = 833;
+          t['ampersand'] = 778;
+          t['quoteright'] = 333;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 500;
+          t['plus'] = 570;
+          t['comma'] = 250;
+          t['hyphen'] = 333;
+          t['period'] = 250;
+          t['slash'] = 278;
+          t['zero'] = 500;
+          t['one'] = 500;
+          t['two'] = 500;
+          t['three'] = 500;
+          t['four'] = 500;
+          t['five'] = 500;
+          t['six'] = 500;
+          t['seven'] = 500;
+          t['eight'] = 500;
+          t['nine'] = 500;
+          t['colon'] = 333;
+          t['semicolon'] = 333;
+          t['less'] = 570;
+          t['equal'] = 570;
+          t['greater'] = 570;
+          t['question'] = 500;
+          t['at'] = 832;
+          t['A'] = 667;
+          t['B'] = 667;
+          t['C'] = 667;
+          t['D'] = 722;
+          t['E'] = 667;
+          t['F'] = 667;
+          t['G'] = 722;
+          t['H'] = 778;
+          t['I'] = 389;
+          t['J'] = 500;
+          t['K'] = 667;
+          t['L'] = 611;
+          t['M'] = 889;
+          t['N'] = 722;
+          t['O'] = 722;
+          t['P'] = 611;
+          t['Q'] = 722;
+          t['R'] = 667;
+          t['S'] = 556;
+          t['T'] = 611;
+          t['U'] = 722;
+          t['V'] = 667;
+          t['W'] = 889;
+          t['X'] = 667;
+          t['Y'] = 611;
+          t['Z'] = 611;
+          t['bracketleft'] = 333;
+          t['backslash'] = 278;
+          t['bracketright'] = 333;
+          t['asciicircum'] = 570;
+          t['underscore'] = 500;
+          t['quoteleft'] = 333;
+          t['a'] = 500;
+          t['b'] = 500;
+          t['c'] = 444;
+          t['d'] = 500;
+          t['e'] = 444;
+          t['f'] = 333;
+          t['g'] = 500;
+          t['h'] = 556;
+          t['i'] = 278;
+          t['j'] = 278;
+          t['k'] = 500;
+          t['l'] = 278;
+          t['m'] = 778;
+          t['n'] = 556;
+          t['o'] = 500;
+          t['p'] = 500;
+          t['q'] = 500;
+          t['r'] = 389;
+          t['s'] = 389;
+          t['t'] = 278;
+          t['u'] = 556;
+          t['v'] = 444;
+          t['w'] = 667;
+          t['x'] = 500;
+          t['y'] = 444;
+          t['z'] = 389;
+          t['braceleft'] = 348;
+          t['bar'] = 220;
+          t['braceright'] = 348;
+          t['asciitilde'] = 570;
+          t['exclamdown'] = 389;
+          t['cent'] = 500;
+          t['sterling'] = 500;
+          t['fraction'] = 167;
+          t['yen'] = 500;
+          t['florin'] = 500;
+          t['section'] = 500;
+          t['currency'] = 500;
+          t['quotesingle'] = 278;
+          t['quotedblleft'] = 500;
+          t['guillemotleft'] = 500;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 556;
+          t['fl'] = 556;
+          t['endash'] = 500;
+          t['dagger'] = 500;
+          t['daggerdbl'] = 500;
+          t['periodcentered'] = 250;
+          t['paragraph'] = 500;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 333;
+          t['quotedblbase'] = 500;
+          t['quotedblright'] = 500;
+          t['guillemotright'] = 500;
+          t['ellipsis'] = 1000;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 500;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 1000;
+          t['AE'] = 944;
+          t['ordfeminine'] = 266;
+          t['Lslash'] = 611;
+          t['Oslash'] = 722;
+          t['OE'] = 944;
+          t['ordmasculine'] = 300;
+          t['ae'] = 722;
+          t['dotlessi'] = 278;
+          t['lslash'] = 278;
+          t['oslash'] = 500;
+          t['oe'] = 722;
+          t['germandbls'] = 500;
+          t['Idieresis'] = 389;
+          t['eacute'] = 444;
+          t['abreve'] = 500;
+          t['uhungarumlaut'] = 556;
+          t['ecaron'] = 444;
+          t['Ydieresis'] = 611;
+          t['divide'] = 570;
+          t['Yacute'] = 611;
+          t['Acircumflex'] = 667;
+          t['aacute'] = 500;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 444;
+          t['scommaaccent'] = 389;
+          t['ecircumflex'] = 444;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 500;
+          t['Uacute'] = 722;
+          t['uogonek'] = 556;
+          t['Edieresis'] = 667;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 747;
+          t['Emacron'] = 667;
+          t['ccaron'] = 444;
+          t['aring'] = 500;
+          t['Ncommaaccent'] = 722;
+          t['lacute'] = 278;
+          t['agrave'] = 500;
+          t['Tcommaaccent'] = 611;
+          t['Cacute'] = 667;
+          t['atilde'] = 500;
+          t['Edotaccent'] = 667;
+          t['scaron'] = 389;
+          t['scedilla'] = 389;
+          t['iacute'] = 278;
+          t['lozenge'] = 494;
+          t['Rcaron'] = 667;
+          t['Gcommaaccent'] = 722;
+          t['ucircumflex'] = 556;
+          t['acircumflex'] = 500;
+          t['Amacron'] = 667;
+          t['rcaron'] = 389;
+          t['ccedilla'] = 444;
+          t['Zdotaccent'] = 611;
+          t['Thorn'] = 611;
+          t['Omacron'] = 722;
+          t['Racute'] = 667;
+          t['Sacute'] = 556;
+          t['dcaron'] = 608;
+          t['Umacron'] = 722;
+          t['uring'] = 556;
+          t['threesuperior'] = 300;
+          t['Ograve'] = 722;
+          t['Agrave'] = 667;
+          t['Abreve'] = 667;
+          t['multiply'] = 570;
+          t['uacute'] = 556;
+          t['Tcaron'] = 611;
+          t['partialdiff'] = 494;
+          t['ydieresis'] = 444;
+          t['Nacute'] = 722;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 667;
+          t['adieresis'] = 500;
+          t['edieresis'] = 444;
+          t['cacute'] = 444;
+          t['nacute'] = 556;
+          t['umacron'] = 556;
+          t['Ncaron'] = 722;
+          t['Iacute'] = 389;
+          t['plusminus'] = 570;
+          t['brokenbar'] = 220;
+          t['registered'] = 747;
+          t['Gbreve'] = 722;
+          t['Idotaccent'] = 389;
+          t['summation'] = 600;
+          t['Egrave'] = 667;
+          t['racute'] = 389;
+          t['omacron'] = 500;
+          t['Zacute'] = 611;
+          t['Zcaron'] = 611;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 667;
+          t['lcommaaccent'] = 278;
+          t['tcaron'] = 366;
+          t['eogonek'] = 444;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 667;
+          t['Adieresis'] = 667;
+          t['egrave'] = 444;
+          t['zacute'] = 389;
+          t['iogonek'] = 278;
+          t['Oacute'] = 722;
+          t['oacute'] = 500;
+          t['amacron'] = 500;
+          t['sacute'] = 389;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 722;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 500;
+          t['twosuperior'] = 300;
+          t['Odieresis'] = 722;
+          t['mu'] = 576;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 500;
+          t['Eogonek'] = 667;
+          t['dcroat'] = 500;
+          t['threequarters'] = 750;
+          t['Scedilla'] = 556;
+          t['lcaron'] = 382;
+          t['Kcommaaccent'] = 667;
+          t['Lacute'] = 611;
+          t['trademark'] = 1000;
+          t['edotaccent'] = 444;
+          t['Igrave'] = 389;
+          t['Imacron'] = 389;
+          t['Lcaron'] = 611;
+          t['onehalf'] = 750;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 500;
+          t['ntilde'] = 556;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 667;
+          t['emacron'] = 444;
+          t['gbreve'] = 500;
+          t['onequarter'] = 750;
+          t['Scaron'] = 556;
+          t['Scommaaccent'] = 556;
+          t['Ohungarumlaut'] = 722;
+          t['degree'] = 400;
+          t['ograve'] = 500;
+          t['Ccaron'] = 667;
+          t['ugrave'] = 556;
+          t['radical'] = 549;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 389;
+          t['Ntilde'] = 722;
+          t['otilde'] = 500;
+          t['Rcommaaccent'] = 667;
+          t['Lcommaaccent'] = 611;
+          t['Atilde'] = 667;
+          t['Aogonek'] = 667;
+          t['Aring'] = 667;
+          t['Otilde'] = 722;
+          t['zdotaccent'] = 389;
+          t['Ecaron'] = 667;
+          t['Iogonek'] = 389;
+          t['kcommaaccent'] = 500;
+          t['minus'] = 606;
+          t['Icircumflex'] = 389;
+          t['ncaron'] = 556;
+          t['tcommaaccent'] = 278;
+          t['logicalnot'] = 606;
+          t['odieresis'] = 500;
+          t['udieresis'] = 556;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 500;
+          t['eth'] = 500;
+          t['zcaron'] = 389;
+          t['ncommaaccent'] = 556;
+          t['onesuperior'] = 300;
+          t['imacron'] = 278;
+          t['Euro'] = 500;
+        });
+        t['Times-Italic'] = getLookupTableFactory(function (t) {
+          t['space'] = 250;
+          t['exclam'] = 333;
+          t['quotedbl'] = 420;
+          t['numbersign'] = 500;
+          t['dollar'] = 500;
+          t['percent'] = 833;
+          t['ampersand'] = 778;
+          t['quoteright'] = 333;
+          t['parenleft'] = 333;
+          t['parenright'] = 333;
+          t['asterisk'] = 500;
+          t['plus'] = 675;
+          t['comma'] = 250;
+          t['hyphen'] = 333;
+          t['period'] = 250;
+          t['slash'] = 278;
+          t['zero'] = 500;
+          t['one'] = 500;
+          t['two'] = 500;
+          t['three'] = 500;
+          t['four'] = 500;
+          t['five'] = 500;
+          t['six'] = 500;
+          t['seven'] = 500;
+          t['eight'] = 500;
+          t['nine'] = 500;
+          t['colon'] = 333;
+          t['semicolon'] = 333;
+          t['less'] = 675;
+          t['equal'] = 675;
+          t['greater'] = 675;
+          t['question'] = 500;
+          t['at'] = 920;
+          t['A'] = 611;
+          t['B'] = 611;
+          t['C'] = 667;
+          t['D'] = 722;
+          t['E'] = 611;
+          t['F'] = 611;
+          t['G'] = 722;
+          t['H'] = 722;
+          t['I'] = 333;
+          t['J'] = 444;
+          t['K'] = 667;
+          t['L'] = 556;
+          t['M'] = 833;
+          t['N'] = 667;
+          t['O'] = 722;
+          t['P'] = 611;
+          t['Q'] = 722;
+          t['R'] = 611;
+          t['S'] = 500;
+          t['T'] = 556;
+          t['U'] = 722;
+          t['V'] = 611;
+          t['W'] = 833;
+          t['X'] = 611;
+          t['Y'] = 556;
+          t['Z'] = 556;
+          t['bracketleft'] = 389;
+          t['backslash'] = 278;
+          t['bracketright'] = 389;
+          t['asciicircum'] = 422;
+          t['underscore'] = 500;
+          t['quoteleft'] = 333;
+          t['a'] = 500;
+          t['b'] = 500;
+          t['c'] = 444;
+          t['d'] = 500;
+          t['e'] = 444;
+          t['f'] = 278;
+          t['g'] = 500;
+          t['h'] = 500;
+          t['i'] = 278;
+          t['j'] = 278;
+          t['k'] = 444;
+          t['l'] = 278;
+          t['m'] = 722;
+          t['n'] = 500;
+          t['o'] = 500;
+          t['p'] = 500;
+          t['q'] = 500;
+          t['r'] = 389;
+          t['s'] = 389;
+          t['t'] = 278;
+          t['u'] = 500;
+          t['v'] = 444;
+          t['w'] = 667;
+          t['x'] = 444;
+          t['y'] = 444;
+          t['z'] = 389;
+          t['braceleft'] = 400;
+          t['bar'] = 275;
+          t['braceright'] = 400;
+          t['asciitilde'] = 541;
+          t['exclamdown'] = 389;
+          t['cent'] = 500;
+          t['sterling'] = 500;
+          t['fraction'] = 167;
+          t['yen'] = 500;
+          t['florin'] = 500;
+          t['section'] = 500;
+          t['currency'] = 500;
+          t['quotesingle'] = 214;
+          t['quotedblleft'] = 556;
+          t['guillemotleft'] = 500;
+          t['guilsinglleft'] = 333;
+          t['guilsinglright'] = 333;
+          t['fi'] = 500;
+          t['fl'] = 500;
+          t['endash'] = 500;
+          t['dagger'] = 500;
+          t['daggerdbl'] = 500;
+          t['periodcentered'] = 250;
+          t['paragraph'] = 523;
+          t['bullet'] = 350;
+          t['quotesinglbase'] = 333;
+          t['quotedblbase'] = 556;
+          t['quotedblright'] = 556;
+          t['guillemotright'] = 500;
+          t['ellipsis'] = 889;
+          t['perthousand'] = 1000;
+          t['questiondown'] = 500;
+          t['grave'] = 333;
+          t['acute'] = 333;
+          t['circumflex'] = 333;
+          t['tilde'] = 333;
+          t['macron'] = 333;
+          t['breve'] = 333;
+          t['dotaccent'] = 333;
+          t['dieresis'] = 333;
+          t['ring'] = 333;
+          t['cedilla'] = 333;
+          t['hungarumlaut'] = 333;
+          t['ogonek'] = 333;
+          t['caron'] = 333;
+          t['emdash'] = 889;
+          t['AE'] = 889;
+          t['ordfeminine'] = 276;
+          t['Lslash'] = 556;
+          t['Oslash'] = 722;
+          t['OE'] = 944;
+          t['ordmasculine'] = 310;
+          t['ae'] = 667;
+          t['dotlessi'] = 278;
+          t['lslash'] = 278;
+          t['oslash'] = 500;
+          t['oe'] = 667;
+          t['germandbls'] = 500;
+          t['Idieresis'] = 333;
+          t['eacute'] = 444;
+          t['abreve'] = 500;
+          t['uhungarumlaut'] = 500;
+          t['ecaron'] = 444;
+          t['Ydieresis'] = 556;
+          t['divide'] = 675;
+          t['Yacute'] = 556;
+          t['Acircumflex'] = 611;
+          t['aacute'] = 500;
+          t['Ucircumflex'] = 722;
+          t['yacute'] = 444;
+          t['scommaaccent'] = 389;
+          t['ecircumflex'] = 444;
+          t['Uring'] = 722;
+          t['Udieresis'] = 722;
+          t['aogonek'] = 500;
+          t['Uacute'] = 722;
+          t['uogonek'] = 500;
+          t['Edieresis'] = 611;
+          t['Dcroat'] = 722;
+          t['commaaccent'] = 250;
+          t['copyright'] = 760;
+          t['Emacron'] = 611;
+          t['ccaron'] = 444;
+          t['aring'] = 500;
+          t['Ncommaaccent'] = 667;
+          t['lacute'] = 278;
+          t['agrave'] = 500;
+          t['Tcommaaccent'] = 556;
+          t['Cacute'] = 667;
+          t['atilde'] = 500;
+          t['Edotaccent'] = 611;
+          t['scaron'] = 389;
+          t['scedilla'] = 389;
+          t['iacute'] = 278;
+          t['lozenge'] = 471;
+          t['Rcaron'] = 611;
+          t['Gcommaaccent'] = 722;
+          t['ucircumflex'] = 500;
+          t['acircumflex'] = 500;
+          t['Amacron'] = 611;
+          t['rcaron'] = 389;
+          t['ccedilla'] = 444;
+          t['Zdotaccent'] = 556;
+          t['Thorn'] = 611;
+          t['Omacron'] = 722;
+          t['Racute'] = 611;
+          t['Sacute'] = 500;
+          t['dcaron'] = 544;
+          t['Umacron'] = 722;
+          t['uring'] = 500;
+          t['threesuperior'] = 300;
+          t['Ograve'] = 722;
+          t['Agrave'] = 611;
+          t['Abreve'] = 611;
+          t['multiply'] = 675;
+          t['uacute'] = 500;
+          t['Tcaron'] = 556;
+          t['partialdiff'] = 476;
+          t['ydieresis'] = 444;
+          t['Nacute'] = 667;
+          t['icircumflex'] = 278;
+          t['Ecircumflex'] = 611;
+          t['adieresis'] = 500;
+          t['edieresis'] = 444;
+          t['cacute'] = 444;
+          t['nacute'] = 500;
+          t['umacron'] = 500;
+          t['Ncaron'] = 667;
+          t['Iacute'] = 333;
+          t['plusminus'] = 675;
+          t['brokenbar'] = 275;
+          t['registered'] = 760;
+          t['Gbreve'] = 722;
+          t['Idotaccent'] = 333;
+          t['summation'] = 600;
+          t['Egrave'] = 611;
+          t['racute'] = 389;
+          t['omacron'] = 500;
+          t['Zacute'] = 556;
+          t['Zcaron'] = 556;
+          t['greaterequal'] = 549;
+          t['Eth'] = 722;
+          t['Ccedilla'] = 667;
+          t['lcommaaccent'] = 278;
+          t['tcaron'] = 300;
+          t['eogonek'] = 444;
+          t['Uogonek'] = 722;
+          t['Aacute'] = 611;
+          t['Adieresis'] = 611;
+          t['egrave'] = 444;
+          t['zacute'] = 389;
+          t['iogonek'] = 278;
+          t['Oacute'] = 722;
+          t['oacute'] = 500;
+          t['amacron'] = 500;
+          t['sacute'] = 389;
+          t['idieresis'] = 278;
+          t['Ocircumflex'] = 722;
+          t['Ugrave'] = 722;
+          t['Delta'] = 612;
+          t['thorn'] = 500;
+          t['twosuperior'] = 300;
+          t['Odieresis'] = 722;
+          t['mu'] = 500;
+          t['igrave'] = 278;
+          t['ohungarumlaut'] = 500;
+          t['Eogonek'] = 611;
+          t['dcroat'] = 500;
+          t['threequarters'] = 750;
+          t['Scedilla'] = 500;
+          t['lcaron'] = 300;
+          t['Kcommaaccent'] = 667;
+          t['Lacute'] = 556;
+          t['trademark'] = 980;
+          t['edotaccent'] = 444;
+          t['Igrave'] = 333;
+          t['Imacron'] = 333;
+          t['Lcaron'] = 611;
+          t['onehalf'] = 750;
+          t['lessequal'] = 549;
+          t['ocircumflex'] = 500;
+          t['ntilde'] = 500;
+          t['Uhungarumlaut'] = 722;
+          t['Eacute'] = 611;
+          t['emacron'] = 444;
+          t['gbreve'] = 500;
+          t['onequarter'] = 750;
+          t['Scaron'] = 500;
+          t['Scommaaccent'] = 500;
+          t['Ohungarumlaut'] = 722;
+          t['degree'] = 400;
+          t['ograve'] = 500;
+          t['Ccaron'] = 667;
+          t['ugrave'] = 500;
+          t['radical'] = 453;
+          t['Dcaron'] = 722;
+          t['rcommaaccent'] = 389;
+          t['Ntilde'] = 667;
+          t['otilde'] = 500;
+          t['Rcommaaccent'] = 611;
+          t['Lcommaaccent'] = 556;
+          t['Atilde'] = 611;
+          t['Aogonek'] = 611;
+          t['Aring'] = 611;
+          t['Otilde'] = 722;
+          t['zdotaccent'] = 389;
+          t['Ecaron'] = 611;
+          t['Iogonek'] = 333;
+          t['kcommaaccent'] = 444;
+          t['minus'] = 675;
+          t['Icircumflex'] = 333;
+          t['ncaron'] = 500;
+          t['tcommaaccent'] = 278;
+          t['logicalnot'] = 675;
+          t['odieresis'] = 500;
+          t['udieresis'] = 500;
+          t['notequal'] = 549;
+          t['gcommaaccent'] = 500;
+          t['eth'] = 500;
+          t['zcaron'] = 389;
+          t['ncommaaccent'] = 500;
+          t['onesuperior'] = 300;
+          t['imacron'] = 278;
+          t['Euro'] = 500;
+        });
+        t['ZapfDingbats'] = getLookupTableFactory(function (t) {
+          t['space'] = 278;
+          t['a1'] = 974;
+          t['a2'] = 961;
+          t['a202'] = 974;
+          t['a3'] = 980;
+          t['a4'] = 719;
+          t['a5'] = 789;
+          t['a119'] = 790;
+          t['a118'] = 791;
+          t['a117'] = 690;
+          t['a11'] = 960;
+          t['a12'] = 939;
+          t['a13'] = 549;
+          t['a14'] = 855;
+          t['a15'] = 911;
+          t['a16'] = 933;
+          t['a105'] = 911;
+          t['a17'] = 945;
+          t['a18'] = 974;
+          t['a19'] = 755;
+          t['a20'] = 846;
+          t['a21'] = 762;
+          t['a22'] = 761;
+          t['a23'] = 571;
+          t['a24'] = 677;
+          t['a25'] = 763;
+          t['a26'] = 760;
+          t['a27'] = 759;
+          t['a28'] = 754;
+          t['a6'] = 494;
+          t['a7'] = 552;
+          t['a8'] = 537;
+          t['a9'] = 577;
+          t['a10'] = 692;
+          t['a29'] = 786;
+          t['a30'] = 788;
+          t['a31'] = 788;
+          t['a32'] = 790;
+          t['a33'] = 793;
+          t['a34'] = 794;
+          t['a35'] = 816;
+          t['a36'] = 823;
+          t['a37'] = 789;
+          t['a38'] = 841;
+          t['a39'] = 823;
+          t['a40'] = 833;
+          t['a41'] = 816;
+          t['a42'] = 831;
+          t['a43'] = 923;
+          t['a44'] = 744;
+          t['a45'] = 723;
+          t['a46'] = 749;
+          t['a47'] = 790;
+          t['a48'] = 792;
+          t['a49'] = 695;
+          t['a50'] = 776;
+          t['a51'] = 768;
+          t['a52'] = 792;
+          t['a53'] = 759;
+          t['a54'] = 707;
+          t['a55'] = 708;
+          t['a56'] = 682;
+          t['a57'] = 701;
+          t['a58'] = 826;
+          t['a59'] = 815;
+          t['a60'] = 789;
+          t['a61'] = 789;
+          t['a62'] = 707;
+          t['a63'] = 687;
+          t['a64'] = 696;
+          t['a65'] = 689;
+          t['a66'] = 786;
+          t['a67'] = 787;
+          t['a68'] = 713;
+          t['a69'] = 791;
+          t['a70'] = 785;
+          t['a71'] = 791;
+          t['a72'] = 873;
+          t['a73'] = 761;
+          t['a74'] = 762;
+          t['a203'] = 762;
+          t['a75'] = 759;
+          t['a204'] = 759;
+          t['a76'] = 892;
+          t['a77'] = 892;
+          t['a78'] = 788;
+          t['a79'] = 784;
+          t['a81'] = 438;
+          t['a82'] = 138;
+          t['a83'] = 277;
+          t['a84'] = 415;
+          t['a97'] = 392;
+          t['a98'] = 392;
+          t['a99'] = 668;
+          t['a100'] = 668;
+          t['a89'] = 390;
+          t['a90'] = 390;
+          t['a93'] = 317;
+          t['a94'] = 317;
+          t['a91'] = 276;
+          t['a92'] = 276;
+          t['a205'] = 509;
+          t['a85'] = 509;
+          t['a206'] = 410;
+          t['a86'] = 410;
+          t['a87'] = 234;
+          t['a88'] = 234;
+          t['a95'] = 334;
+          t['a96'] = 334;
+          t['a101'] = 732;
+          t['a102'] = 544;
+          t['a103'] = 544;
+          t['a104'] = 910;
+          t['a106'] = 667;
+          t['a107'] = 760;
+          t['a108'] = 760;
+          t['a112'] = 776;
+          t['a111'] = 595;
+          t['a110'] = 694;
+          t['a109'] = 626;
+          t['a120'] = 788;
+          t['a121'] = 788;
+          t['a122'] = 788;
+          t['a123'] = 788;
+          t['a124'] = 788;
+          t['a125'] = 788;
+          t['a126'] = 788;
+          t['a127'] = 788;
+          t['a128'] = 788;
+          t['a129'] = 788;
+          t['a130'] = 788;
+          t['a131'] = 788;
+          t['a132'] = 788;
+          t['a133'] = 788;
+          t['a134'] = 788;
+          t['a135'] = 788;
+          t['a136'] = 788;
+          t['a137'] = 788;
+          t['a138'] = 788;
+          t['a139'] = 788;
+          t['a140'] = 788;
+          t['a141'] = 788;
+          t['a142'] = 788;
+          t['a143'] = 788;
+          t['a144'] = 788;
+          t['a145'] = 788;
+          t['a146'] = 788;
+          t['a147'] = 788;
+          t['a148'] = 788;
+          t['a149'] = 788;
+          t['a150'] = 788;
+          t['a151'] = 788;
+          t['a152'] = 788;
+          t['a153'] = 788;
+          t['a154'] = 788;
+          t['a155'] = 788;
+          t['a156'] = 788;
+          t['a157'] = 788;
+          t['a158'] = 788;
+          t['a159'] = 788;
+          t['a160'] = 894;
+          t['a161'] = 838;
+          t['a163'] = 1016;
+          t['a164'] = 458;
+          t['a196'] = 748;
+          t['a165'] = 924;
+          t['a192'] = 748;
+          t['a166'] = 918;
+          t['a167'] = 927;
+          t['a168'] = 928;
+          t['a169'] = 928;
+          t['a170'] = 834;
+          t['a171'] = 873;
+          t['a172'] = 828;
+          t['a173'] = 924;
+          t['a162'] = 924;
+          t['a174'] = 917;
+          t['a175'] = 930;
+          t['a176'] = 931;
+          t['a177'] = 463;
+          t['a178'] = 883;
+          t['a179'] = 836;
+          t['a193'] = 836;
+          t['a180'] = 867;
+          t['a199'] = 867;
+          t['a181'] = 696;
+          t['a200'] = 696;
+          t['a182'] = 874;
+          t['a201'] = 874;
+          t['a183'] = 760;
+          t['a184'] = 946;
+          t['a197'] = 771;
+          t['a185'] = 865;
+          t['a194'] = 771;
+          t['a198'] = 888;
+          t['a186'] = 967;
+          t['a195'] = 888;
+          t['a187'] = 831;
+          t['a188'] = 873;
+          t['a189'] = 927;
+          t['a190'] = 970;
+          t['a191'] = 918;
+        });
+      });
+      exports.getMetrics = getMetrics;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreMurmurHash3 = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var Uint32ArrayView = sharedUtil.Uint32ArrayView;
+      var MurmurHash3_64 = function MurmurHash3_64Closure(seed) {
+        // Workaround for missing math precision in JS.
+        var MASK_HIGH = 0xffff0000;
+        var MASK_LOW = 0xffff;
+        function MurmurHash3_64(seed) {
+          var SEED = 0xc3d2e1f0;
+          this.h1 = seed ? seed & 0xffffffff : SEED;
+          this.h2 = seed ? seed & 0xffffffff : SEED;
+        }
+        var alwaysUseUint32ArrayView = false;
+        MurmurHash3_64.prototype = {
+          update: function MurmurHash3_64_update(input) {
+            var useUint32ArrayView = alwaysUseUint32ArrayView;
+            var i;
+            if (typeof input === 'string') {
+              var data = new Uint8Array(input.length * 2);
+              var length = 0;
+              for (i = 0; i < input.length; i++) {
+                var code = input.charCodeAt(i);
+                if (code <= 0xff) {
+                  data[length++] = code;
+                } else {
+                  data[length++] = code >>> 8;
+                  data[length++] = code & 0xff;
+                }
+              }
+            } else if (input instanceof Uint8Array) {
+              data = input;
+              length = data.length;
+            } else if (typeof input === 'object' && 'length' in input) {
+              // processing regular arrays as well, e.g. for IE9
+              data = input;
+              length = data.length;
+              useUint32ArrayView = true;
+            } else {
+              throw new Error('Wrong data format in MurmurHash3_64_update. ' + 'Input must be a string or array.');
+            }
+            var blockCounts = length >> 2;
+            var tailLength = length - blockCounts * 4;
+            // we don't care about endianness here
+            var dataUint32 = useUint32ArrayView ? new Uint32ArrayView(data, blockCounts) : new Uint32Array(data.buffer, 0, blockCounts);
+            var k1 = 0;
+            var k2 = 0;
+            var h1 = this.h1;
+            var h2 = this.h2;
+            var C1 = 0xcc9e2d51;
+            var C2 = 0x1b873593;
+            var C1_LOW = C1 & MASK_LOW;
+            var C2_LOW = C2 & MASK_LOW;
+            for (i = 0; i < blockCounts; i++) {
+              if (i & 1) {
+                k1 = dataUint32[i];
+                k1 = k1 * C1 & MASK_HIGH | k1 * C1_LOW & MASK_LOW;
+                k1 = k1 << 15 | k1 >>> 17;
+                k1 = k1 * C2 & MASK_HIGH | k1 * C2_LOW & MASK_LOW;
+                h1 ^= k1;
+                h1 = h1 << 13 | h1 >>> 19;
+                h1 = h1 * 5 + 0xe6546b64;
+              } else {
+                k2 = dataUint32[i];
+                k2 = k2 * C1 & MASK_HIGH | k2 * C1_LOW & MASK_LOW;
+                k2 = k2 << 15 | k2 >>> 17;
+                k2 = k2 * C2 & MASK_HIGH | k2 * C2_LOW & MASK_LOW;
+                h2 ^= k2;
+                h2 = h2 << 13 | h2 >>> 19;
+                h2 = h2 * 5 + 0xe6546b64;
+              }
+            }
+            k1 = 0;
+            switch (tailLength) {
+            case 3:
+              k1 ^= data[blockCounts * 4 + 2] << 16;
+            case 2:
+              k1 ^= data[blockCounts * 4 + 1] << 8;
+            case 1:
+              k1 ^= data[blockCounts * 4];
+              k1 = k1 * C1 & MASK_HIGH | k1 * C1_LOW & MASK_LOW;
+              k1 = k1 << 15 | k1 >>> 17;
+              k1 = k1 * C2 & MASK_HIGH | k1 * C2_LOW & MASK_LOW;
+              if (blockCounts & 1) {
+                h1 ^= k1;
+              } else {
+                h2 ^= k1;
+              }
+            }
+            this.h1 = h1;
+            this.h2 = h2;
+            return this;
+          },
+          hexdigest: function MurmurHash3_64_hexdigest() {
+            var h1 = this.h1;
+            var h2 = this.h2;
+            h1 ^= h2 >>> 1;
+            h1 = h1 * 0xed558ccd & MASK_HIGH | h1 * 0x8ccd & MASK_LOW;
+            h2 = h2 * 0xff51afd7 & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 0xafd7ed55 & MASK_HIGH) >>> 16;
+            h1 ^= h2 >>> 1;
+            h1 = h1 * 0x1a85ec53 & MASK_HIGH | h1 * 0xec53 & MASK_LOW;
+            h2 = h2 * 0xc4ceb9fe & MASK_HIGH | ((h2 << 16 | h1 >>> 16) * 0xb9fe1a85 & MASK_HIGH) >>> 16;
+            h1 ^= h2 >>> 1;
+            for (var i = 0, arr = [
+                  h1,
+                  h2
+                ], str = ''; i < arr.length; i++) {
+              var hex = (arr[i] >>> 0).toString(16);
+              while (hex.length < 8) {
+                hex = '0' + hex;
+              }
+              str += hex;
+            }
+            return str;
+          }
+        };
+        return MurmurHash3_64;
+      }();
+      exports.MurmurHash3_64 = MurmurHash3_64;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCorePrimitives = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var isArray = sharedUtil.isArray;
+      var Name = function NameClosure() {
+        function Name(name) {
+          this.name = name;
+        }
+        Name.prototype = {};
+        var nameCache = Object.create(null);
+        Name.get = function Name_get(name) {
+          var nameValue = nameCache[name];
+          return nameValue ? nameValue : nameCache[name] = new Name(name);
+        };
+        return Name;
+      }();
+      var Cmd = function CmdClosure() {
+        function Cmd(cmd) {
+          this.cmd = cmd;
+        }
+        Cmd.prototype = {};
+        var cmdCache = Object.create(null);
+        Cmd.get = function Cmd_get(cmd) {
+          var cmdValue = cmdCache[cmd];
+          return cmdValue ? cmdValue : cmdCache[cmd] = new Cmd(cmd);
+        };
+        return Cmd;
+      }();
+      var Dict = function DictClosure() {
+        var nonSerializable = function nonSerializableClosure() {
+          return nonSerializable;
+        };
+        // creating closure on some variable
+        // xref is optional
+        function Dict(xref) {
+          // Map should only be used internally, use functions below to access.
+          this.map = Object.create(null);
+          this.xref = xref;
+          this.objId = null;
+          this.suppressEncryption = false;
+          this.__nonSerializable__ = nonSerializable;
+        }
+        // disable cloning of the Dict
+        Dict.prototype = {
+          assignXref: function Dict_assignXref(newXref) {
+            this.xref = newXref;
+          },
+          // automatically dereferences Ref objects
+          get: function Dict_get(key1, key2, key3) {
+            var value;
+            var xref = this.xref, suppressEncryption = this.suppressEncryption;
+            if (typeof (value = this.map[key1]) !== 'undefined' || key1 in this.map || typeof key2 === 'undefined') {
+              return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
+            }
+            if (typeof (value = this.map[key2]) !== 'undefined' || key2 in this.map || typeof key3 === 'undefined') {
+              return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
+            }
+            value = this.map[key3] || null;
+            return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
+          },
+          // Same as get(), but returns a promise and uses fetchIfRefAsync().
+          getAsync: function Dict_getAsync(key1, key2, key3) {
+            var value;
+            var xref = this.xref, suppressEncryption = this.suppressEncryption;
+            if (typeof (value = this.map[key1]) !== 'undefined' || key1 in this.map || typeof key2 === 'undefined') {
+              if (xref) {
+                return xref.fetchIfRefAsync(value, suppressEncryption);
+              }
+              return Promise.resolve(value);
+            }
+            if (typeof (value = this.map[key2]) !== 'undefined' || key2 in this.map || typeof key3 === 'undefined') {
+              if (xref) {
+                return xref.fetchIfRefAsync(value, suppressEncryption);
+              }
+              return Promise.resolve(value);
+            }
+            value = this.map[key3] || null;
+            if (xref) {
+              return xref.fetchIfRefAsync(value, suppressEncryption);
+            }
+            return Promise.resolve(value);
+          },
+          // Same as get(), but dereferences all elements if the result is an Array.
+          getArray: function Dict_getArray(key1, key2, key3) {
+            var value = this.get(key1, key2, key3);
+            var xref = this.xref, suppressEncryption = this.suppressEncryption;
+            if (!isArray(value) || !xref) {
+              return value;
+            }
+            value = value.slice();
+            // Ensure that we don't modify the Dict data.
+            for (var i = 0, ii = value.length; i < ii; i++) {
+              if (!isRef(value[i])) {
+                continue;
+              }
+              value[i] = xref.fetch(value[i], suppressEncryption);
+            }
+            return value;
+          },
+          // no dereferencing
+          getRaw: function Dict_getRaw(key) {
+            return this.map[key];
+          },
+          getKeys: function Dict_getKeys() {
+            return Object.keys(this.map);
+          },
+          set: function Dict_set(key, value) {
+            this.map[key] = value;
+          },
+          has: function Dict_has(key) {
+            return key in this.map;
+          },
+          forEach: function Dict_forEach(callback) {
+            for (var key in this.map) {
+              callback(key, this.get(key));
+            }
+          }
+        };
+        Dict.empty = new Dict(null);
+        Dict.merge = function Dict_merge(xref, dictArray) {
+          var mergedDict = new Dict(xref);
+          for (var i = 0, ii = dictArray.length; i < ii; i++) {
+            var dict = dictArray[i];
+            if (!isDict(dict)) {
+              continue;
+            }
+            for (var keyName in dict.map) {
+              if (mergedDict.map[keyName]) {
+                continue;
+              }
+              mergedDict.map[keyName] = dict.map[keyName];
+            }
+          }
+          return mergedDict;
+        };
+        return Dict;
+      }();
+      var Ref = function RefClosure() {
+        function Ref(num, gen) {
+          this.num = num;
+          this.gen = gen;
+        }
+        Ref.prototype = {
+          toString: function Ref_toString() {
+            // This function is hot, so we make the string as compact as possible.
+            // |this.gen| is almost always zero, so we treat that case specially.
+            var str = this.num + 'R';
+            if (this.gen !== 0) {
+              str += this.gen;
+            }
+            return str;
+          }
+        };
+        return Ref;
+      }();
+      // The reference is identified by number and generation.
+      // This structure stores only one instance of the reference.
+      var RefSet = function RefSetClosure() {
+        function RefSet() {
+          this.dict = Object.create(null);
+        }
+        RefSet.prototype = {
+          has: function RefSet_has(ref) {
+            return ref.toString() in this.dict;
+          },
+          put: function RefSet_put(ref) {
+            this.dict[ref.toString()] = true;
+          },
+          remove: function RefSet_remove(ref) {
+            delete this.dict[ref.toString()];
+          }
+        };
+        return RefSet;
+      }();
+      var RefSetCache = function RefSetCacheClosure() {
+        function RefSetCache() {
+          this.dict = Object.create(null);
+        }
+        RefSetCache.prototype = {
+          get: function RefSetCache_get(ref) {
+            return this.dict[ref.toString()];
+          },
+          has: function RefSetCache_has(ref) {
+            return ref.toString() in this.dict;
+          },
+          put: function RefSetCache_put(ref, obj) {
+            this.dict[ref.toString()] = obj;
+          },
+          putAlias: function RefSetCache_putAlias(ref, aliasRef) {
+            this.dict[ref.toString()] = this.get(aliasRef);
+          },
+          forEach: function RefSetCache_forEach(fn, thisArg) {
+            for (var i in this.dict) {
+              fn.call(thisArg, this.dict[i]);
+            }
+          },
+          clear: function RefSetCache_clear() {
+            this.dict = Object.create(null);
+          }
+        };
+        return RefSetCache;
+      }();
+      function isName(v, name) {
+        return v instanceof Name && (name === undefined || v.name === name);
+      }
+      function isCmd(v, cmd) {
+        return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
+      }
+      function isDict(v, type) {
+        return v instanceof Dict && (type === undefined || isName(v.get('Type'), type));
+      }
+      function isRef(v) {
+        return v instanceof Ref;
+      }
+      function isRefsEqual(v1, v2) {
+        return v1.num === v2.num && v1.gen === v2.gen;
+      }
+      function isStream(v) {
+        return typeof v === 'object' && v !== null && v.getBytes !== undefined;
+      }
+      exports.Cmd = Cmd;
+      exports.Dict = Dict;
+      exports.Name = Name;
+      exports.Ref = Ref;
+      exports.RefSet = RefSet;
+      exports.RefSetCache = RefSetCache;
+      exports.isCmd = isCmd;
+      exports.isDict = isDict;
+      exports.isName = isName;
+      exports.isRef = isRef;
+      exports.isRefsEqual = isRefsEqual;
+      exports.isStream = isStream;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreStandardFonts = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var getLookupTableFactory = sharedUtil.getLookupTableFactory;
+      /**
+       * Hold a map of decoded fonts and of the standard fourteen Type1
+       * fonts and their acronyms.
+       */
+      var getStdFontMap = getLookupTableFactory(function (t) {
+        t['ArialNarrow'] = 'Helvetica';
+        t['ArialNarrow-Bold'] = 'Helvetica-Bold';
+        t['ArialNarrow-BoldItalic'] = 'Helvetica-BoldOblique';
+        t['ArialNarrow-Italic'] = 'Helvetica-Oblique';
+        t['ArialBlack'] = 'Helvetica';
+        t['ArialBlack-Bold'] = 'Helvetica-Bold';
+        t['ArialBlack-BoldItalic'] = 'Helvetica-BoldOblique';
+        t['ArialBlack-Italic'] = 'Helvetica-Oblique';
+        t['Arial'] = 'Helvetica';
+        t['Arial-Bold'] = 'Helvetica-Bold';
+        t['Arial-BoldItalic'] = 'Helvetica-BoldOblique';
+        t['Arial-Italic'] = 'Helvetica-Oblique';
+        t['Arial-BoldItalicMT'] = 'Helvetica-BoldOblique';
+        t['Arial-BoldMT'] = 'Helvetica-Bold';
+        t['Arial-ItalicMT'] = 'Helvetica-Oblique';
+        t['ArialMT'] = 'Helvetica';
+        t['Courier-Bold'] = 'Courier-Bold';
+        t['Courier-BoldItalic'] = 'Courier-BoldOblique';
+        t['Courier-Italic'] = 'Courier-Oblique';
+        t['CourierNew'] = 'Courier';
+        t['CourierNew-Bold'] = 'Courier-Bold';
+        t['CourierNew-BoldItalic'] = 'Courier-BoldOblique';
+        t['CourierNew-Italic'] = 'Courier-Oblique';
+        t['CourierNewPS-BoldItalicMT'] = 'Courier-BoldOblique';
+        t['CourierNewPS-BoldMT'] = 'Courier-Bold';
+        t['CourierNewPS-ItalicMT'] = 'Courier-Oblique';
+        t['CourierNewPSMT'] = 'Courier';
+        t['Helvetica'] = 'Helvetica';
+        t['Helvetica-Bold'] = 'Helvetica-Bold';
+        t['Helvetica-BoldItalic'] = 'Helvetica-BoldOblique';
+        t['Helvetica-BoldOblique'] = 'Helvetica-BoldOblique';
+        t['Helvetica-Italic'] = 'Helvetica-Oblique';
+        t['Helvetica-Oblique'] = 'Helvetica-Oblique';
+        t['Symbol-Bold'] = 'Symbol';
+        t['Symbol-BoldItalic'] = 'Symbol';
+        t['Symbol-Italic'] = 'Symbol';
+        t['TimesNewRoman'] = 'Times-Roman';
+        t['TimesNewRoman-Bold'] = 'Times-Bold';
+        t['TimesNewRoman-BoldItalic'] = 'Times-BoldItalic';
+        t['TimesNewRoman-Italic'] = 'Times-Italic';
+        t['TimesNewRomanPS'] = 'Times-Roman';
+        t['TimesNewRomanPS-Bold'] = 'Times-Bold';
+        t['TimesNewRomanPS-BoldItalic'] = 'Times-BoldItalic';
+        t['TimesNewRomanPS-BoldItalicMT'] = 'Times-BoldItalic';
+        t['TimesNewRomanPS-BoldMT'] = 'Times-Bold';
+        t['TimesNewRomanPS-Italic'] = 'Times-Italic';
+        t['TimesNewRomanPS-ItalicMT'] = 'Times-Italic';
+        t['TimesNewRomanPSMT'] = 'Times-Roman';
+        t['TimesNewRomanPSMT-Bold'] = 'Times-Bold';
+        t['TimesNewRomanPSMT-BoldItalic'] = 'Times-BoldItalic';
+        t['TimesNewRomanPSMT-Italic'] = 'Times-Italic';
+      });
+      /**
+       * Holds the map of the non-standard fonts that might be included as
+       * a standard fonts without glyph data.
+       */
+      var getNonStdFontMap = getLookupTableFactory(function (t) {
+        t['CenturyGothic'] = 'Helvetica';
+        t['CenturyGothic-Bold'] = 'Helvetica-Bold';
+        t['CenturyGothic-BoldItalic'] = 'Helvetica-BoldOblique';
+        t['CenturyGothic-Italic'] = 'Helvetica-Oblique';
+        t['ComicSansMS'] = 'Comic Sans MS';
+        t['ComicSansMS-Bold'] = 'Comic Sans MS-Bold';
+        t['ComicSansMS-BoldItalic'] = 'Comic Sans MS-BoldItalic';
+        t['ComicSansMS-Italic'] = 'Comic Sans MS-Italic';
+        t['LucidaConsole'] = 'Courier';
+        t['LucidaConsole-Bold'] = 'Courier-Bold';
+        t['LucidaConsole-BoldItalic'] = 'Courier-BoldOblique';
+        t['LucidaConsole-Italic'] = 'Courier-Oblique';
+        t['MS-Gothic'] = 'MS Gothic';
+        t['MS-Gothic-Bold'] = 'MS Gothic-Bold';
+        t['MS-Gothic-BoldItalic'] = 'MS Gothic-BoldItalic';
+        t['MS-Gothic-Italic'] = 'MS Gothic-Italic';
+        t['MS-Mincho'] = 'MS Mincho';
+        t['MS-Mincho-Bold'] = 'MS Mincho-Bold';
+        t['MS-Mincho-BoldItalic'] = 'MS Mincho-BoldItalic';
+        t['MS-Mincho-Italic'] = 'MS Mincho-Italic';
+        t['MS-PGothic'] = 'MS PGothic';
+        t['MS-PGothic-Bold'] = 'MS PGothic-Bold';
+        t['MS-PGothic-BoldItalic'] = 'MS PGothic-BoldItalic';
+        t['MS-PGothic-Italic'] = 'MS PGothic-Italic';
+        t['MS-PMincho'] = 'MS PMincho';
+        t['MS-PMincho-Bold'] = 'MS PMincho-Bold';
+        t['MS-PMincho-BoldItalic'] = 'MS PMincho-BoldItalic';
+        t['MS-PMincho-Italic'] = 'MS PMincho-Italic';
+        t['Wingdings'] = 'ZapfDingbats';
+      });
+      var getSerifFonts = getLookupTableFactory(function (t) {
+        t['Adobe Jenson'] = true;
+        t['Adobe Text'] = true;
+        t['Albertus'] = true;
+        t['Aldus'] = true;
+        t['Alexandria'] = true;
+        t['Algerian'] = true;
+        t['American Typewriter'] = true;
+        t['Antiqua'] = true;
+        t['Apex'] = true;
+        t['Arno'] = true;
+        t['Aster'] = true;
+        t['Aurora'] = true;
+        t['Baskerville'] = true;
+        t['Bell'] = true;
+        t['Bembo'] = true;
+        t['Bembo Schoolbook'] = true;
+        t['Benguiat'] = true;
+        t['Berkeley Old Style'] = true;
+        t['Bernhard Modern'] = true;
+        t['Berthold City'] = true;
+        t['Bodoni'] = true;
+        t['Bauer Bodoni'] = true;
+        t['Book Antiqua'] = true;
+        t['Bookman'] = true;
+        t['Bordeaux Roman'] = true;
+        t['Californian FB'] = true;
+        t['Calisto'] = true;
+        t['Calvert'] = true;
+        t['Capitals'] = true;
+        t['Cambria'] = true;
+        t['Cartier'] = true;
+        t['Caslon'] = true;
+        t['Catull'] = true;
+        t['Centaur'] = true;
+        t['Century Old Style'] = true;
+        t['Century Schoolbook'] = true;
+        t['Chaparral'] = true;
+        t['Charis SIL'] = true;
+        t['Cheltenham'] = true;
+        t['Cholla Slab'] = true;
+        t['Clarendon'] = true;
+        t['Clearface'] = true;
+        t['Cochin'] = true;
+        t['Colonna'] = true;
+        t['Computer Modern'] = true;
+        t['Concrete Roman'] = true;
+        t['Constantia'] = true;
+        t['Cooper Black'] = true;
+        t['Corona'] = true;
+        t['Ecotype'] = true;
+        t['Egyptienne'] = true;
+        t['Elephant'] = true;
+        t['Excelsior'] = true;
+        t['Fairfield'] = true;
+        t['FF Scala'] = true;
+        t['Folkard'] = true;
+        t['Footlight'] = true;
+        t['FreeSerif'] = true;
+        t['Friz Quadrata'] = true;
+        t['Garamond'] = true;
+        t['Gentium'] = true;
+        t['Georgia'] = true;
+        t['Gloucester'] = true;
+        t['Goudy Old Style'] = true;
+        t['Goudy Schoolbook'] = true;
+        t['Goudy Pro Font'] = true;
+        t['Granjon'] = true;
+        t['Guardian Egyptian'] = true;
+        t['Heather'] = true;
+        t['Hercules'] = true;
+        t['High Tower Text'] = true;
+        t['Hiroshige'] = true;
+        t['Hoefler Text'] = true;
+        t['Humana Serif'] = true;
+        t['Imprint'] = true;
+        t['Ionic No. 5'] = true;
+        t['Janson'] = true;
+        t['Joanna'] = true;
+        t['Korinna'] = true;
+        t['Lexicon'] = true;
+        t['Liberation Serif'] = true;
+        t['Linux Libertine'] = true;
+        t['Literaturnaya'] = true;
+        t['Lucida'] = true;
+        t['Lucida Bright'] = true;
+        t['Melior'] = true;
+        t['Memphis'] = true;
+        t['Miller'] = true;
+        t['Minion'] = true;
+        t['Modern'] = true;
+        t['Mona Lisa'] = true;
+        t['Mrs Eaves'] = true;
+        t['MS Serif'] = true;
+        t['Museo Slab'] = true;
+        t['New York'] = true;
+        t['Nimbus Roman'] = true;
+        t['NPS Rawlinson Roadway'] = true;
+        t['Palatino'] = true;
+        t['Perpetua'] = true;
+        t['Plantin'] = true;
+        t['Plantin Schoolbook'] = true;
+        t['Playbill'] = true;
+        t['Poor Richard'] = true;
+        t['Rawlinson Roadway'] = true;
+        t['Renault'] = true;
+        t['Requiem'] = true;
+        t['Rockwell'] = true;
+        t['Roman'] = true;
+        t['Rotis Serif'] = true;
+        t['Sabon'] = true;
+        t['Scala'] = true;
+        t['Seagull'] = true;
+        t['Sistina'] = true;
+        t['Souvenir'] = true;
+        t['STIX'] = true;
+        t['Stone Informal'] = true;
+        t['Stone Serif'] = true;
+        t['Sylfaen'] = true;
+        t['Times'] = true;
+        t['Trajan'] = true;
+        t['Trinité'] = true;
+        t['Trump Mediaeval'] = true;
+        t['Utopia'] = true;
+        t['Vale Type'] = true;
+        t['Bitstream Vera'] = true;
+        t['Vera Serif'] = true;
+        t['Versailles'] = true;
+        t['Wanted'] = true;
+        t['Weiss'] = true;
+        t['Wide Latin'] = true;
+        t['Windsor'] = true;
+        t['XITS'] = true;
+      });
+      var getSymbolsFonts = getLookupTableFactory(function (t) {
+        t['Dingbats'] = true;
+        t['Symbol'] = true;
+        t['ZapfDingbats'] = true;
+      });
+      // Glyph map for well-known standard fonts. Sometimes Ghostscript uses CID
+      // fonts, but does not embed the CID to GID mapping. The mapping is incomplete
+      // for all glyphs, but common for some set of the standard fonts.
+      var getGlyphMapForStandardFonts = getLookupTableFactory(function (t) {
+        t[2] = 10;
+        t[3] = 32;
+        t[4] = 33;
+        t[5] = 34;
+        t[6] = 35;
+        t[7] = 36;
+        t[8] = 37;
+        t[9] = 38;
+        t[10] = 39;
+        t[11] = 40;
+        t[12] = 41;
+        t[13] = 42;
+        t[14] = 43;
+        t[15] = 44;
+        t[16] = 45;
+        t[17] = 46;
+        t[18] = 47;
+        t[19] = 48;
+        t[20] = 49;
+        t[21] = 50;
+        t[22] = 51;
+        t[23] = 52;
+        t[24] = 53;
+        t[25] = 54;
+        t[26] = 55;
+        t[27] = 56;
+        t[28] = 57;
+        t[29] = 58;
+        t[30] = 894;
+        t[31] = 60;
+        t[32] = 61;
+        t[33] = 62;
+        t[34] = 63;
+        t[35] = 64;
+        t[36] = 65;
+        t[37] = 66;
+        t[38] = 67;
+        t[39] = 68;
+        t[40] = 69;
+        t[41] = 70;
+        t[42] = 71;
+        t[43] = 72;
+        t[44] = 73;
+        t[45] = 74;
+        t[46] = 75;
+        t[47] = 76;
+        t[48] = 77;
+        t[49] = 78;
+        t[50] = 79;
+        t[51] = 80;
+        t[52] = 81;
+        t[53] = 82;
+        t[54] = 83;
+        t[55] = 84;
+        t[56] = 85;
+        t[57] = 86;
+        t[58] = 87;
+        t[59] = 88;
+        t[60] = 89;
+        t[61] = 90;
+        t[62] = 91;
+        t[63] = 92;
+        t[64] = 93;
+        t[65] = 94;
+        t[66] = 95;
+        t[67] = 96;
+        t[68] = 97;
+        t[69] = 98;
+        t[70] = 99;
+        t[71] = 100;
+        t[72] = 101;
+        t[73] = 102;
+        t[74] = 103;
+        t[75] = 104;
+        t[76] = 105;
+        t[77] = 106;
+        t[78] = 107;
+        t[79] = 108;
+        t[80] = 109;
+        t[81] = 110;
+        t[82] = 111;
+        t[83] = 112;
+        t[84] = 113;
+        t[85] = 114;
+        t[86] = 115;
+        t[87] = 116;
+        t[88] = 117;
+        t[89] = 118;
+        t[90] = 119;
+        t[91] = 120;
+        t[92] = 121;
+        t[93] = 122;
+        t[94] = 123;
+        t[95] = 124;
+        t[96] = 125;
+        t[97] = 126;
+        t[98] = 196;
+        t[99] = 197;
+        t[100] = 199;
+        t[101] = 201;
+        t[102] = 209;
+        t[103] = 214;
+        t[104] = 220;
+        t[105] = 225;
+        t[106] = 224;
+        t[107] = 226;
+        t[108] = 228;
+        t[109] = 227;
+        t[110] = 229;
+        t[111] = 231;
+        t[112] = 233;
+        t[113] = 232;
+        t[114] = 234;
+        t[115] = 235;
+        t[116] = 237;
+        t[117] = 236;
+        t[118] = 238;
+        t[119] = 239;
+        t[120] = 241;
+        t[121] = 243;
+        t[122] = 242;
+        t[123] = 244;
+        t[124] = 246;
+        t[125] = 245;
+        t[126] = 250;
+        t[127] = 249;
+        t[128] = 251;
+        t[129] = 252;
+        t[130] = 8224;
+        t[131] = 176;
+        t[132] = 162;
+        t[133] = 163;
+        t[134] = 167;
+        t[135] = 8226;
+        t[136] = 182;
+        t[137] = 223;
+        t[138] = 174;
+        t[139] = 169;
+        t[140] = 8482;
+        t[141] = 180;
+        t[142] = 168;
+        t[143] = 8800;
+        t[144] = 198;
+        t[145] = 216;
+        t[146] = 8734;
+        t[147] = 177;
+        t[148] = 8804;
+        t[149] = 8805;
+        t[150] = 165;
+        t[151] = 181;
+        t[152] = 8706;
+        t[153] = 8721;
+        t[154] = 8719;
+        t[156] = 8747;
+        t[157] = 170;
+        t[158] = 186;
+        t[159] = 8486;
+        t[160] = 230;
+        t[161] = 248;
+        t[162] = 191;
+        t[163] = 161;
+        t[164] = 172;
+        t[165] = 8730;
+        t[166] = 402;
+        t[167] = 8776;
+        t[168] = 8710;
+        t[169] = 171;
+        t[170] = 187;
+        t[171] = 8230;
+        t[210] = 218;
+        t[223] = 711;
+        t[224] = 321;
+        t[225] = 322;
+        t[227] = 353;
+        t[229] = 382;
+        t[234] = 253;
+        t[252] = 263;
+        t[253] = 268;
+        t[254] = 269;
+        t[258] = 258;
+        t[260] = 260;
+        t[261] = 261;
+        t[265] = 280;
+        t[266] = 281;
+        t[268] = 283;
+        t[269] = 313;
+        t[275] = 323;
+        t[276] = 324;
+        t[278] = 328;
+        t[284] = 345;
+        t[285] = 346;
+        t[286] = 347;
+        t[292] = 367;
+        t[295] = 377;
+        t[296] = 378;
+        t[298] = 380;
+        t[305] = 963;
+        t[306] = 964;
+        t[307] = 966;
+        t[308] = 8215;
+        t[309] = 8252;
+        t[310] = 8319;
+        t[311] = 8359;
+        t[312] = 8592;
+        t[313] = 8593;
+        t[337] = 9552;
+        t[493] = 1039;
+        t[494] = 1040;
+        t[705] = 1524;
+        t[706] = 8362;
+        t[710] = 64288;
+        t[711] = 64298;
+        t[759] = 1617;
+        t[761] = 1776;
+        t[763] = 1778;
+        t[775] = 1652;
+        t[777] = 1764;
+        t[778] = 1780;
+        t[779] = 1781;
+        t[780] = 1782;
+        t[782] = 771;
+        t[783] = 64726;
+        t[786] = 8363;
+        t[788] = 8532;
+        t[790] = 768;
+        t[791] = 769;
+        t[792] = 768;
+        t[795] = 803;
+        t[797] = 64336;
+        t[798] = 64337;
+        t[799] = 64342;
+        t[800] = 64343;
+        t[801] = 64344;
+        t[802] = 64345;
+        t[803] = 64362;
+        t[804] = 64363;
+        t[805] = 64364;
+        t[2424] = 7821;
+        t[2425] = 7822;
+        t[2426] = 7823;
+        t[2427] = 7824;
+        t[2428] = 7825;
+        t[2429] = 7826;
+        t[2430] = 7827;
+        t[2433] = 7682;
+        t[2678] = 8045;
+        t[2679] = 8046;
+        t[2830] = 1552;
+        t[2838] = 686;
+        t[2840] = 751;
+        t[2842] = 753;
+        t[2843] = 754;
+        t[2844] = 755;
+        t[2846] = 757;
+        t[2856] = 767;
+        t[2857] = 848;
+        t[2858] = 849;
+        t[2862] = 853;
+        t[2863] = 854;
+        t[2864] = 855;
+        t[2865] = 861;
+        t[2866] = 862;
+        t[2906] = 7460;
+        t[2908] = 7462;
+        t[2909] = 7463;
+        t[2910] = 7464;
+        t[2912] = 7466;
+        t[2913] = 7467;
+        t[2914] = 7468;
+        t[2916] = 7470;
+        t[2917] = 7471;
+        t[2918] = 7472;
+        t[2920] = 7474;
+        t[2921] = 7475;
+        t[2922] = 7476;
+        t[2924] = 7478;
+        t[2925] = 7479;
+        t[2926] = 7480;
+        t[2928] = 7482;
+        t[2929] = 7483;
+        t[2930] = 7484;
+        t[2932] = 7486;
+        t[2933] = 7487;
+        t[2934] = 7488;
+        t[2936] = 7490;
+        t[2937] = 7491;
+        t[2938] = 7492;
+        t[2940] = 7494;
+        t[2941] = 7495;
+        t[2942] = 7496;
+        t[2944] = 7498;
+        t[2946] = 7500;
+        t[2948] = 7502;
+        t[2950] = 7504;
+        t[2951] = 7505;
+        t[2952] = 7506;
+        t[2954] = 7508;
+        t[2955] = 7509;
+        t[2956] = 7510;
+        t[2958] = 7512;
+        t[2959] = 7513;
+        t[2960] = 7514;
+        t[2962] = 7516;
+        t[2963] = 7517;
+        t[2964] = 7518;
+        t[2966] = 7520;
+        t[2967] = 7521;
+        t[2968] = 7522;
+        t[2970] = 7524;
+        t[2971] = 7525;
+        t[2972] = 7526;
+        t[2974] = 7528;
+        t[2975] = 7529;
+        t[2976] = 7530;
+        t[2978] = 1537;
+        t[2979] = 1538;
+        t[2980] = 1539;
+        t[2982] = 1549;
+        t[2983] = 1551;
+        t[2984] = 1552;
+        t[2986] = 1554;
+        t[2987] = 1555;
+        t[2988] = 1556;
+        t[2990] = 1623;
+        t[2991] = 1624;
+        t[2995] = 1775;
+        t[2999] = 1791;
+        t[3002] = 64290;
+        t[3003] = 64291;
+        t[3004] = 64292;
+        t[3006] = 64294;
+        t[3007] = 64295;
+        t[3008] = 64296;
+        t[3011] = 1900;
+        t[3014] = 8223;
+        t[3015] = 8244;
+        t[3017] = 7532;
+        t[3018] = 7533;
+        t[3019] = 7534;
+        t[3075] = 7590;
+        t[3076] = 7591;
+        t[3079] = 7594;
+        t[3080] = 7595;
+        t[3083] = 7598;
+        t[3084] = 7599;
+        t[3087] = 7602;
+        t[3088] = 7603;
+        t[3091] = 7606;
+        t[3092] = 7607;
+        t[3095] = 7610;
+        t[3096] = 7611;
+        t[3099] = 7614;
+        t[3100] = 7615;
+        t[3103] = 7618;
+        t[3104] = 7619;
+        t[3107] = 8337;
+        t[3108] = 8338;
+        t[3116] = 1884;
+        t[3119] = 1885;
+        t[3120] = 1885;
+        t[3123] = 1886;
+        t[3124] = 1886;
+        t[3127] = 1887;
+        t[3128] = 1887;
+        t[3131] = 1888;
+        t[3132] = 1888;
+        t[3135] = 1889;
+        t[3136] = 1889;
+        t[3139] = 1890;
+        t[3140] = 1890;
+        t[3143] = 1891;
+        t[3144] = 1891;
+        t[3147] = 1892;
+        t[3148] = 1892;
+        t[3153] = 580;
+        t[3154] = 581;
+        t[3157] = 584;
+        t[3158] = 585;
+        t[3161] = 588;
+        t[3162] = 589;
+        t[3165] = 891;
+        t[3166] = 892;
+        t[3169] = 1274;
+        t[3170] = 1275;
+        t[3173] = 1278;
+        t[3174] = 1279;
+        t[3181] = 7622;
+        t[3182] = 7623;
+        t[3282] = 11799;
+        t[3316] = 578;
+        t[3379] = 42785;
+        t[3393] = 1159;
+        t[3416] = 8377;
+      });
+      // The glyph map for ArialBlack differs slightly from the glyph map used for
+      // other well-known standard fonts. Hence we use this (incomplete) CID to GID
+      // mapping to adjust the glyph map for non-embedded ArialBlack fonts.
+      var getSupplementalGlyphMapForArialBlack = getLookupTableFactory(function (t) {
+        t[227] = 322;
+        t[264] = 261;
+        t[291] = 346;
+      });
+      exports.getStdFontMap = getStdFontMap;
+      exports.getNonStdFontMap = getNonStdFontMap;
+      exports.getSerifFonts = getSerifFonts;
+      exports.getSymbolsFonts = getSymbolsFonts;
+      exports.getGlyphMapForStandardFonts = getGlyphMapForStandardFonts;
+      exports.getSupplementalGlyphMapForArialBlack = getSupplementalGlyphMapForArialBlack;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreUnicode = {}, root.pdfjsSharedUtil);
+    }(this, function (exports, sharedUtil) {
+      var getLookupTableFactory = sharedUtil.getLookupTableFactory;
+      // Some characters, e.g. copyrightserif, are mapped to the private use area
+      // and might not be displayed using standard fonts. Mapping/hacking well-known
+      // chars to the similar equivalents in the normal characters range.
+      var getSpecialPUASymbols = getLookupTableFactory(function (t) {
+        t[63721] = 0x00A9;
+        // copyrightsans (0xF8E9) => copyright
+        t[63193] = 0x00A9;
+        // copyrightserif (0xF6D9) => copyright
+        t[63720] = 0x00AE;
+        // registersans (0xF8E8) => registered
+        t[63194] = 0x00AE;
+        // registerserif (0xF6DA) => registered
+        t[63722] = 0x2122;
+        // trademarksans (0xF8EA) => trademark
+        t[63195] = 0x2122;
+        // trademarkserif (0xF6DB) => trademark
+        t[63729] = 0x23A7;
+        // bracelefttp (0xF8F1)
+        t[63730] = 0x23A8;
+        // braceleftmid (0xF8F2)
+        t[63731] = 0x23A9;
+        // braceleftbt (0xF8F3)
+        t[63740] = 0x23AB;
+        // bracerighttp (0xF8FC)
+        t[63741] = 0x23AC;
+        // bracerightmid (0xF8FD)
+        t[63742] = 0x23AD;
+        // bracerightbt (0xF8FE)
+        t[63726] = 0x23A1;
+        // bracketlefttp (0xF8EE)
+        t[63727] = 0x23A2;
+        // bracketleftex (0xF8EF)
+        t[63728] = 0x23A3;
+        // bracketleftbt (0xF8F0)
+        t[63737] = 0x23A4;
+        // bracketrighttp (0xF8F9)
+        t[63738] = 0x23A5;
+        // bracketrightex (0xF8FA)
+        t[63739] = 0x23A6;
+        // bracketrightbt (0xF8FB)
+        t[63723] = 0x239B;
+        // parenlefttp (0xF8EB)
+        t[63724] = 0x239C;
+        // parenleftex (0xF8EC)
+        t[63725] = 0x239D;
+        // parenleftbt (0xF8ED)
+        t[63734] = 0x239E;
+        // parenrighttp (0xF8F6)
+        t[63735] = 0x239F;
+        // parenrightex (0xF8F7)
+        t[63736] = 0x23A0;
+      });
+      // parenrightbt (0xF8F8)
+      function mapSpecialUnicodeValues(code) {
+        if (code >= 0xFFF0 && code <= 0xFFFF) {
+          // Specials unicode block.
+          return 0;
+        } else if (code >= 0xF600 && code <= 0xF8FF) {
+          return getSpecialPUASymbols()[code] || code;
+        }
+        return code;
+      }
+      function getUnicodeForGlyph(name, glyphsUnicodeMap) {
+        var unicode = glyphsUnicodeMap[name];
+        if (unicode !== undefined) {
+          return unicode;
+        }
+        if (!name) {
+          return -1;
+        }
+        // Try to recover valid Unicode values from 'uniXXXX'/'uXXXX{XX}' glyphs.
+        if (name[0] === 'u') {
+          var nameLen = name.length, hexStr;
+          if (nameLen === 7 && name[1] === 'n' && name[2] === 'i') {
+            // 'uniXXXX'
+            hexStr = name.substr(3);
+          } else if (nameLen >= 5 && nameLen <= 7) {
+            // 'uXXXX{XX}'
+            hexStr = name.substr(1);
+          } else {
+            return -1;
+          }
+          // Check for upper-case hexadecimal characters, to avoid false positives.
+          if (hexStr === hexStr.toUpperCase()) {
+            unicode = parseInt(hexStr, 16);
+            if (unicode >= 0) {
+              return unicode;
+            }
+          }
+        }
+        return -1;
+      }
+      var UnicodeRanges = [
+        {
+          'begin': 0x0000,
+          'end': 0x007F
+        },
+        // Basic Latin
+        {
+          'begin': 0x0080,
+          'end': 0x00FF
+        },
+        // Latin-1 Supplement
+        {
+          'begin': 0x0100,
+          'end': 0x017F
+        },
+        // Latin Extended-A
+        {
+          'begin': 0x0180,
+          'end': 0x024F
+        },
+        // Latin Extended-B
+        {
+          'begin': 0x0250,
+          'end': 0x02AF
+        },
+        // IPA Extensions
+        {
+          'begin': 0x02B0,
+          'end': 0x02FF
+        },
+        // Spacing Modifier Letters
+        {
+          'begin': 0x0300,
+          'end': 0x036F
+        },
+        // Combining Diacritical Marks
+        {
+          'begin': 0x0370,
+          'end': 0x03FF
+        },
+        // Greek and Coptic
+        {
+          'begin': 0x2C80,
+          'end': 0x2CFF
+        },
+        // Coptic
+        {
+          'begin': 0x0400,
+          'end': 0x04FF
+        },
+        // Cyrillic
+        {
+          'begin': 0x0530,
+          'end': 0x058F
+        },
+        // Armenian
+        {
+          'begin': 0x0590,
+          'end': 0x05FF
+        },
+        // Hebrew
+        {
+          'begin': 0xA500,
+          'end': 0xA63F
+        },
+        // Vai
+        {
+          'begin': 0x0600,
+          'end': 0x06FF
+        },
+        // Arabic
+        {
+          'begin': 0x07C0,
+          'end': 0x07FF
+        },
+        // NKo
+        {
+          'begin': 0x0900,
+          'end': 0x097F
+        },
+        // Devanagari
+        {
+          'begin': 0x0980,
+          'end': 0x09FF
+        },
+        // Bengali
+        {
+          'begin': 0x0A00,
+          'end': 0x0A7F
+        },
+        // Gurmukhi
+        {
+          'begin': 0x0A80,
+          'end': 0x0AFF
+        },
+        // Gujarati
+        {
+          'begin': 0x0B00,
+          'end': 0x0B7F
+        },
+        // Oriya
+        {
+          'begin': 0x0B80,
+          'end': 0x0BFF
+        },
+        // Tamil
+        {
+          'begin': 0x0C00,
+          'end': 0x0C7F
+        },
+        // Telugu
+        {
+          'begin': 0x0C80,
+          'end': 0x0CFF
+        },
+        // Kannada
+        {
+          'begin': 0x0D00,
+          'end': 0x0D7F
+        },
+        // Malayalam
+        {
+          'begin': 0x0E00,
+          'end': 0x0E7F
+        },
+        // Thai
+        {
+          'begin': 0x0E80,
+          'end': 0x0EFF
+        },
+        // Lao
+        {
+          'begin': 0x10A0,
+          'end': 0x10FF
+        },
+        // Georgian
+        {
+          'begin': 0x1B00,
+          'end': 0x1B7F
+        },
+        // Balinese
+        {
+          'begin': 0x1100,
+          'end': 0x11FF
+        },
+        // Hangul Jamo
+        {
+          'begin': 0x1E00,
+          'end': 0x1EFF
+        },
+        // Latin Extended Additional
+        {
+          'begin': 0x1F00,
+          'end': 0x1FFF
+        },
+        // Greek Extended
+        {
+          'begin': 0x2000,
+          'end': 0x206F
+        },
+        // General Punctuation
+        {
+          'begin': 0x2070,
+          'end': 0x209F
+        },
+        // Superscripts And Subscripts
+        {
+          'begin': 0x20A0,
+          'end': 0x20CF
+        },
+        // Currency Symbol
+        {
+          'begin': 0x20D0,
+          'end': 0x20FF
+        },
+        // Combining Diacritical Marks
+        {
+          'begin': 0x2100,
+          'end': 0x214F
+        },
+        // Letterlike Symbols
+        {
+          'begin': 0x2150,
+          'end': 0x218F
+        },
+        // Number Forms
+        {
+          'begin': 0x2190,
+          'end': 0x21FF
+        },
+        // Arrows
+        {
+          'begin': 0x2200,
+          'end': 0x22FF
+        },
+        // Mathematical Operators
+        {
+          'begin': 0x2300,
+          'end': 0x23FF
+        },
+        // Miscellaneous Technical
+        {
+          'begin': 0x2400,
+          'end': 0x243F
+        },
+        // Control Pictures
+        {
+          'begin': 0x2440,
+          'end': 0x245F
+        },
+        // Optical Character Recognition
+        {
+          'begin': 0x2460,
+          'end': 0x24FF
+        },
+        // Enclosed Alphanumerics
+        {
+          'begin': 0x2500,
+          'end': 0x257F
+        },
+        // Box Drawing
+        {
+          'begin': 0x2580,
+          'end': 0x259F
+        },
+        // Block Elements
+        {
+          'begin': 0x25A0,
+          'end': 0x25FF
+        },
+        // Geometric Shapes
+        {
+          'begin': 0x2600,
+          'end': 0x26FF
+        },
+        // Miscellaneous Symbols
+        {
+          'begin': 0x2700,
+          'end': 0x27BF
+        },
+        // Dingbats
+        {
+          'begin': 0x3000,
+          'end': 0x303F
+        },
+        // CJK Symbols And Punctuation
+        {
+          'begin': 0x3040,
+          'end': 0x309F
+        },
+        // Hiragana
+        {
+          'begin': 0x30A0,
+          'end': 0x30FF
+        },
+        // Katakana
+        {
+          'begin': 0x3100,
+          'end': 0x312F
+        },
+        // Bopomofo
+        {
+          'begin': 0x3130,
+          'end': 0x318F
+        },
+        // Hangul Compatibility Jamo
+        {
+          'begin': 0xA840,
+          'end': 0xA87F
+        },
+        // Phags-pa
+        {
+          'begin': 0x3200,
+          'end': 0x32FF
+        },
+        // Enclosed CJK Letters And Months
+        {
+          'begin': 0x3300,
+          'end': 0x33FF
+        },
+        // CJK Compatibility
+        {
+          'begin': 0xAC00,
+          'end': 0xD7AF
+        },
+        // Hangul Syllables
+        {
+          'begin': 0xD800,
+          'end': 0xDFFF
+        },
+        // Non-Plane 0 *
+        {
+          'begin': 0x10900,
+          'end': 0x1091F
+        },
+        // Phoenicia
+        {
+          'begin': 0x4E00,
+          'end': 0x9FFF
+        },
+        // CJK Unified Ideographs
+        {
+          'begin': 0xE000,
+          'end': 0xF8FF
+        },
+        // Private Use Area (plane 0)
+        {
+          'begin': 0x31C0,
+          'end': 0x31EF
+        },
+        // CJK Strokes
+        {
+          'begin': 0xFB00,
+          'end': 0xFB4F
+        },
+        // Alphabetic Presentation Forms
+        {
+          'begin': 0xFB50,
+          'end': 0xFDFF
+        },
+        // Arabic Presentation Forms-A
+        {
+          'begin': 0xFE20,
+          'end': 0xFE2F
+        },
+        // Combining Half Marks
+        {
+          'begin': 0xFE10,
+          'end': 0xFE1F
+        },
+        // Vertical Forms
+        {
+          'begin': 0xFE50,
+          'end': 0xFE6F
+        },
+        // Small Form Variants
+        {
+          'begin': 0xFE70,
+          'end': 0xFEFF
+        },
+        // Arabic Presentation Forms-B
+        {
+          'begin': 0xFF00,
+          'end': 0xFFEF
+        },
+        // Halfwidth And Fullwidth Forms
+        {
+          'begin': 0xFFF0,
+          'end': 0xFFFF
+        },
+        // Specials
+        {
+          'begin': 0x0F00,
+          'end': 0x0FFF
+        },
+        // Tibetan
+        {
+          'begin': 0x0700,
+          'end': 0x074F
+        },
+        // Syriac
+        {
+          'begin': 0x0780,
+          'end': 0x07BF
+        },
+        // Thaana
+        {
+          'begin': 0x0D80,
+          'end': 0x0DFF
+        },
+        // Sinhala
+        {
+          'begin': 0x1000,
+          'end': 0x109F
+        },
+        // Myanmar
+        {
+          'begin': 0x1200,
+          'end': 0x137F
+        },
+        // Ethiopic
+        {
+          'begin': 0x13A0,
+          'end': 0x13FF
+        },
+        // Cherokee
+        {
+          'begin': 0x1400,
+          'end': 0x167F
+        },
+        // Unified Canadian Aboriginal Syllabics
+        {
+          'begin': 0x1680,
+          'end': 0x169F
+        },
+        // Ogham
+        {
+          'begin': 0x16A0,
+          'end': 0x16FF
+        },
+        // Runic
+        {
+          'begin': 0x1780,
+          'end': 0x17FF
+        },
+        // Khmer
+        {
+          'begin': 0x1800,
+          'end': 0x18AF
+        },
+        // Mongolian
+        {
+          'begin': 0x2800,
+          'end': 0x28FF
+        },
+        // Braille Patterns
+        {
+          'begin': 0xA000,
+          'end': 0xA48F
+        },
+        // Yi Syllables
+        {
+          'begin': 0x1700,
+          'end': 0x171F
+        },
+        // Tagalog
+        {
+          'begin': 0x10300,
+          'end': 0x1032F
+        },
+        // Old Italic
+        {
+          'begin': 0x10330,
+          'end': 0x1034F
+        },
+        // Gothic
+        {
+          'begin': 0x10400,
+          'end': 0x1044F
+        },
+        // Deseret
+        {
+          'begin': 0x1D000,
+          'end': 0x1D0FF
+        },
+        // Byzantine Musical Symbols
+        {
+          'begin': 0x1D400,
+          'end': 0x1D7FF
+        },
+        // Mathematical Alphanumeric Symbols
+        {
+          'begin': 0xFF000,
+          'end': 0xFFFFD
+        },
+        // Private Use (plane 15)
+        {
+          'begin': 0xFE00,
+          'end': 0xFE0F
+        },
+        // Variation Selectors
+        {
+          'begin': 0xE0000,
+          'end': 0xE007F
+        },
+        // Tags
+        {
+          'begin': 0x1900,
+          'end': 0x194F
+        },
+        // Limbu
+        {
+          'begin': 0x1950,
+          'end': 0x197F
+        },
+        // Tai Le
+        {
+          'begin': 0x1980,
+          'end': 0x19DF
+        },
+        // New Tai Lue
+        {
+          'begin': 0x1A00,
+          'end': 0x1A1F
+        },
+        // Buginese
+        {
+          'begin': 0x2C00,
+          'end': 0x2C5F
+        },
+        // Glagolitic
+        {
+          'begin': 0x2D30,
+          'end': 0x2D7F
+        },
+        // Tifinagh
+        {
+          'begin': 0x4DC0,
+          'end': 0x4DFF
+        },
+        // Yijing Hexagram Symbols
+        {
+          'begin': 0xA800,
+          'end': 0xA82F
+        },
+        // Syloti Nagri
+        {
+          'begin': 0x10000,
+          'end': 0x1007F
+        },
+        // Linear B Syllabary
+        {
+          'begin': 0x10140,
+          'end': 0x1018F
+        },
+        // Ancient Greek Numbers
+        {
+          'begin': 0x10380,
+          'end': 0x1039F
+        },
+        // Ugaritic
+        {
+          'begin': 0x103A0,
+          'end': 0x103DF
+        },
+        // Old Persian
+        {
+          'begin': 0x10450,
+          'end': 0x1047F
+        },
+        // Shavian
+        {
+          'begin': 0x10480,
+          'end': 0x104AF
+        },
+        // Osmanya
+        {
+          'begin': 0x10800,
+          'end': 0x1083F
+        },
+        // Cypriot Syllabary
+        {
+          'begin': 0x10A00,
+          'end': 0x10A5F
+        },
+        // Kharoshthi
+        {
+          'begin': 0x1D300,
+          'end': 0x1D35F
+        },
+        // Tai Xuan Jing Symbols
+        {
+          'begin': 0x12000,
+          'end': 0x123FF
+        },
+        // Cuneiform
+        {
+          'begin': 0x1D360,
+          'end': 0x1D37F
+        },
+        // Counting Rod Numerals
+        {
+          'begin': 0x1B80,
+          'end': 0x1BBF
+        },
+        // Sundanese
+        {
+          'begin': 0x1C00,
+          'end': 0x1C4F
+        },
+        // Lepcha
+        {
+          'begin': 0x1C50,
+          'end': 0x1C7F
+        },
+        // Ol Chiki
+        {
+          'begin': 0xA880,
+          'end': 0xA8DF
+        },
+        // Saurashtra
+        {
+          'begin': 0xA900,
+          'end': 0xA92F
+        },
+        // Kayah Li
+        {
+          'begin': 0xA930,
+          'end': 0xA95F
+        },
+        // Rejang
+        {
+          'begin': 0xAA00,
+          'end': 0xAA5F
+        },
+        // Cham
+        {
+          'begin': 0x10190,
+          'end': 0x101CF
+        },
+        // Ancient Symbols
+        {
+          'begin': 0x101D0,
+          'end': 0x101FF
+        },
+        // Phaistos Disc
+        {
+          'begin': 0x102A0,
+          'end': 0x102DF
+        },
+        // Carian
+        {
+          'begin': 0x1F030,
+          'end': 0x1F09F
+        }
+      ];
+      // Domino Tiles
+      function getUnicodeRangeFor(value) {
+        for (var i = 0, ii = UnicodeRanges.length; i < ii; i++) {
+          var range = UnicodeRanges[i];
+          if (value >= range.begin && value < range.end) {
+            return i;
+          }
+        }
+        return -1;
+      }
+      function isRTLRangeFor(value) {
+        var range = UnicodeRanges[13];
+        if (value >= range.begin && value < range.end) {
+          return true;
+        }
+        range = UnicodeRanges[11];
+        if (value >= range.begin && value < range.end) {
+          return true;
+        }
+        return false;
+      }
+      // The normalization table is obtained by filtering the Unicode characters
+      // database with <compat> entries.
+      var getNormalizedUnicodes = getLookupTableFactory(function (t) {
+        t['\u00A8'] = '\u0020\u0308';
+        t['\u00AF'] = '\u0020\u0304';
+        t['\u00B4'] = '\u0020\u0301';
+        t['\u00B5'] = '\u03BC';
+        t['\u00B8'] = '\u0020\u0327';
+        t['\u0132'] = '\u0049\u004A';
+        t['\u0133'] = '\u0069\u006A';
+        t['\u013F'] = '\u004C\u00B7';
+        t['\u0140'] = '\u006C\u00B7';
+        t['\u0149'] = '\u02BC\u006E';
+        t['\u017F'] = '\u0073';
+        t['\u01C4'] = '\u0044\u017D';
+        t['\u01C5'] = '\u0044\u017E';
+        t['\u01C6'] = '\u0064\u017E';
+        t['\u01C7'] = '\u004C\u004A';
+        t['\u01C8'] = '\u004C\u006A';
+        t['\u01C9'] = '\u006C\u006A';
+        t['\u01CA'] = '\u004E\u004A';
+        t['\u01CB'] = '\u004E\u006A';
+        t['\u01CC'] = '\u006E\u006A';
+        t['\u01F1'] = '\u0044\u005A';
+        t['\u01F2'] = '\u0044\u007A';
+        t['\u01F3'] = '\u0064\u007A';
+        t['\u02D8'] = '\u0020\u0306';
+        t['\u02D9'] = '\u0020\u0307';
+        t['\u02DA'] = '\u0020\u030A';
+        t['\u02DB'] = '\u0020\u0328';
+        t['\u02DC'] = '\u0020\u0303';
+        t['\u02DD'] = '\u0020\u030B';
+        t['\u037A'] = '\u0020\u0345';
+        t['\u0384'] = '\u0020\u0301';
+        t['\u03D0'] = '\u03B2';
+        t['\u03D1'] = '\u03B8';
+        t['\u03D2'] = '\u03A5';
+        t['\u03D5'] = '\u03C6';
+        t['\u03D6'] = '\u03C0';
+        t['\u03F0'] = '\u03BA';
+        t['\u03F1'] = '\u03C1';
+        t['\u03F2'] = '\u03C2';
+        t['\u03F4'] = '\u0398';
+        t['\u03F5'] = '\u03B5';
+        t['\u03F9'] = '\u03A3';
+        t['\u0587'] = '\u0565\u0582';
+        t['\u0675'] = '\u0627\u0674';
+        t['\u0676'] = '\u0648\u0674';
+        t['\u0677'] = '\u06C7\u0674';
+        t['\u0678'] = '\u064A\u0674';
+        t['\u0E33'] = '\u0E4D\u0E32';
+        t['\u0EB3'] = '\u0ECD\u0EB2';
+        t['\u0EDC'] = '\u0EAB\u0E99';
+        t['\u0EDD'] = '\u0EAB\u0EA1';
+        t['\u0F77'] = '\u0FB2\u0F81';
+        t['\u0F79'] = '\u0FB3\u0F81';
+        t['\u1E9A'] = '\u0061\u02BE';
+        t['\u1FBD'] = '\u0020\u0313';
+        t['\u1FBF'] = '\u0020\u0313';
+        t['\u1FC0'] = '\u0020\u0342';
+        t['\u1FFE'] = '\u0020\u0314';
+        t['\u2002'] = '\u0020';
+        t['\u2003'] = '\u0020';
+        t['\u2004'] = '\u0020';
+        t['\u2005'] = '\u0020';
+        t['\u2006'] = '\u0020';
+        t['\u2008'] = '\u0020';
+        t['\u2009'] = '\u0020';
+        t['\u200A'] = '\u0020';
+        t['\u2017'] = '\u0020\u0333';
+        t['\u2024'] = '\u002E';
+        t['\u2025'] = '\u002E\u002E';
+        t['\u2026'] = '\u002E\u002E\u002E';
+        t['\u2033'] = '\u2032\u2032';
+        t['\u2034'] = '\u2032\u2032\u2032';
+        t['\u2036'] = '\u2035\u2035';
+        t['\u2037'] = '\u2035\u2035\u2035';
+        t['\u203C'] = '\u0021\u0021';
+        t['\u203E'] = '\u0020\u0305';
+        t['\u2047'] = '\u003F\u003F';
+        t['\u2048'] = '\u003F\u0021';
+        t['\u2049'] = '\u0021\u003F';
+        t['\u2057'] = '\u2032\u2032\u2032\u2032';
+        t['\u205F'] = '\u0020';
+        t['\u20A8'] = '\u0052\u0073';
+        t['\u2100'] = '\u0061\u002F\u0063';
+        t['\u2101'] = '\u0061\u002F\u0073';
+        t['\u2103'] = '\u00B0\u0043';
+        t['\u2105'] = '\u0063\u002F\u006F';
+        t['\u2106'] = '\u0063\u002F\u0075';
+        t['\u2107'] = '\u0190';
+        t['\u2109'] = '\u00B0\u0046';
+        t['\u2116'] = '\u004E\u006F';
+        t['\u2121'] = '\u0054\u0045\u004C';
+        t['\u2135'] = '\u05D0';
+        t['\u2136'] = '\u05D1';
+        t['\u2137'] = '\u05D2';
+        t['\u2138'] = '\u05D3';
+        t['\u213B'] = '\u0046\u0041\u0058';
+        t['\u2160'] = '\u0049';
+        t['\u2161'] = '\u0049\u0049';
+        t['\u2162'] = '\u0049\u0049\u0049';
+        t['\u2163'] = '\u0049\u0056';
+        t['\u2164'] = '\u0056';
+        t['\u2165'] = '\u0056\u0049';
+        t['\u2166'] = '\u0056\u0049\u0049';
+        t['\u2167'] = '\u0056\u0049\u0049\u0049';
+        t['\u2168'] = '\u0049\u0058';
+        t['\u2169'] = '\u0058';
+        t['\u216A'] = '\u0058\u0049';
+        t['\u216B'] = '\u0058\u0049\u0049';
+        t['\u216C'] = '\u004C';
+        t['\u216D'] = '\u0043';
+        t['\u216E'] = '\u0044';
+        t['\u216F'] = '\u004D';
+        t['\u2170'] = '\u0069';
+        t['\u2171'] = '\u0069\u0069';
+        t['\u2172'] = '\u0069\u0069\u0069';
+        t['\u2173'] = '\u0069\u0076';
+        t['\u2174'] = '\u0076';
+        t['\u2175'] = '\u0076\u0069';
+        t['\u2176'] = '\u0076\u0069\u0069';
+        t['\u2177'] = '\u0076\u0069\u0069\u0069';
+        t['\u2178'] = '\u0069\u0078';
+        t['\u2179'] = '\u0078';
+        t['\u217A'] = '\u0078\u0069';
+        t['\u217B'] = '\u0078\u0069\u0069';
+        t['\u217C'] = '\u006C';
+        t['\u217D'] = '\u0063';
+        t['\u217E'] = '\u0064';
+        t['\u217F'] = '\u006D';
+        t['\u222C'] = '\u222B\u222B';
+        t['\u222D'] = '\u222B\u222B\u222B';
+        t['\u222F'] = '\u222E\u222E';
+        t['\u2230'] = '\u222E\u222E\u222E';
+        t['\u2474'] = '\u0028\u0031\u0029';
+        t['\u2475'] = '\u0028\u0032\u0029';
+        t['\u2476'] = '\u0028\u0033\u0029';
+        t['\u2477'] = '\u0028\u0034\u0029';
+        t['\u2478'] = '\u0028\u0035\u0029';
+        t['\u2479'] = '\u0028\u0036\u0029';
+        t['\u247A'] = '\u0028\u0037\u0029';
+        t['\u247B'] = '\u0028\u0038\u0029';
+        t['\u247C'] = '\u0028\u0039\u0029';
+        t['\u247D'] = '\u0028\u0031\u0030\u0029';
+        t['\u247E'] = '\u0028\u0031\u0031\u0029';
+        t['\u247F'] = '\u0028\u0031\u0032\u0029';
+        t['\u2480'] = '\u0028\u0031\u0033\u0029';
+        t['\u2481'] = '\u0028\u0031\u0034\u0029';
+        t['\u2482'] = '\u0028\u0031\u0035\u0029';
+        t['\u2483'] = '\u0028\u0031\u0036\u0029';
+        t['\u2484'] = '\u0028\u0031\u0037\u0029';
+        t['\u2485'] = '\u0028\u0031\u0038\u0029';
+        t['\u2486'] = '\u0028\u0031\u0039\u0029';
+        t['\u2487'] = '\u0028\u0032\u0030\u0029';
+        t['\u2488'] = '\u0031\u002E';
+        t['\u2489'] = '\u0032\u002E';
+        t['\u248A'] = '\u0033\u002E';
+        t['\u248B'] = '\u0034\u002E';
+        t['\u248C'] = '\u0035\u002E';
+        t['\u248D'] = '\u0036\u002E';
+        t['\u248E'] = '\u0037\u002E';
+        t['\u248F'] = '\u0038\u002E';
+        t['\u2490'] = '\u0039\u002E';
+        t['\u2491'] = '\u0031\u0030\u002E';
+        t['\u2492'] = '\u0031\u0031\u002E';
+        t['\u2493'] = '\u0031\u0032\u002E';
+        t['\u2494'] = '\u0031\u0033\u002E';
+        t['\u2495'] = '\u0031\u0034\u002E';
+        t['\u2496'] = '\u0031\u0035\u002E';
+        t['\u2497'] = '\u0031\u0036\u002E';
+        t['\u2498'] = '\u0031\u0037\u002E';
+        t['\u2499'] = '\u0031\u0038\u002E';
+        t['\u249A'] = '\u0031\u0039\u002E';
+        t['\u249B'] = '\u0032\u0030\u002E';
+        t['\u249C'] = '\u0028\u0061\u0029';
+        t['\u249D'] = '\u0028\u0062\u0029';
+        t['\u249E'] = '\u0028\u0063\u0029';
+        t['\u249F'] = '\u0028\u0064\u0029';
+        t['\u24A0'] = '\u0028\u0065\u0029';
+        t['\u24A1'] = '\u0028\u0066\u0029';
+        t['\u24A2'] = '\u0028\u0067\u0029';
+        t['\u24A3'] = '\u0028\u0068\u0029';
+        t['\u24A4'] = '\u0028\u0069\u0029';
+        t['\u24A5'] = '\u0028\u006A\u0029';
+        t['\u24A6'] = '\u0028\u006B\u0029';
+        t['\u24A7'] = '\u0028\u006C\u0029';
+        t['\u24A8'] = '\u0028\u006D\u0029';
+        t['\u24A9'] = '\u0028\u006E\u0029';
+        t['\u24AA'] = '\u0028\u006F\u0029';
+        t['\u24AB'] = '\u0028\u0070\u0029';
+        t['\u24AC'] = '\u0028\u0071\u0029';
+        t['\u24AD'] = '\u0028\u0072\u0029';
+        t['\u24AE'] = '\u0028\u0073\u0029';
+        t['\u24AF'] = '\u0028\u0074\u0029';
+        t['\u24B0'] = '\u0028\u0075\u0029';
+        t['\u24B1'] = '\u0028\u0076\u0029';
+        t['\u24B2'] = '\u0028\u0077\u0029';
+        t['\u24B3'] = '\u0028\u0078\u0029';
+        t['\u24B4'] = '\u0028\u0079\u0029';
+        t['\u24B5'] = '\u0028\u007A\u0029';
+        t['\u2A0C'] = '\u222B\u222B\u222B\u222B';
+        t['\u2A74'] = '\u003A\u003A\u003D';
+        t['\u2A75'] = '\u003D\u003D';
+        t['\u2A76'] = '\u003D\u003D\u003D';
+        t['\u2E9F'] = '\u6BCD';
+        t['\u2EF3'] = '\u9F9F';
+        t['\u2F00'] = '\u4E00';
+        t['\u2F01'] = '\u4E28';
+        t['\u2F02'] = '\u4E36';
+        t['\u2F03'] = '\u4E3F';
+        t['\u2F04'] = '\u4E59';
+        t['\u2F05'] = '\u4E85';
+        t['\u2F06'] = '\u4E8C';
+        t['\u2F07'] = '\u4EA0';
+        t['\u2F08'] = '\u4EBA';
+        t['\u2F09'] = '\u513F';
+        t['\u2F0A'] = '\u5165';
+        t['\u2F0B'] = '\u516B';
+        t['\u2F0C'] = '\u5182';
+        t['\u2F0D'] = '\u5196';
+        t['\u2F0E'] = '\u51AB';
+        t['\u2F0F'] = '\u51E0';
+        t['\u2F10'] = '\u51F5';
+        t['\u2F11'] = '\u5200';
+        t['\u2F12'] = '\u529B';
+        t['\u2F13'] = '\u52F9';
+        t['\u2F14'] = '\u5315';
+        t['\u2F15'] = '\u531A';
+        t['\u2F16'] = '\u5338';
+        t['\u2F17'] = '\u5341';
+        t['\u2F18'] = '\u535C';
+        t['\u2F19'] = '\u5369';
+        t['\u2F1A'] = '\u5382';
+        t['\u2F1B'] = '\u53B6';
+        t['\u2F1C'] = '\u53C8';
+        t['\u2F1D'] = '\u53E3';
+        t['\u2F1E'] = '\u56D7';
+        t['\u2F1F'] = '\u571F';
+        t['\u2F20'] = '\u58EB';
+        t['\u2F21'] = '\u5902';
+        t['\u2F22'] = '\u590A';
+        t['\u2F23'] = '\u5915';
+        t['\u2F24'] = '\u5927';
+        t['\u2F25'] = '\u5973';
+        t['\u2F26'] = '\u5B50';
+        t['\u2F27'] = '\u5B80';
+        t['\u2F28'] = '\u5BF8';
+        t['\u2F29'] = '\u5C0F';
+        t['\u2F2A'] = '\u5C22';
+        t['\u2F2B'] = '\u5C38';
+        t['\u2F2C'] = '\u5C6E';
+        t['\u2F2D'] = '\u5C71';
+        t['\u2F2E'] = '\u5DDB';
+        t['\u2F2F'] = '\u5DE5';
+        t['\u2F30'] = '\u5DF1';
+        t['\u2F31'] = '\u5DFE';
+        t['\u2F32'] = '\u5E72';
+        t['\u2F33'] = '\u5E7A';
+        t['\u2F34'] = '\u5E7F';
+        t['\u2F35'] = '\u5EF4';
+        t['\u2F36'] = '\u5EFE';
+        t['\u2F37'] = '\u5F0B';
+        t['\u2F38'] = '\u5F13';
+        t['\u2F39'] = '\u5F50';
+        t['\u2F3A'] = '\u5F61';
+        t['\u2F3B'] = '\u5F73';
+        t['\u2F3C'] = '\u5FC3';
+        t['\u2F3D'] = '\u6208';
+        t['\u2F3E'] = '\u6236';
+        t['\u2F3F'] = '\u624B';
+        t['\u2F40'] = '\u652F';
+        t['\u2F41'] = '\u6534';
+        t['\u2F42'] = '\u6587';
+        t['\u2F43'] = '\u6597';
+        t['\u2F44'] = '\u65A4';
+        t['\u2F45'] = '\u65B9';
+        t['\u2F46'] = '\u65E0';
+        t['\u2F47'] = '\u65E5';
+        t['\u2F48'] = '\u66F0';
+        t['\u2F49'] = '\u6708';
+        t['\u2F4A'] = '\u6728';
+        t['\u2F4B'] = '\u6B20';
+        t['\u2F4C'] = '\u6B62';
+        t['\u2F4D'] = '\u6B79';
+        t['\u2F4E'] = '\u6BB3';
+        t['\u2F4F'] = '\u6BCB';
+        t['\u2F50'] = '\u6BD4';
+        t['\u2F51'] = '\u6BDB';
+        t['\u2F52'] = '\u6C0F';
+        t['\u2F53'] = '\u6C14';
+        t['\u2F54'] = '\u6C34';
+        t['\u2F55'] = '\u706B';
+        t['\u2F56'] = '\u722A';
+        t['\u2F57'] = '\u7236';
+        t['\u2F58'] = '\u723B';
+        t['\u2F59'] = '\u723F';
+        t['\u2F5A'] = '\u7247';
+        t['\u2F5B'] = '\u7259';
+        t['\u2F5C'] = '\u725B';
+        t['\u2F5D'] = '\u72AC';
+        t['\u2F5E'] = '\u7384';
+        t['\u2F5F'] = '\u7389';
+        t['\u2F60'] = '\u74DC';
+        t['\u2F61'] = '\u74E6';
+        t['\u2F62'] = '\u7518';
+        t['\u2F63'] = '\u751F';
+        t['\u2F64'] = '\u7528';
+        t['\u2F65'] = '\u7530';
+        t['\u2F66'] = '\u758B';
+        t['\u2F67'] = '\u7592';
+        t['\u2F68'] = '\u7676';
+        t['\u2F69'] = '\u767D';
+        t['\u2F6A'] = '\u76AE';
+        t['\u2F6B'] = '\u76BF';
+        t['\u2F6C'] = '\u76EE';
+        t['\u2F6D'] = '\u77DB';
+        t['\u2F6E'] = '\u77E2';
+        t['\u2F6F'] = '\u77F3';
+        t['\u2F70'] = '\u793A';
+        t['\u2F71'] = '\u79B8';
+        t['\u2F72'] = '\u79BE';
+        t['\u2F73'] = '\u7A74';
+        t['\u2F74'] = '\u7ACB';
+        t['\u2F75'] = '\u7AF9';
+        t['\u2F76'] = '\u7C73';
+        t['\u2F77'] = '\u7CF8';
+        t['\u2F78'] = '\u7F36';
+        t['\u2F79'] = '\u7F51';
+        t['\u2F7A'] = '\u7F8A';
+        t['\u2F7B'] = '\u7FBD';
+        t['\u2F7C'] = '\u8001';
+        t['\u2F7D'] = '\u800C';
+        t['\u2F7E'] = '\u8012';
+        t['\u2F7F'] = '\u8033';
+        t['\u2F80'] = '\u807F';
+        t['\u2F81'] = '\u8089';
+        t['\u2F82'] = '\u81E3';
+        t['\u2F83'] = '\u81EA';
+        t['\u2F84'] = '\u81F3';
+        t['\u2F85'] = '\u81FC';
+        t['\u2F86'] = '\u820C';
+        t['\u2F87'] = '\u821B';
+        t['\u2F88'] = '\u821F';
+        t['\u2F89'] = '\u826E';
+        t['\u2F8A'] = '\u8272';
+        t['\u2F8B'] = '\u8278';
+        t['\u2F8C'] = '\u864D';
+        t['\u2F8D'] = '\u866B';
+        t['\u2F8E'] = '\u8840';
+        t['\u2F8F'] = '\u884C';
+        t['\u2F90'] = '\u8863';
+        t['\u2F91'] = '\u897E';
+        t['\u2F92'] = '\u898B';
+        t['\u2F93'] = '\u89D2';
+        t['\u2F94'] = '\u8A00';
+        t['\u2F95'] = '\u8C37';
+        t['\u2F96'] = '\u8C46';
+        t['\u2F97'] = '\u8C55';
+        t['\u2F98'] = '\u8C78';
+        t['\u2F99'] = '\u8C9D';
+        t['\u2F9A'] = '\u8D64';
+        t['\u2F9B'] = '\u8D70';
+        t['\u2F9C'] = '\u8DB3';
+        t['\u2F9D'] = '\u8EAB';
+        t['\u2F9E'] = '\u8ECA';
+        t['\u2F9F'] = '\u8F9B';
+        t['\u2FA0'] = '\u8FB0';
+        t['\u2FA1'] = '\u8FB5';
+        t['\u2FA2'] = '\u9091';
+        t['\u2FA3'] = '\u9149';
+        t['\u2FA4'] = '\u91C6';
+        t['\u2FA5'] = '\u91CC';
+        t['\u2FA6'] = '\u91D1';
+        t['\u2FA7'] = '\u9577';
+        t['\u2FA8'] = '\u9580';
+        t['\u2FA9'] = '\u961C';
+        t['\u2FAA'] = '\u96B6';
+        t['\u2FAB'] = '\u96B9';
+        t['\u2FAC'] = '\u96E8';
+        t['\u2FAD'] = '\u9751';
+        t['\u2FAE'] = '\u975E';
+        t['\u2FAF'] = '\u9762';
+        t['\u2FB0'] = '\u9769';
+        t['\u2FB1'] = '\u97CB';
+        t['\u2FB2'] = '\u97ED';
+        t['\u2FB3'] = '\u97F3';
+        t['\u2FB4'] = '\u9801';
+        t['\u2FB5'] = '\u98A8';
+        t['\u2FB6'] = '\u98DB';
+        t['\u2FB7'] = '\u98DF';
+        t['\u2FB8'] = '\u9996';
+        t['\u2FB9'] = '\u9999';
+        t['\u2FBA'] = '\u99AC';
+        t['\u2FBB'] = '\u9AA8';
+        t['\u2FBC'] = '\u9AD8';
+        t['\u2FBD'] = '\u9ADF';
+        t['\u2FBE'] = '\u9B25';
+        t['\u2FBF'] = '\u9B2F';
+        t['\u2FC0'] = '\u9B32';
+        t['\u2FC1'] = '\u9B3C';
+        t['\u2FC2'] = '\u9B5A';
+        t['\u2FC3'] = '\u9CE5';
+        t['\u2FC4'] = '\u9E75';
+        t['\u2FC5'] = '\u9E7F';
+        t['\u2FC6'] = '\u9EA5';
+        t['\u2FC7'] = '\u9EBB';
+        t['\u2FC8'] = '\u9EC3';
+        t['\u2FC9'] = '\u9ECD';
+        t['\u2FCA'] = '\u9ED1';
+        t['\u2FCB'] = '\u9EF9';
+        t['\u2FCC'] = '\u9EFD';
+        t['\u2FCD'] = '\u9F0E';
+        t['\u2FCE'] = '\u9F13';
+        t['\u2FCF'] = '\u9F20';
+        t['\u2FD0'] = '\u9F3B';
+        t['\u2FD1'] = '\u9F4A';
+        t['\u2FD2'] = '\u9F52';
+        t['\u2FD3'] = '\u9F8D';
+        t['\u2FD4'] = '\u9F9C';
+        t['\u2FD5'] = '\u9FA0';
+        t['\u3036'] = '\u3012';
+        t['\u3038'] = '\u5341';
+        t['\u3039'] = '\u5344';
+        t['\u303A'] = '\u5345';
+        t['\u309B'] = '\u0020\u3099';
+        t['\u309C'] = '\u0020\u309A';
+        t['\u3131'] = '\u1100';
+        t['\u3132'] = '\u1101';
+        t['\u3133'] = '\u11AA';
+        t['\u3134'] = '\u1102';
+        t['\u3135'] = '\u11AC';
+        t['\u3136'] = '\u11AD';
+        t['\u3137'] = '\u1103';
+        t['\u3138'] = '\u1104';
+        t['\u3139'] = '\u1105';
+        t['\u313A'] = '\u11B0';
+        t['\u313B'] = '\u11B1';
+        t['\u313C'] = '\u11B2';
+        t['\u313D'] = '\u11B3';
+        t['\u313E'] = '\u11B4';
+        t['\u313F'] = '\u11B5';
+        t['\u3140'] = '\u111A';
+        t['\u3141'] = '\u1106';
+        t['\u3142'] = '\u1107';
+        t['\u3143'] = '\u1108';
+        t['\u3144'] = '\u1121';
+        t['\u3145'] = '\u1109';
+        t['\u3146'] = '\u110A';
+        t['\u3147'] = '\u110B';
+        t['\u3148'] = '\u110C';
+        t['\u3149'] = '\u110D';
+        t['\u314A'] = '\u110E';
+        t['\u314B'] = '\u110F';
+        t['\u314C'] = '\u1110';
+        t['\u314D'] = '\u1111';
+        t['\u314E'] = '\u1112';
+        t['\u314F'] = '\u1161';
+        t['\u3150'] = '\u1162';
+        t['\u3151'] = '\u1163';
+        t['\u3152'] = '\u1164';
+        t['\u3153'] = '\u1165';
+        t['\u3154'] = '\u1166';
+        t['\u3155'] = '\u1167';
+        t['\u3156'] = '\u1168';
+        t['\u3157'] = '\u1169';
+        t['\u3158'] = '\u116A';
+        t['\u3159'] = '\u116B';
+        t['\u315A'] = '\u116C';
+        t['\u315B'] = '\u116D';
+        t['\u315C'] = '\u116E';
+        t['\u315D'] = '\u116F';
+        t['\u315E'] = '\u1170';
+        t['\u315F'] = '\u1171';
+        t['\u3160'] = '\u1172';
+        t['\u3161'] = '\u1173';
+        t['\u3162'] = '\u1174';
+        t['\u3163'] = '\u1175';
+        t['\u3164'] = '\u1160';
+        t['\u3165'] = '\u1114';
+        t['\u3166'] = '\u1115';
+        t['\u3167'] = '\u11C7';
+        t['\u3168'] = '\u11C8';
+        t['\u3169'] = '\u11CC';
+        t['\u316A'] = '\u11CE';
+        t['\u316B'] = '\u11D3';
+        t['\u316C'] = '\u11D7';
+        t['\u316D'] = '\u11D9';
+        t['\u316E'] = '\u111C';
+        t['\u316F'] = '\u11DD';
+        t['\u3170'] = '\u11DF';
+        t['\u3171'] = '\u111D';
+        t['\u3172'] = '\u111E';
+        t['\u3173'] = '\u1120';
+        t['\u3174'] = '\u1122';
+        t['\u3175'] = '\u1123';
+        t['\u3176'] = '\u1127';
+        t['\u3177'] = '\u1129';
+        t['\u3178'] = '\u112B';
+        t['\u3179'] = '\u112C';
+        t['\u317A'] = '\u112D';
+        t['\u317B'] = '\u112E';
+        t['\u317C'] = '\u112F';
+        t['\u317D'] = '\u1132';
+        t['\u317E'] = '\u1136';
+        t['\u317F'] = '\u1140';
+        t['\u3180'] = '\u1147';
+        t['\u3181'] = '\u114C';
+        t['\u3182'] = '\u11F1';
+        t['\u3183'] = '\u11F2';
+        t['\u3184'] = '\u1157';
+        t['\u3185'] = '\u1158';
+        t['\u3186'] = '\u1159';
+        t['\u3187'] = '\u1184';
+        t['\u3188'] = '\u1185';
+        t['\u3189'] = '\u1188';
+        t['\u318A'] = '\u1191';
+        t['\u318B'] = '\u1192';
+        t['\u318C'] = '\u1194';
+        t['\u318D'] = '\u119E';
+        t['\u318E'] = '\u11A1';
+        t['\u3200'] = '\u0028\u1100\u0029';
+        t['\u3201'] = '\u0028\u1102\u0029';
+        t['\u3202'] = '\u0028\u1103\u0029';
+        t['\u3203'] = '\u0028\u1105\u0029';
+        t['\u3204'] = '\u0028\u1106\u0029';
+        t['\u3205'] = '\u0028\u1107\u0029';
+        t['\u3206'] = '\u0028\u1109\u0029';
+        t['\u3207'] = '\u0028\u110B\u0029';
+        t['\u3208'] = '\u0028\u110C\u0029';
+        t['\u3209'] = '\u0028\u110E\u0029';
+        t['\u320A'] = '\u0028\u110F\u0029';
+        t['\u320B'] = '\u0028\u1110\u0029';
+        t['\u320C'] = '\u0028\u1111\u0029';
+        t['\u320D'] = '\u0028\u1112\u0029';
+        t['\u320E'] = '\u0028\u1100\u1161\u0029';
+        t['\u320F'] = '\u0028\u1102\u1161\u0029';
+        t['\u3210'] = '\u0028\u1103\u1161\u0029';
+        t['\u3211'] = '\u0028\u1105\u1161\u0029';
+        t['\u3212'] = '\u0028\u1106\u1161\u0029';
+        t['\u3213'] = '\u0028\u1107\u1161\u0029';
+        t['\u3214'] = '\u0028\u1109\u1161\u0029';
+        t['\u3215'] = '\u0028\u110B\u1161\u0029';
+        t['\u3216'] = '\u0028\u110C\u1161\u0029';
+        t['\u3217'] = '\u0028\u110E\u1161\u0029';
+        t['\u3218'] = '\u0028\u110F\u1161\u0029';
+        t['\u3219'] = '\u0028\u1110\u1161\u0029';
+        t['\u321A'] = '\u0028\u1111\u1161\u0029';
+        t['\u321B'] = '\u0028\u1112\u1161\u0029';
+        t['\u321C'] = '\u0028\u110C\u116E\u0029';
+        t['\u321D'] = '\u0028\u110B\u1169\u110C\u1165\u11AB\u0029';
+        t['\u321E'] = '\u0028\u110B\u1169\u1112\u116E\u0029';
+        t['\u3220'] = '\u0028\u4E00\u0029';
+        t['\u3221'] = '\u0028\u4E8C\u0029';
+        t['\u3222'] = '\u0028\u4E09\u0029';
+        t['\u3223'] = '\u0028\u56DB\u0029';
+        t['\u3224'] = '\u0028\u4E94\u0029';
+        t['\u3225'] = '\u0028\u516D\u0029';
+        t['\u3226'] = '\u0028\u4E03\u0029';
+        t['\u3227'] = '\u0028\u516B\u0029';
+        t['\u3228'] = '\u0028\u4E5D\u0029';
+        t['\u3229'] = '\u0028\u5341\u0029';
+        t['\u322A'] = '\u0028\u6708\u0029';
+        t['\u322B'] = '\u0028\u706B\u0029';
+        t['\u322C'] = '\u0028\u6C34\u0029';
+        t['\u322D'] = '\u0028\u6728\u0029';
+        t['\u322E'] = '\u0028\u91D1\u0029';
+        t['\u322F'] = '\u0028\u571F\u0029';
+        t['\u3230'] = '\u0028\u65E5\u0029';
+        t['\u3231'] = '\u0028\u682A\u0029';
+        t['\u3232'] = '\u0028\u6709\u0029';
+        t['\u3233'] = '\u0028\u793E\u0029';
+        t['\u3234'] = '\u0028\u540D\u0029';
+        t['\u3235'] = '\u0028\u7279\u0029';
+        t['\u3236'] = '\u0028\u8CA1\u0029';
+        t['\u3237'] = '\u0028\u795D\u0029';
+        t['\u3238'] = '\u0028\u52B4\u0029';
+        t['\u3239'] = '\u0028\u4EE3\u0029';
+        t['\u323A'] = '\u0028\u547C\u0029';
+        t['\u323B'] = '\u0028\u5B66\u0029';
+        t['\u323C'] = '\u0028\u76E3\u0029';
+        t['\u323D'] = '\u0028\u4F01\u0029';
+        t['\u323E'] = '\u0028\u8CC7\u0029';
+        t['\u323F'] = '\u0028\u5354\u0029';
+        t['\u3240'] = '\u0028\u796D\u0029';
+        t['\u3241'] = '\u0028\u4F11\u0029';
+        t['\u3242'] = '\u0028\u81EA\u0029';
+        t['\u3243'] = '\u0028\u81F3\u0029';
+        t['\u32C0'] = '\u0031\u6708';
+        t['\u32C1'] = '\u0032\u6708';
+        t['\u32C2'] = '\u0033\u6708';
+        t['\u32C3'] = '\u0034\u6708';
+        t['\u32C4'] = '\u0035\u6708';
+        t['\u32C5'] = '\u0036\u6708';
+        t['\u32C6'] = '\u0037\u6708';
+        t['\u32C7'] = '\u0038\u6708';
+        t['\u32C8'] = '\u0039\u6708';
+        t['\u32C9'] = '\u0031\u0030\u6708';
+        t['\u32CA'] = '\u0031\u0031\u6708';
+        t['\u32CB'] = '\u0031\u0032\u6708';
+        t['\u3358'] = '\u0030\u70B9';
+        t['\u3359'] = '\u0031\u70B9';
+        t['\u335A'] = '\u0032\u70B9';
+        t['\u335B'] = '\u0033\u70B9';
+        t['\u335C'] = '\u0034\u70B9';
+        t['\u335D'] = '\u0035\u70B9';
+        t['\u335E'] = '\u0036\u70B9';
+        t['\u335F'] = '\u0037\u70B9';
+        t['\u3360'] = '\u0038\u70B9';
+        t['\u3361'] = '\u0039\u70B9';
+        t['\u3362'] = '\u0031\u0030\u70B9';
+        t['\u3363'] = '\u0031\u0031\u70B9';
+        t['\u3364'] = '\u0031\u0032\u70B9';
+        t['\u3365'] = '\u0031\u0033\u70B9';
+        t['\u3366'] = '\u0031\u0034\u70B9';
+        t['\u3367'] = '\u0031\u0035\u70B9';
+        t['\u3368'] = '\u0031\u0036\u70B9';
+        t['\u3369'] = '\u0031\u0037\u70B9';
+        t['\u336A'] = '\u0031\u0038\u70B9';
+        t['\u336B'] = '\u0031\u0039\u70B9';
+        t['\u336C'] = '\u0032\u0030\u70B9';
+        t['\u336D'] = '\u0032\u0031\u70B9';
+        t['\u336E'] = '\u0032\u0032\u70B9';
+        t['\u336F'] = '\u0032\u0033\u70B9';
+        t['\u3370'] = '\u0032\u0034\u70B9';
+        t['\u33E0'] = '\u0031\u65E5';
+        t['\u33E1'] = '\u0032\u65E5';
+        t['\u33E2'] = '\u0033\u65E5';
+        t['\u33E3'] = '\u0034\u65E5';
+        t['\u33E4'] = '\u0035\u65E5';
+        t['\u33E5'] = '\u0036\u65E5';
+        t['\u33E6'] = '\u0037\u65E5';
+        t['\u33E7'] = '\u0038\u65E5';
+        t['\u33E8'] = '\u0039\u65E5';
+        t['\u33E9'] = '\u0031\u0030\u65E5';
+        t['\u33EA'] = '\u0031\u0031\u65E5';
+        t['\u33EB'] = '\u0031\u0032\u65E5';
+        t['\u33EC'] = '\u0031\u0033\u65E5';
+        t['\u33ED'] = '\u0031\u0034\u65E5';
+        t['\u33EE'] = '\u0031\u0035\u65E5';
+        t['\u33EF'] = '\u0031\u0036\u65E5';
+        t['\u33F0'] = '\u0031\u0037\u65E5';
+        t['\u33F1'] = '\u0031\u0038\u65E5';
+        t['\u33F2'] = '\u0031\u0039\u65E5';
+        t['\u33F3'] = '\u0032\u0030\u65E5';
+        t['\u33F4'] = '\u0032\u0031\u65E5';
+        t['\u33F5'] = '\u0032\u0032\u65E5';
+        t['\u33F6'] = '\u0032\u0033\u65E5';
+        t['\u33F7'] = '\u0032\u0034\u65E5';
+        t['\u33F8'] = '\u0032\u0035\u65E5';
+        t['\u33F9'] = '\u0032\u0036\u65E5';
+        t['\u33FA'] = '\u0032\u0037\u65E5';
+        t['\u33FB'] = '\u0032\u0038\u65E5';
+        t['\u33FC'] = '\u0032\u0039\u65E5';
+        t['\u33FD'] = '\u0033\u0030\u65E5';
+        t['\u33FE'] = '\u0033\u0031\u65E5';
+        t['\uFB00'] = '\u0066\u0066';
+        t['\uFB01'] = '\u0066\u0069';
+        t['\uFB02'] = '\u0066\u006C';
+        t['\uFB03'] = '\u0066\u0066\u0069';
+        t['\uFB04'] = '\u0066\u0066\u006C';
+        t['\uFB05'] = '\u017F\u0074';
+        t['\uFB06'] = '\u0073\u0074';
+        t['\uFB13'] = '\u0574\u0576';
+        t['\uFB14'] = '\u0574\u0565';
+        t['\uFB15'] = '\u0574\u056B';
+        t['\uFB16'] = '\u057E\u0576';
+        t['\uFB17'] = '\u0574\u056D';
+        t['\uFB4F'] = '\u05D0\u05DC';
+        t['\uFB50'] = '\u0671';
+        t['\uFB51'] = '\u0671';
+        t['\uFB52'] = '\u067B';
+        t['\uFB53'] = '\u067B';
+        t['\uFB54'] = '\u067B';
+        t['\uFB55'] = '\u067B';
+        t['\uFB56'] = '\u067E';
+        t['\uFB57'] = '\u067E';
+        t['\uFB58'] = '\u067E';
+        t['\uFB59'] = '\u067E';
+        t['\uFB5A'] = '\u0680';
+        t['\uFB5B'] = '\u0680';
+        t['\uFB5C'] = '\u0680';
+        t['\uFB5D'] = '\u0680';
+        t['\uFB5E'] = '\u067A';
+        t['\uFB5F'] = '\u067A';
+        t['\uFB60'] = '\u067A';
+        t['\uFB61'] = '\u067A';
+        t['\uFB62'] = '\u067F';
+        t['\uFB63'] = '\u067F';
+        t['\uFB64'] = '\u067F';
+        t['\uFB65'] = '\u067F';
+        t['\uFB66'] = '\u0679';
+        t['\uFB67'] = '\u0679';
+        t['\uFB68'] = '\u0679';
+        t['\uFB69'] = '\u0679';
+        t['\uFB6A'] = '\u06A4';
+        t['\uFB6B'] = '\u06A4';
+        t['\uFB6C'] = '\u06A4';
+        t['\uFB6D'] = '\u06A4';
+        t['\uFB6E'] = '\u06A6';
+        t['\uFB6F'] = '\u06A6';
+        t['\uFB70'] = '\u06A6';
+        t['\uFB71'] = '\u06A6';
+        t['\uFB72'] = '\u0684';
+        t['\uFB73'] = '\u0684';
+        t['\uFB74'] = '\u0684';
+        t['\uFB75'] = '\u0684';
+        t['\uFB76'] = '\u0683';
+        t['\uFB77'] = '\u0683';
+        t['\uFB78'] = '\u0683';
+        t['\uFB79'] = '\u0683';
+        t['\uFB7A'] = '\u0686';
+        t['\uFB7B'] = '\u0686';
+        t['\uFB7C'] = '\u0686';
+        t['\uFB7D'] = '\u0686';
+        t['\uFB7E'] = '\u0687';
+        t['\uFB7F'] = '\u0687';
+        t['\uFB80'] = '\u0687';
+        t['\uFB81'] = '\u0687';
+        t['\uFB82'] = '\u068D';
+        t['\uFB83'] = '\u068D';
+        t['\uFB84'] = '\u068C';
+        t['\uFB85'] = '\u068C';
+        t['\uFB86'] = '\u068E';
+        t['\uFB87'] = '\u068E';
+        t['\uFB88'] = '\u0688';
+        t['\uFB89'] = '\u0688';
+        t['\uFB8A'] = '\u0698';
+        t['\uFB8B'] = '\u0698';
+        t['\uFB8C'] = '\u0691';
+        t['\uFB8D'] = '\u0691';
+        t['\uFB8E'] = '\u06A9';
+        t['\uFB8F'] = '\u06A9';
+        t['\uFB90'] = '\u06A9';
+        t['\uFB91'] = '\u06A9';
+        t['\uFB92'] = '\u06AF';
+        t['\uFB93'] = '\u06AF';
+        t['\uFB94'] = '\u06AF';
+        t['\uFB95'] = '\u06AF';
+        t['\uFB96'] = '\u06B3';
+        t['\uFB97'] = '\u06B3';
+        t['\uFB98'] = '\u06B3';
+        t['\uFB99'] = '\u06B3';
+        t['\uFB9A'] = '\u06B1';
+        t['\uFB9B'] = '\u06B1';
+        t['\uFB9C'] = '\u06B1';
+        t['\uFB9D'] = '\u06B1';
+        t['\uFB9E'] = '\u06BA';
+        t['\uFB9F'] = '\u06BA';
+        t['\uFBA0'] = '\u06BB';
+        t['\uFBA1'] = '\u06BB';
+        t['\uFBA2'] = '\u06BB';
+        t['\uFBA3'] = '\u06BB';
+        t['\uFBA4'] = '\u06C0';
+        t['\uFBA5'] = '\u06C0';
+        t['\uFBA6'] = '\u06C1';
+        t['\uFBA7'] = '\u06C1';
+        t['\uFBA8'] = '\u06C1';
+        t['\uFBA9'] = '\u06C1';
+        t['\uFBAA'] = '\u06BE';
+        t['\uFBAB'] = '\u06BE';
+        t['\uFBAC'] = '\u06BE';
+        t['\uFBAD'] = '\u06BE';
+        t['\uFBAE'] = '\u06D2';
+        t['\uFBAF'] = '\u06D2';
+        t['\uFBB0'] = '\u06D3';
+        t['\uFBB1'] = '\u06D3';
+        t['\uFBD3'] = '\u06AD';
+        t['\uFBD4'] = '\u06AD';
+        t['\uFBD5'] = '\u06AD';
+        t['\uFBD6'] = '\u06AD';
+        t['\uFBD7'] = '\u06C7';
+        t['\uFBD8'] = '\u06C7';
+        t['\uFBD9'] = '\u06C6';
+        t['\uFBDA'] = '\u06C6';
+        t['\uFBDB'] = '\u06C8';
+        t['\uFBDC'] = '\u06C8';
+        t['\uFBDD'] = '\u0677';
+        t['\uFBDE'] = '\u06CB';
+        t['\uFBDF'] = '\u06CB';
+        t['\uFBE0'] = '\u06C5';
+        t['\uFBE1'] = '\u06C5';
+        t['\uFBE2'] = '\u06C9';
+        t['\uFBE3'] = '\u06C9';
+        t['\uFBE4'] = '\u06D0';
+        t['\uFBE5'] = '\u06D0';
+        t['\uFBE6'] = '\u06D0';
+        t['\uFBE7'] = '\u06D0';
+        t['\uFBE8'] = '\u0649';
+        t['\uFBE9'] = '\u0649';
+        t['\uFBEA'] = '\u0626\u0627';
+        t['\uFBEB'] = '\u0626\u0627';
+        t['\uFBEC'] = '\u0626\u06D5';
+        t['\uFBED'] = '\u0626\u06D5';
+        t['\uFBEE'] = '\u0626\u0648';
+        t['\uFBEF'] = '\u0626\u0648';
+        t['\uFBF0'] = '\u0626\u06C7';
+        t['\uFBF1'] = '\u0626\u06C7';
+        t['\uFBF2'] = '\u0626\u06C6';
+        t['\uFBF3'] = '\u0626\u06C6';
+        t['\uFBF4'] = '\u0626\u06C8';
+        t['\uFBF5'] = '\u0626\u06C8';
+        t['\uFBF6'] = '\u0626\u06D0';
+        t['\uFBF7'] = '\u0626\u06D0';
+        t['\uFBF8'] = '\u0626\u06D0';
+        t['\uFBF9'] = '\u0626\u0649';
+        t['\uFBFA'] = '\u0626\u0649';
+        t['\uFBFB'] = '\u0626\u0649';
+        t['\uFBFC'] = '\u06CC';
+        t['\uFBFD'] = '\u06CC';
+        t['\uFBFE'] = '\u06CC';
+        t['\uFBFF'] = '\u06CC';
+        t['\uFC00'] = '\u0626\u062C';
+        t['\uFC01'] = '\u0626\u062D';
+        t['\uFC02'] = '\u0626\u0645';
+        t['\uFC03'] = '\u0626\u0649';
+        t['\uFC04'] = '\u0626\u064A';
+        t['\uFC05'] = '\u0628\u062C';
+        t['\uFC06'] = '\u0628\u062D';
+        t['\uFC07'] = '\u0628\u062E';
+        t['\uFC08'] = '\u0628\u0645';
+        t['\uFC09'] = '\u0628\u0649';
+        t['\uFC0A'] = '\u0628\u064A';
+        t['\uFC0B'] = '\u062A\u062C';
+        t['\uFC0C'] = '\u062A\u062D';
+        t['\uFC0D'] = '\u062A\u062E';
+        t['\uFC0E'] = '\u062A\u0645';
+        t['\uFC0F'] = '\u062A\u0649';
+        t['\uFC10'] = '\u062A\u064A';
+        t['\uFC11'] = '\u062B\u062C';
+        t['\uFC12'] = '\u062B\u0645';
+        t['\uFC13'] = '\u062B\u0649';
+        t['\uFC14'] = '\u062B\u064A';
+        t['\uFC15'] = '\u062C\u062D';
+        t['\uFC16'] = '\u062C\u0645';
+        t['\uFC17'] = '\u062D\u062C';
+        t['\uFC18'] = '\u062D\u0645';
+        t['\uFC19'] = '\u062E\u062C';
+        t['\uFC1A'] = '\u062E\u062D';
+        t['\uFC1B'] = '\u062E\u0645';
+        t['\uFC1C'] = '\u0633\u062C';
+        t['\uFC1D'] = '\u0633\u062D';
+        t['\uFC1E'] = '\u0633\u062E';
+        t['\uFC1F'] = '\u0633\u0645';
+        t['\uFC20'] = '\u0635\u062D';
+        t['\uFC21'] = '\u0635\u0645';
+        t['\uFC22'] = '\u0636\u062C';
+        t['\uFC23'] = '\u0636\u062D';
+        t['\uFC24'] = '\u0636\u062E';
+        t['\uFC25'] = '\u0636\u0645';
+        t['\uFC26'] = '\u0637\u062D';
+        t['\uFC27'] = '\u0637\u0645';
+        t['\uFC28'] = '\u0638\u0645';
+        t['\uFC29'] = '\u0639\u062C';
+        t['\uFC2A'] = '\u0639\u0645';
+        t['\uFC2B'] = '\u063A\u062C';
+        t['\uFC2C'] = '\u063A\u0645';
+        t['\uFC2D'] = '\u0641\u062C';
+        t['\uFC2E'] = '\u0641\u062D';
+        t['\uFC2F'] = '\u0641\u062E';
+        t['\uFC30'] = '\u0641\u0645';
+        t['\uFC31'] = '\u0641\u0649';
+        t['\uFC32'] = '\u0641\u064A';
+        t['\uFC33'] = '\u0642\u062D';
+        t['\uFC34'] = '\u0642\u0645';
+        t['\uFC35'] = '\u0642\u0649';
+        t['\uFC36'] = '\u0642\u064A';
+        t['\uFC37'] = '\u0643\u0627';
+        t['\uFC38'] = '\u0643\u062C';
+        t['\uFC39'] = '\u0643\u062D';
+        t['\uFC3A'] = '\u0643\u062E';
+        t['\uFC3B'] = '\u0643\u0644';
+        t['\uFC3C'] = '\u0643\u0645';
+        t['\uFC3D'] = '\u0643\u0649';
+        t['\uFC3E'] = '\u0643\u064A';
+        t['\uFC3F'] = '\u0644\u062C';
+        t['\uFC40'] = '\u0644\u062D';
+        t['\uFC41'] = '\u0644\u062E';
+        t['\uFC42'] = '\u0644\u0645';
+        t['\uFC43'] = '\u0644\u0649';
+        t['\uFC44'] = '\u0644\u064A';
+        t['\uFC45'] = '\u0645\u062C';
+        t['\uFC46'] = '\u0645\u062D';
+        t['\uFC47'] = '\u0645\u062E';
+        t['\uFC48'] = '\u0645\u0645';
+        t['\uFC49'] = '\u0645\u0649';
+        t['\uFC4A'] = '\u0645\u064A';
+        t['\uFC4B'] = '\u0646\u062C';
+        t['\uFC4C'] = '\u0646\u062D';
+        t['\uFC4D'] = '\u0646\u062E';
+        t['\uFC4E'] = '\u0646\u0645';
+        t['\uFC4F'] = '\u0646\u0649';
+        t['\uFC50'] = '\u0646\u064A';
+        t['\uFC51'] = '\u0647\u062C';
+        t['\uFC52'] = '\u0647\u0645';
+        t['\uFC53'] = '\u0647\u0649';
+        t['\uFC54'] = '\u0647\u064A';
+        t['\uFC55'] = '\u064A\u062C';
+        t['\uFC56'] = '\u064A\u062D';
+        t['\uFC57'] = '\u064A\u062E';
+        t['\uFC58'] = '\u064A\u0645';
+        t['\uFC59'] = '\u064A\u0649';
+        t['\uFC5A'] = '\u064A\u064A';
+        t['\uFC5B'] = '\u0630\u0670';
+        t['\uFC5C'] = '\u0631\u0670';
+        t['\uFC5D'] = '\u0649\u0670';
+        t['\uFC5E'] = '\u0020\u064C\u0651';
+        t['\uFC5F'] = '\u0020\u064D\u0651';
+        t['\uFC60'] = '\u0020\u064E\u0651';
+        t['\uFC61'] = '\u0020\u064F\u0651';
+        t['\uFC62'] = '\u0020\u0650\u0651';
+        t['\uFC63'] = '\u0020\u0651\u0670';
+        t['\uFC64'] = '\u0626\u0631';
+        t['\uFC65'] = '\u0626\u0632';
+        t['\uFC66'] = '\u0626\u0645';
+        t['\uFC67'] = '\u0626\u0646';
+        t['\uFC68'] = '\u0626\u0649';
+        t['\uFC69'] = '\u0626\u064A';
+        t['\uFC6A'] = '\u0628\u0631';
+        t['\uFC6B'] = '\u0628\u0632';
+        t['\uFC6C'] = '\u0628\u0645';
+        t['\uFC6D'] = '\u0628\u0646';
+        t['\uFC6E'] = '\u0628\u0649';
+        t['\uFC6F'] = '\u0628\u064A';
+        t['\uFC70'] = '\u062A\u0631';
+        t['\uFC71'] = '\u062A\u0632';
+        t['\uFC72'] = '\u062A\u0645';
+        t['\uFC73'] = '\u062A\u0646';
+        t['\uFC74'] = '\u062A\u0649';
+        t['\uFC75'] = '\u062A\u064A';
+        t['\uFC76'] = '\u062B\u0631';
+        t['\uFC77'] = '\u062B\u0632';
+        t['\uFC78'] = '\u062B\u0645';
+        t['\uFC79'] = '\u062B\u0646';
+        t['\uFC7A'] = '\u062B\u0649';
+        t['\uFC7B'] = '\u062B\u064A';
+        t['\uFC7C'] = '\u0641\u0649';
+        t['\uFC7D'] = '\u0641\u064A';
+        t['\uFC7E'] = '\u0642\u0649';
+        t['\uFC7F'] = '\u0642\u064A';
+        t['\uFC80'] = '\u0643\u0627';
+        t['\uFC81'] = '\u0643\u0644';
+        t['\uFC82'] = '\u0643\u0645';
+        t['\uFC83'] = '\u0643\u0649';
+        t['\uFC84'] = '\u0643\u064A';
+        t['\uFC85'] = '\u0644\u0645';
+        t['\uFC86'] = '\u0644\u0649';
+        t['\uFC87'] = '\u0644\u064A';
+        t['\uFC88'] = '\u0645\u0627';
+        t['\uFC89'] = '\u0645\u0645';
+        t['\uFC8A'] = '\u0646\u0631';
+        t['\uFC8B'] = '\u0646\u0632';
+        t['\uFC8C'] = '\u0646\u0645';
+        t['\uFC8D'] = '\u0646\u0646';
+        t['\uFC8E'] = '\u0646\u0649';
+        t['\uFC8F'] = '\u0646\u064A';
+        t['\uFC90'] = '\u0649\u0670';
+        t['\uFC91'] = '\u064A\u0631';
+        t['\uFC92'] = '\u064A\u0632';
+        t['\uFC93'] = '\u064A\u0645';
+        t['\uFC94'] = '\u064A\u0646';
+        t['\uFC95'] = '\u064A\u0649';
+        t['\uFC96'] = '\u064A\u064A';
+        t['\uFC97'] = '\u0626\u062C';
+        t['\uFC98'] = '\u0626\u062D';
+        t['\uFC99'] = '\u0626\u062E';
+        t['\uFC9A'] = '\u0626\u0645';
+        t['\uFC9B'] = '\u0626\u0647';
+        t['\uFC9C'] = '\u0628\u062C';
+        t['\uFC9D'] = '\u0628\u062D';
+        t['\uFC9E'] = '\u0628\u062E';
+        t['\uFC9F'] = '\u0628\u0645';
+        t['\uFCA0'] = '\u0628\u0647';
+        t['\uFCA1'] = '\u062A\u062C';
+        t['\uFCA2'] = '\u062A\u062D';
+        t['\uFCA3'] = '\u062A\u062E';
+        t['\uFCA4'] = '\u062A\u0645';
+        t['\uFCA5'] = '\u062A\u0647';
+        t['\uFCA6'] = '\u062B\u0645';
+        t['\uFCA7'] = '\u062C\u062D';
+        t['\uFCA8'] = '\u062C\u0645';
+        t['\uFCA9'] = '\u062D\u062C';
+        t['\uFCAA'] = '\u062D\u0645';
+        t['\uFCAB'] = '\u062E\u062C';
+        t['\uFCAC'] = '\u062E\u0645';
+        t['\uFCAD'] = '\u0633\u062C';
+        t['\uFCAE'] = '\u0633\u062D';
+        t['\uFCAF'] = '\u0633\u062E';
+        t['\uFCB0'] = '\u0633\u0645';
+        t['\uFCB1'] = '\u0635\u062D';
+        t['\uFCB2'] = '\u0635\u062E';
+        t['\uFCB3'] = '\u0635\u0645';
+        t['\uFCB4'] = '\u0636\u062C';
+        t['\uFCB5'] = '\u0636\u062D';
+        t['\uFCB6'] = '\u0636\u062E';
+        t['\uFCB7'] = '\u0636\u0645';
+        t['\uFCB8'] = '\u0637\u062D';
+        t['\uFCB9'] = '\u0638\u0645';
+        t['\uFCBA'] = '\u0639\u062C';
+        t['\uFCBB'] = '\u0639\u0645';
+        t['\uFCBC'] = '\u063A\u062C';
+        t['\uFCBD'] = '\u063A\u0645';
+        t['\uFCBE'] = '\u0641\u062C';
+        t['\uFCBF'] = '\u0641\u062D';
+        t['\uFCC0'] = '\u0641\u062E';
+        t['\uFCC1'] = '\u0641\u0645';
+        t['\uFCC2'] = '\u0642\u062D';
+        t['\uFCC3'] = '\u0642\u0645';
+        t['\uFCC4'] = '\u0643\u062C';
+        t['\uFCC5'] = '\u0643\u062D';
+        t['\uFCC6'] = '\u0643\u062E';
+        t['\uFCC7'] = '\u0643\u0644';
+        t['\uFCC8'] = '\u0643\u0645';
+        t['\uFCC9'] = '\u0644\u062C';
+        t['\uFCCA'] = '\u0644\u062D';
+        t['\uFCCB'] = '\u0644\u062E';
+        t['\uFCCC'] = '\u0644\u0645';
+        t['\uFCCD'] = '\u0644\u0647';
+        t['\uFCCE'] = '\u0645\u062C';
+        t['\uFCCF'] = '\u0645\u062D';
+        t['\uFCD0'] = '\u0645\u062E';
+        t['\uFCD1'] = '\u0645\u0645';
+        t['\uFCD2'] = '\u0646\u062C';
+        t['\uFCD3'] = '\u0646\u062D';
+        t['\uFCD4'] = '\u0646\u062E';
+        t['\uFCD5'] = '\u0646\u0645';
+        t['\uFCD6'] = '\u0646\u0647';
+        t['\uFCD7'] = '\u0647\u062C';
+        t['\uFCD8'] = '\u0647\u0645';
+        t['\uFCD9'] = '\u0647\u0670';
+        t['\uFCDA'] = '\u064A\u062C';
+        t['\uFCDB'] = '\u064A\u062D';
+        t['\uFCDC'] = '\u064A\u062E';
+        t['\uFCDD'] = '\u064A\u0645';
+        t['\uFCDE'] = '\u064A\u0647';
+        t['\uFCDF'] = '\u0626\u0645';
+        t['\uFCE0'] = '\u0626\u0647';
+        t['\uFCE1'] = '\u0628\u0645';
+        t['\uFCE2'] = '\u0628\u0647';
+        t['\uFCE3'] = '\u062A\u0645';
+        t['\uFCE4'] = '\u062A\u0647';
+        t['\uFCE5'] = '\u062B\u0645';
+        t['\uFCE6'] = '\u062B\u0647';
+        t['\uFCE7'] = '\u0633\u0645';
+        t['\uFCE8'] = '\u0633\u0647';
+        t['\uFCE9'] = '\u0634\u0645';
+        t['\uFCEA'] = '\u0634\u0647';
+        t['\uFCEB'] = '\u0643\u0644';
+        t['\uFCEC'] = '\u0643\u0645';
+        t['\uFCED'] = '\u0644\u0645';
+        t['\uFCEE'] = '\u0646\u0645';
+        t['\uFCEF'] = '\u0646\u0647';
+        t['\uFCF0'] = '\u064A\u0645';
+        t['\uFCF1'] = '\u064A\u0647';
+        t['\uFCF2'] = '\u0640\u064E\u0651';
+        t['\uFCF3'] = '\u0640\u064F\u0651';
+        t['\uFCF4'] = '\u0640\u0650\u0651';
+        t['\uFCF5'] = '\u0637\u0649';
+        t['\uFCF6'] = '\u0637\u064A';
+        t['\uFCF7'] = '\u0639\u0649';
+        t['\uFCF8'] = '\u0639\u064A';
+        t['\uFCF9'] = '\u063A\u0649';
+        t['\uFCFA'] = '\u063A\u064A';
+        t['\uFCFB'] = '\u0633\u0649';
+        t['\uFCFC'] = '\u0633\u064A';
+        t['\uFCFD'] = '\u0634\u0649';
+        t['\uFCFE'] = '\u0634\u064A';
+        t['\uFCFF'] = '\u062D\u0649';
+        t['\uFD00'] = '\u062D\u064A';
+        t['\uFD01'] = '\u062C\u0649';
+        t['\uFD02'] = '\u062C\u064A';
+        t['\uFD03'] = '\u062E\u0649';
+        t['\uFD04'] = '\u062E\u064A';
+        t['\uFD05'] = '\u0635\u0649';
+        t['\uFD06'] = '\u0635\u064A';
+        t['\uFD07'] = '\u0636\u0649';
+        t['\uFD08'] = '\u0636\u064A';
+        t['\uFD09'] = '\u0634\u062C';
+        t['\uFD0A'] = '\u0634\u062D';
+        t['\uFD0B'] = '\u0634\u062E';
+        t['\uFD0C'] = '\u0634\u0645';
+        t['\uFD0D'] = '\u0634\u0631';
+        t['\uFD0E'] = '\u0633\u0631';
+        t['\uFD0F'] = '\u0635\u0631';
+        t['\uFD10'] = '\u0636\u0631';
+        t['\uFD11'] = '\u0637\u0649';
+        t['\uFD12'] = '\u0637\u064A';
+        t['\uFD13'] = '\u0639\u0649';
+        t['\uFD14'] = '\u0639\u064A';
+        t['\uFD15'] = '\u063A\u0649';
+        t['\uFD16'] = '\u063A\u064A';
+        t['\uFD17'] = '\u0633\u0649';
+        t['\uFD18'] = '\u0633\u064A';
+        t['\uFD19'] = '\u0634\u0649';
+        t['\uFD1A'] = '\u0634\u064A';
+        t['\uFD1B'] = '\u062D\u0649';
+        t['\uFD1C'] = '\u062D\u064A';
+        t['\uFD1D'] = '\u062C\u0649';
+        t['\uFD1E'] = '\u062C\u064A';
+        t['\uFD1F'] = '\u062E\u0649';
+        t['\uFD20'] = '\u062E\u064A';
+        t['\uFD21'] = '\u0635\u0649';
+        t['\uFD22'] = '\u0635\u064A';
+        t['\uFD23'] = '\u0636\u0649';
+        t['\uFD24'] = '\u0636\u064A';
+        t['\uFD25'] = '\u0634\u062C';
+        t['\uFD26'] = '\u0634\u062D';
+        t['\uFD27'] = '\u0634\u062E';
+        t['\uFD28'] = '\u0634\u0645';
+        t['\uFD29'] = '\u0634\u0631';
+        t['\uFD2A'] = '\u0633\u0631';
+        t['\uFD2B'] = '\u0635\u0631';
+        t['\uFD2C'] = '\u0636\u0631';
+        t['\uFD2D'] = '\u0634\u062C';
+        t['\uFD2E'] = '\u0634\u062D';
+        t['\uFD2F'] = '\u0634\u062E';
+        t['\uFD30'] = '\u0634\u0645';
+        t['\uFD31'] = '\u0633\u0647';
+        t['\uFD32'] = '\u0634\u0647';
+        t['\uFD33'] = '\u0637\u0645';
+        t['\uFD34'] = '\u0633\u062C';
+        t['\uFD35'] = '\u0633\u062D';
+        t['\uFD36'] = '\u0633\u062E';
+        t['\uFD37'] = '\u0634\u062C';
+        t['\uFD38'] = '\u0634\u062D';
+        t['\uFD39'] = '\u0634\u062E';
+        t['\uFD3A'] = '\u0637\u0645';
+        t['\uFD3B'] = '\u0638\u0645';
+        t['\uFD3C'] = '\u0627\u064B';
+        t['\uFD3D'] = '\u0627\u064B';
+        t['\uFD50'] = '\u062A\u062C\u0645';
+        t['\uFD51'] = '\u062A\u062D\u062C';
+        t['\uFD52'] = '\u062A\u062D\u062C';
+        t['\uFD53'] = '\u062A\u062D\u0645';
+        t['\uFD54'] = '\u062A\u062E\u0645';
+        t['\uFD55'] = '\u062A\u0645\u062C';
+        t['\uFD56'] = '\u062A\u0645\u062D';
+        t['\uFD57'] = '\u062A\u0645\u062E';
+        t['\uFD58'] = '\u062C\u0645\u062D';
+        t['\uFD59'] = '\u062C\u0645\u062D';
+        t['\uFD5A'] = '\u062D\u0645\u064A';
+        t['\uFD5B'] = '\u062D\u0645\u0649';
+        t['\uFD5C'] = '\u0633\u062D\u062C';
+        t['\uFD5D'] = '\u0633\u062C\u062D';
+        t['\uFD5E'] = '\u0633\u062C\u0649';
+        t['\uFD5F'] = '\u0633\u0645\u062D';
+        t['\uFD60'] = '\u0633\u0645\u062D';
+        t['\uFD61'] = '\u0633\u0645\u062C';
+        t['\uFD62'] = '\u0633\u0645\u0645';
+        t['\uFD63'] = '\u0633\u0645\u0645';
+        t['\uFD64'] = '\u0635\u062D\u062D';
+        t['\uFD65'] = '\u0635\u062D\u062D';
+        t['\uFD66'] = '\u0635\u0645\u0645';
+        t['\uFD67'] = '\u0634\u062D\u0645';
+        t['\uFD68'] = '\u0634\u062D\u0645';
+        t['\uFD69'] = '\u0634\u062C\u064A';
+        t['\uFD6A'] = '\u0634\u0645\u062E';
+        t['\uFD6B'] = '\u0634\u0645\u062E';
+        t['\uFD6C'] = '\u0634\u0645\u0645';
+        t['\uFD6D'] = '\u0634\u0645\u0645';
+        t['\uFD6E'] = '\u0636\u062D\u0649';
+        t['\uFD6F'] = '\u0636\u062E\u0645';
+        t['\uFD70'] = '\u0636\u062E\u0645';
+        t['\uFD71'] = '\u0637\u0645\u062D';
+        t['\uFD72'] = '\u0637\u0645\u062D';
+        t['\uFD73'] = '\u0637\u0645\u0645';
+        t['\uFD74'] = '\u0637\u0645\u064A';
+        t['\uFD75'] = '\u0639\u062C\u0645';
+        t['\uFD76'] = '\u0639\u0645\u0645';
+        t['\uFD77'] = '\u0639\u0645\u0645';
+        t['\uFD78'] = '\u0639\u0645\u0649';
+        t['\uFD79'] = '\u063A\u0645\u0645';
+        t['\uFD7A'] = '\u063A\u0645\u064A';
+        t['\uFD7B'] = '\u063A\u0645\u0649';
+        t['\uFD7C'] = '\u0641\u062E\u0645';
+        t['\uFD7D'] = '\u0641\u062E\u0645';
+        t['\uFD7E'] = '\u0642\u0645\u062D';
+        t['\uFD7F'] = '\u0642\u0645\u0645';
+        t['\uFD80'] = '\u0644\u062D\u0645';
+        t['\uFD81'] = '\u0644\u062D\u064A';
+        t['\uFD82'] = '\u0644\u062D\u0649';
+        t['\uFD83'] = '\u0644\u062C\u062C';
+        t['\uFD84'] = '\u0644\u062C\u062C';
+        t['\uFD85'] = '\u0644\u062E\u0645';
+        t['\uFD86'] = '\u0644\u062E\u0645';
+        t['\uFD87'] = '\u0644\u0645\u062D';
+        t['\uFD88'] = '\u0644\u0645\u062D';
+        t['\uFD89'] = '\u0645\u062D\u062C';
+        t['\uFD8A'] = '\u0645\u062D\u0645';
+        t['\uFD8B'] = '\u0645\u062D\u064A';
+        t['\uFD8C'] = '\u0645\u062C\u062D';
+        t['\uFD8D'] = '\u0645\u062C\u0645';
+        t['\uFD8E'] = '\u0645\u062E\u062C';
+        t['\uFD8F'] = '\u0645\u062E\u0645';
+        t['\uFD92'] = '\u0645\u062C\u062E';
+        t['\uFD93'] = '\u0647\u0645\u062C';
+        t['\uFD94'] = '\u0647\u0645\u0645';
+        t['\uFD95'] = '\u0646\u062D\u0645';
+        t['\uFD96'] = '\u0646\u062D\u0649';
+        t['\uFD97'] = '\u0646\u062C\u0645';
+        t['\uFD98'] = '\u0646\u062C\u0645';
+        t['\uFD99'] = '\u0646\u062C\u0649';
+        t['\uFD9A'] = '\u0646\u0645\u064A';
+        t['\uFD9B'] = '\u0646\u0645\u0649';
+        t['\uFD9C'] = '\u064A\u0645\u0645';
+        t['\uFD9D'] = '\u064A\u0645\u0645';
+        t['\uFD9E'] = '\u0628\u062E\u064A';
+        t['\uFD9F'] = '\u062A\u062C\u064A';
+        t['\uFDA0'] = '\u062A\u062C\u0649';
+        t['\uFDA1'] = '\u062A\u062E\u064A';
+        t['\uFDA2'] = '\u062A\u062E\u0649';
+        t['\uFDA3'] = '\u062A\u0645\u064A';
+        t['\uFDA4'] = '\u062A\u0645\u0649';
+        t['\uFDA5'] = '\u062C\u0645\u064A';
+        t['\uFDA6'] = '\u062C\u062D\u0649';
+        t['\uFDA7'] = '\u062C\u0645\u0649';
+        t['\uFDA8'] = '\u0633\u062E\u0649';
+        t['\uFDA9'] = '\u0635\u062D\u064A';
+        t['\uFDAA'] = '\u0634\u062D\u064A';
+        t['\uFDAB'] = '\u0636\u062D\u064A';
+        t['\uFDAC'] = '\u0644\u062C\u064A';
+        t['\uFDAD'] = '\u0644\u0645\u064A';
+        t['\uFDAE'] = '\u064A\u062D\u064A';
+        t['\uFDAF'] = '\u064A\u062C\u064A';
+        t['\uFDB0'] = '\u064A\u0645\u064A';
+        t['\uFDB1'] = '\u0645\u0645\u064A';
+        t['\uFDB2'] = '\u0642\u0645\u064A';
+        t['\uFDB3'] = '\u0646\u062D\u064A';
+        t['\uFDB4'] = '\u0642\u0645\u062D';
+        t['\uFDB5'] = '\u0644\u062D\u0645';
+        t['\uFDB6'] = '\u0639\u0645\u064A';
+        t['\uFDB7'] = '\u0643\u0645\u064A';
+        t['\uFDB8'] = '\u0646\u062C\u062D';
+        t['\uFDB9'] = '\u0645\u062E\u064A';
+        t['\uFDBA'] = '\u0644\u062C\u0645';
+        t['\uFDBB'] = '\u0643\u0645\u0645';
+        t['\uFDBC'] = '\u0644\u062C\u0645';
+        t['\uFDBD'] = '\u0646\u062C\u062D';
+        t['\uFDBE'] = '\u062C\u062D\u064A';
+        t['\uFDBF'] = '\u062D\u062C\u064A';
+        t['\uFDC0'] = '\u0645\u062C\u064A';
+        t['\uFDC1'] = '\u0641\u0645\u064A';
+        t['\uFDC2'] = '\u0628\u062D\u064A';
+        t['\uFDC3'] = '\u0643\u0645\u0645';
+        t['\uFDC4'] = '\u0639\u062C\u0645';
+        t['\uFDC5'] = '\u0635\u0645\u0645';
+        t['\uFDC6'] = '\u0633\u062E\u064A';
+        t['\uFDC7'] = '\u0646\u062C\u064A';
+        t['\uFE49'] = '\u203E';
+        t['\uFE4A'] = '\u203E';
+        t['\uFE4B'] = '\u203E';
+        t['\uFE4C'] = '\u203E';
+        t['\uFE4D'] = '\u005F';
+        t['\uFE4E'] = '\u005F';
+        t['\uFE4F'] = '\u005F';
+        t['\uFE80'] = '\u0621';
+        t['\uFE81'] = '\u0622';
+        t['\uFE82'] = '\u0622';
+        t['\uFE83'] = '\u0623';
+        t['\uFE84'] = '\u0623';
+        t['\uFE85'] = '\u0624';
+        t['\uFE86'] = '\u0624';
+        t['\uFE87'] = '\u0625';
+        t['\uFE88'] = '\u0625';
+        t['\uFE89'] = '\u0626';
+        t['\uFE8A'] = '\u0626';
+        t['\uFE8B'] = '\u0626';
+        t['\uFE8C'] = '\u0626';
+        t['\uFE8D'] = '\u0627';
+        t['\uFE8E'] = '\u0627';
+        t['\uFE8F'] = '\u0628';
+        t['\uFE90'] = '\u0628';
+        t['\uFE91'] = '\u0628';
+        t['\uFE92'] = '\u0628';
+        t['\uFE93'] = '\u0629';
+        t['\uFE94'] = '\u0629';
+        t['\uFE95'] = '\u062A';
+        t['\uFE96'] = '\u062A';
+        t['\uFE97'] = '\u062A';
+        t['\uFE98'] = '\u062A';
+        t['\uFE99'] = '\u062B';
+        t['\uFE9A'] = '\u062B';
+        t['\uFE9B'] = '\u062B';
+        t['\uFE9C'] = '\u062B';
+        t['\uFE9D'] = '\u062C';
+        t['\uFE9E'] = '\u062C';
+        t['\uFE9F'] = '\u062C';
+        t['\uFEA0'] = '\u062C';
+        t['\uFEA1'] = '\u062D';
+        t['\uFEA2'] = '\u062D';
+        t['\uFEA3'] = '\u062D';
+        t['\uFEA4'] = '\u062D';
+        t['\uFEA5'] = '\u062E';
+        t['\uFEA6'] = '\u062E';
+        t['\uFEA7'] = '\u062E';
+        t['\uFEA8'] = '\u062E';
+        t['\uFEA9'] = '\u062F';
+        t['\uFEAA'] = '\u062F';
+        t['\uFEAB'] = '\u0630';
+        t['\uFEAC'] = '\u0630';
+        t['\uFEAD'] = '\u0631';
+        t['\uFEAE'] = '\u0631';
+        t['\uFEAF'] = '\u0632';
+        t['\uFEB0'] = '\u0632';
+        t['\uFEB1'] = '\u0633';
+        t['\uFEB2'] = '\u0633';
+        t['\uFEB3'] = '\u0633';
+        t['\uFEB4'] = '\u0633';
+        t['\uFEB5'] = '\u0634';
+        t['\uFEB6'] = '\u0634';
+        t['\uFEB7'] = '\u0634';
+        t['\uFEB8'] = '\u0634';
+        t['\uFEB9'] = '\u0635';
+        t['\uFEBA'] = '\u0635';
+        t['\uFEBB'] = '\u0635';
+        t['\uFEBC'] = '\u0635';
+        t['\uFEBD'] = '\u0636';
+        t['\uFEBE'] = '\u0636';
+        t['\uFEBF'] = '\u0636';
+        t['\uFEC0'] = '\u0636';
+        t['\uFEC1'] = '\u0637';
+        t['\uFEC2'] = '\u0637';
+        t['\uFEC3'] = '\u0637';
+        t['\uFEC4'] = '\u0637';
+        t['\uFEC5'] = '\u0638';
+        t['\uFEC6'] = '\u0638';
+        t['\uFEC7'] = '\u0638';
+        t['\uFEC8'] = '\u0638';
+        t['\uFEC9'] = '\u0639';
+        t['\uFECA'] = '\u0639';
+        t['\uFECB'] = '\u0639';
+        t['\uFECC'] = '\u0639';
+        t['\uFECD'] = '\u063A';
+        t['\uFECE'] = '\u063A';
+        t['\uFECF'] = '\u063A';
+        t['\uFED0'] = '\u063A';
+        t['\uFED1'] = '\u0641';
+        t['\uFED2'] = '\u0641';
+        t['\uFED3'] = '\u0641';
+        t['\uFED4'] = '\u0641';
+        t['\uFED5'] = '\u0642';
+        t['\uFED6'] = '\u0642';
+        t['\uFED7'] = '\u0642';
+        t['\uFED8'] = '\u0642';
+        t['\uFED9'] = '\u0643';
+        t['\uFEDA'] = '\u0643';
+        t['\uFEDB'] = '\u0643';
+        t['\uFEDC'] = '\u0643';
+        t['\uFEDD'] = '\u0644';
+        t['\uFEDE'] = '\u0644';
+        t['\uFEDF'] = '\u0644';
+        t['\uFEE0'] = '\u0644';
+        t['\uFEE1'] = '\u0645';
+        t['\uFEE2'] = '\u0645';
+        t['\uFEE3'] = '\u0645';
+        t['\uFEE4'] = '\u0645';
+        t['\uFEE5'] = '\u0646';
+        t['\uFEE6'] = '\u0646';
+        t['\uFEE7'] = '\u0646';
+        t['\uFEE8'] = '\u0646';
+        t['\uFEE9'] = '\u0647';
+        t['\uFEEA'] = '\u0647';
+        t['\uFEEB'] = '\u0647';
+        t['\uFEEC'] = '\u0647';
+        t['\uFEED'] = '\u0648';
+        t['\uFEEE'] = '\u0648';
+        t['\uFEEF'] = '\u0649';
+        t['\uFEF0'] = '\u0649';
+        t['\uFEF1'] = '\u064A';
+        t['\uFEF2'] = '\u064A';
+        t['\uFEF3'] = '\u064A';
+        t['\uFEF4'] = '\u064A';
+        t['\uFEF5'] = '\u0644\u0622';
+        t['\uFEF6'] = '\u0644\u0622';
+        t['\uFEF7'] = '\u0644\u0623';
+        t['\uFEF8'] = '\u0644\u0623';
+        t['\uFEF9'] = '\u0644\u0625';
+        t['\uFEFA'] = '\u0644\u0625';
+        t['\uFEFB'] = '\u0644\u0627';
+        t['\uFEFC'] = '\u0644\u0627';
+      });
+      function reverseIfRtl(chars) {
+        var charsLength = chars.length;
+        //reverse an arabic ligature
+        if (charsLength <= 1 || !isRTLRangeFor(chars.charCodeAt(0))) {
+          return chars;
+        }
+        var s = '';
+        for (var ii = charsLength - 1; ii >= 0; ii--) {
+          s += chars[ii];
+        }
+        return s;
+      }
+      exports.mapSpecialUnicodeValues = mapSpecialUnicodeValues;
+      exports.reverseIfRtl = reverseIfRtl;
+      exports.getUnicodeRangeFor = getUnicodeRangeFor;
+      exports.getNormalizedUnicodes = getNormalizedUnicodes;
+      exports.getUnicodeForGlyph = getUnicodeForGlyph;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreStream = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreJbig2, root.pdfjsCoreJpg, root.pdfjsCoreJpx);
+    }(this, function (exports, sharedUtil, corePrimitives, coreJbig2, coreJpg, coreJpx) {
+      var Util = sharedUtil.Util;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isInt = sharedUtil.isInt;
+      var isArray = sharedUtil.isArray;
+      var createObjectURL = sharedUtil.createObjectURL;
+      var shadow = sharedUtil.shadow;
+      var warn = sharedUtil.warn;
+      var isSpace = sharedUtil.isSpace;
+      var Dict = corePrimitives.Dict;
+      var isDict = corePrimitives.isDict;
+      var isStream = corePrimitives.isStream;
+      var Jbig2Image = coreJbig2.Jbig2Image;
+      var JpegImage = coreJpg.JpegImage;
+      var JpxImage = coreJpx.JpxImage;
+      var Stream = function StreamClosure() {
+        function Stream(arrayBuffer, start, length, dict) {
+          this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
+          this.start = start || 0;
+          this.pos = this.start;
+          this.end = start + length || this.bytes.length;
+          this.dict = dict;
+        }
+        // required methods for a stream. if a particular stream does not
+        // implement these, an error should be thrown
+        Stream.prototype = {
+          get length() {
+            return this.end - this.start;
+          },
+          get isEmpty() {
+            return this.length === 0;
+          },
+          getByte: function Stream_getByte() {
+            if (this.pos >= this.end) {
+              return -1;
+            }
+            return this.bytes[this.pos++];
+          },
+          getUint16: function Stream_getUint16() {
+            var b0 = this.getByte();
+            var b1 = this.getByte();
+            if (b0 === -1 || b1 === -1) {
+              return -1;
+            }
+            return (b0 << 8) + b1;
+          },
+          getInt32: function Stream_getInt32() {
+            var b0 = this.getByte();
+            var b1 = this.getByte();
+            var b2 = this.getByte();
+            var b3 = this.getByte();
+            return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+          },
+          // returns subarray of original buffer
+          // should only be read
+          getBytes: function Stream_getBytes(length) {
+            var bytes = this.bytes;
+            var pos = this.pos;
+            var strEnd = this.end;
+            if (!length) {
+              return bytes.subarray(pos, strEnd);
+            }
+            var end = pos + length;
+            if (end > strEnd) {
+              end = strEnd;
+            }
+            this.pos = end;
+            return bytes.subarray(pos, end);
+          },
+          peekByte: function Stream_peekByte() {
+            var peekedByte = this.getByte();
+            this.pos--;
+            return peekedByte;
+          },
+          peekBytes: function Stream_peekBytes(length) {
+            var bytes = this.getBytes(length);
+            this.pos -= bytes.length;
+            return bytes;
+          },
+          skip: function Stream_skip(n) {
+            if (!n) {
+              n = 1;
+            }
+            this.pos += n;
+          },
+          reset: function Stream_reset() {
+            this.pos = this.start;
+          },
+          moveStart: function Stream_moveStart() {
+            this.start = this.pos;
+          },
+          makeSubStream: function Stream_makeSubStream(start, length, dict) {
+            return new Stream(this.bytes.buffer, start, length, dict);
+          },
+          isStream: true
+        };
+        return Stream;
+      }();
+      var StringStream = function StringStreamClosure() {
+        function StringStream(str) {
+          var length = str.length;
+          var bytes = new Uint8Array(length);
+          for (var n = 0; n < length; ++n) {
+            bytes[n] = str.charCodeAt(n);
+          }
+          Stream.call(this, bytes);
+        }
+        StringStream.prototype = Stream.prototype;
+        return StringStream;
+      }();
+      // super class for the decoding streams
+      var DecodeStream = function DecodeStreamClosure() {
+        // Lots of DecodeStreams are created whose buffers are never used.  For these
+        // we share a single empty buffer. This is (a) space-efficient and (b) avoids
+        // having special cases that would be required if we used |null| for an empty
+        // buffer.
+        var emptyBuffer = new Uint8Array(0);
+        function DecodeStream(maybeMinBufferLength) {
+          this.pos = 0;
+          this.bufferLength = 0;
+          this.eof = false;
+          this.buffer = emptyBuffer;
+          this.minBufferLength = 512;
+          if (maybeMinBufferLength) {
+            // Compute the first power of two that is as big as maybeMinBufferLength.
+            while (this.minBufferLength < maybeMinBufferLength) {
+              this.minBufferLength *= 2;
+            }
+          }
+        }
+        DecodeStream.prototype = {
+          get isEmpty() {
+            while (!this.eof && this.bufferLength === 0) {
+              this.readBlock();
+            }
+            return this.bufferLength === 0;
+          },
+          ensureBuffer: function DecodeStream_ensureBuffer(requested) {
+            var buffer = this.buffer;
+            if (requested <= buffer.byteLength) {
+              return buffer;
+            }
+            var size = this.minBufferLength;
+            while (size < requested) {
+              size *= 2;
+            }
+            var buffer2 = new Uint8Array(size);
+            buffer2.set(buffer);
+            return this.buffer = buffer2;
+          },
+          getByte: function DecodeStream_getByte() {
+            var pos = this.pos;
+            while (this.bufferLength <= pos) {
+              if (this.eof) {
+                return -1;
+              }
+              this.readBlock();
+            }
+            return this.buffer[this.pos++];
+          },
+          getUint16: function DecodeStream_getUint16() {
+            var b0 = this.getByte();
+            var b1 = this.getByte();
+            if (b0 === -1 || b1 === -1) {
+              return -1;
+            }
+            return (b0 << 8) + b1;
+          },
+          getInt32: function DecodeStream_getInt32() {
+            var b0 = this.getByte();
+            var b1 = this.getByte();
+            var b2 = this.getByte();
+            var b3 = this.getByte();
+            return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+          },
+          getBytes: function DecodeStream_getBytes(length) {
+            var end, pos = this.pos;
+            if (length) {
+              this.ensureBuffer(pos + length);
+              end = pos + length;
+              while (!this.eof && this.bufferLength < end) {
+                this.readBlock();
+              }
+              var bufEnd = this.bufferLength;
+              if (end > bufEnd) {
+                end = bufEnd;
+              }
+            } else {
+              while (!this.eof) {
+                this.readBlock();
+              }
+              end = this.bufferLength;
+            }
+            this.pos = end;
+            return this.buffer.subarray(pos, end);
+          },
+          peekByte: function DecodeStream_peekByte() {
+            var peekedByte = this.getByte();
+            this.pos--;
+            return peekedByte;
+          },
+          peekBytes: function DecodeStream_peekBytes(length) {
+            var bytes = this.getBytes(length);
+            this.pos -= bytes.length;
+            return bytes;
+          },
+          makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
+            var end = start + length;
+            while (this.bufferLength <= end && !this.eof) {
+              this.readBlock();
+            }
+            return new Stream(this.buffer, start, length, dict);
+          },
+          skip: function DecodeStream_skip(n) {
+            if (!n) {
+              n = 1;
+            }
+            this.pos += n;
+          },
+          reset: function DecodeStream_reset() {
+            this.pos = 0;
+          },
+          getBaseStreams: function DecodeStream_getBaseStreams() {
+            if (this.str && this.str.getBaseStreams) {
+              return this.str.getBaseStreams();
+            }
+            return [];
+          }
+        };
+        return DecodeStream;
+      }();
+      var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
+        function StreamsSequenceStream(streams) {
+          this.streams = streams;
+          DecodeStream.call(this, /* maybeLength = */
+          null);
+        }
+        StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
+        StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
+          var streams = this.streams;
+          if (streams.length === 0) {
+            this.eof = true;
+            return;
+          }
+          var stream = streams.shift();
+          var chunk = stream.getBytes();
+          var bufferLength = this.bufferLength;
+          var newLength = bufferLength + chunk.length;
+          var buffer = this.ensureBuffer(newLength);
+          buffer.set(chunk, bufferLength);
+          this.bufferLength = newLength;
+        };
+        StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
+          var baseStreams = [];
+          for (var i = 0, ii = this.streams.length; i < ii; i++) {
+            var stream = this.streams[i];
+            if (stream.getBaseStreams) {
+              Util.appendToArray(baseStreams, stream.getBaseStreams());
+            }
+          }
+          return baseStreams;
+        };
+        return StreamsSequenceStream;
+      }();
+      var FlateStream = function FlateStreamClosure() {
+        var codeLenCodeMap = new Int32Array([
+          16,
+          17,
+          18,
+          0,
+          8,
+          7,
+          9,
+          6,
+          10,
+          5,
+          11,
+          4,
+          12,
+          3,
+          13,
+          2,
+          14,
+          1,
+          15
+        ]);
+        var lengthDecode = new Int32Array([
+          0x00003,
+          0x00004,
+          0x00005,
+          0x00006,
+          0x00007,
+          0x00008,
+          0x00009,
+          0x0000a,
+          0x1000b,
+          0x1000d,
+          0x1000f,
+          0x10011,
+          0x20013,
+          0x20017,
+          0x2001b,
+          0x2001f,
+          0x30023,
+          0x3002b,
+          0x30033,
+          0x3003b,
+          0x40043,
+          0x40053,
+          0x40063,
+          0x40073,
+          0x50083,
+          0x500a3,
+          0x500c3,
+          0x500e3,
+          0x00102,
+          0x00102,
+          0x00102
+        ]);
+        var distDecode = new Int32Array([
+          0x00001,
+          0x00002,
+          0x00003,
+          0x00004,
+          0x10005,
+          0x10007,
+          0x20009,
+          0x2000d,
+          0x30011,
+          0x30019,
+          0x40021,
+          0x40031,
+          0x50041,
+          0x50061,
+          0x60081,
+          0x600c1,
+          0x70101,
+          0x70181,
+          0x80201,
+          0x80301,
+          0x90401,
+          0x90601,
+          0xa0801,
+          0xa0c01,
+          0xb1001,
+          0xb1801,
+          0xc2001,
+          0xc3001,
+          0xd4001,
+          0xd6001
+        ]);
+        var fixedLitCodeTab = [
+          new Int32Array([
+            0x70100,
+            0x80050,
+            0x80010,
+            0x80118,
+            0x70110,
+            0x80070,
+            0x80030,
+            0x900c0,
+            0x70108,
+            0x80060,
+            0x80020,
+            0x900a0,
+            0x80000,
+            0x80080,
+            0x80040,
+            0x900e0,
+            0x70104,
+            0x80058,
+            0x80018,
+            0x90090,
+            0x70114,
+            0x80078,
+            0x80038,
+            0x900d0,
+            0x7010c,
+            0x80068,
+            0x80028,
+            0x900b0,
+            0x80008,
+            0x80088,
+            0x80048,
+            0x900f0,
+            0x70102,
+            0x80054,
+            0x80014,
+            0x8011c,
+            0x70112,
+            0x80074,
+            0x80034,
+            0x900c8,
+            0x7010a,
+            0x80064,
+            0x80024,
+            0x900a8,
+            0x80004,
+            0x80084,
+            0x80044,
+            0x900e8,
+            0x70106,
+            0x8005c,
+            0x8001c,
+            0x90098,
+            0x70116,
+            0x8007c,
+            0x8003c,
+            0x900d8,
+            0x7010e,
+            0x8006c,
+            0x8002c,
+            0x900b8,
+            0x8000c,
+            0x8008c,
+            0x8004c,
+            0x900f8,
+            0x70101,
+            0x80052,
+            0x80012,
+            0x8011a,
+            0x70111,
+            0x80072,
+            0x80032,
+            0x900c4,
+            0x70109,
+            0x80062,
+            0x80022,
+            0x900a4,
+            0x80002,
+            0x80082,
+            0x80042,
+            0x900e4,
+            0x70105,
+            0x8005a,
+            0x8001a,
+            0x90094,
+            0x70115,
+            0x8007a,
+            0x8003a,
+            0x900d4,
+            0x7010d,
+            0x8006a,
+            0x8002a,
+            0x900b4,
+            0x8000a,
+            0x8008a,
+            0x8004a,
+            0x900f4,
+            0x70103,
+            0x80056,
+            0x80016,
+            0x8011e,
+            0x70113,
+            0x80076,
+            0x80036,
+            0x900cc,
+            0x7010b,
+            0x80066,
+            0x80026,
+            0x900ac,
+            0x80006,
+            0x80086,
+            0x80046,
+            0x900ec,
+            0x70107,
+            0x8005e,
+            0x8001e,
+            0x9009c,
+            0x70117,
+            0x8007e,
+            0x8003e,
+            0x900dc,
+            0x7010f,
+            0x8006e,
+            0x8002e,
+            0x900bc,
+            0x8000e,
+            0x8008e,
+            0x8004e,
+            0x900fc,
+            0x70100,
+            0x80051,
+            0x80011,
+            0x80119,
+            0x70110,
+            0x80071,
+            0x80031,
+            0x900c2,
+            0x70108,
+            0x80061,
+            0x80021,
+            0x900a2,
+            0x80001,
+            0x80081,
+            0x80041,
+            0x900e2,
+            0x70104,
+            0x80059,
+            0x80019,
+            0x90092,
+            0x70114,
+            0x80079,
+            0x80039,
+            0x900d2,
+            0x7010c,
+            0x80069,
+            0x80029,
+            0x900b2,
+            0x80009,
+            0x80089,
+            0x80049,
+            0x900f2,
+            0x70102,
+            0x80055,
+            0x80015,
+            0x8011d,
+            0x70112,
+            0x80075,
+            0x80035,
+            0x900ca,
+            0x7010a,
+            0x80065,
+            0x80025,
+            0x900aa,
+            0x80005,
+            0x80085,
+            0x80045,
+            0x900ea,
+            0x70106,
+            0x8005d,
+            0x8001d,
+            0x9009a,
+            0x70116,
+            0x8007d,
+            0x8003d,
+            0x900da,
+            0x7010e,
+            0x8006d,
+            0x8002d,
+            0x900ba,
+            0x8000d,
+            0x8008d,
+            0x8004d,
+            0x900fa,
+            0x70101,
+            0x80053,
+            0x80013,
+            0x8011b,
+            0x70111,
+            0x80073,
+            0x80033,
+            0x900c6,
+            0x70109,
+            0x80063,
+            0x80023,
+            0x900a6,
+            0x80003,
+            0x80083,
+            0x80043,
+            0x900e6,
+            0x70105,
+            0x8005b,
+            0x8001b,
+            0x90096,
+            0x70115,
+            0x8007b,
+            0x8003b,
+            0x900d6,
+            0x7010d,
+            0x8006b,
+            0x8002b,
+            0x900b6,
+            0x8000b,
+            0x8008b,
+            0x8004b,
+            0x900f6,
+            0x70103,
+            0x80057,
+            0x80017,
+            0x8011f,
+            0x70113,
+            0x80077,
+            0x80037,
+            0x900ce,
+            0x7010b,
+            0x80067,
+            0x80027,
+            0x900ae,
+            0x80007,
+            0x80087,
+            0x80047,
+            0x900ee,
+            0x70107,
+            0x8005f,
+            0x8001f,
+            0x9009e,
+            0x70117,
+            0x8007f,
+            0x8003f,
+            0x900de,
+            0x7010f,
+            0x8006f,
+            0x8002f,
+            0x900be,
+            0x8000f,
+            0x8008f,
+            0x8004f,
+            0x900fe,
+            0x70100,
+            0x80050,
+            0x80010,
+            0x80118,
+            0x70110,
+            0x80070,
+            0x80030,
+            0x900c1,
+            0x70108,
+            0x80060,
+            0x80020,
+            0x900a1,
+            0x80000,
+            0x80080,
+            0x80040,
+            0x900e1,
+            0x70104,
+            0x80058,
+            0x80018,
+            0x90091,
+            0x70114,
+            0x80078,
+            0x80038,
+            0x900d1,
+            0x7010c,
+            0x80068,
+            0x80028,
+            0x900b1,
+            0x80008,
+            0x80088,
+            0x80048,
+            0x900f1,
+            0x70102,
+            0x80054,
+            0x80014,
+            0x8011c,
+            0x70112,
+            0x80074,
+            0x80034,
+            0x900c9,
+            0x7010a,
+            0x80064,
+            0x80024,
+            0x900a9,
+            0x80004,
+            0x80084,
+            0x80044,
+            0x900e9,
+            0x70106,
+            0x8005c,
+            0x8001c,
+            0x90099,
+            0x70116,
+            0x8007c,
+            0x8003c,
+            0x900d9,
+            0x7010e,
+            0x8006c,
+            0x8002c,
+            0x900b9,
+            0x8000c,
+            0x8008c,
+            0x8004c,
+            0x900f9,
+            0x70101,
+            0x80052,
+            0x80012,
+            0x8011a,
+            0x70111,
+            0x80072,
+            0x80032,
+            0x900c5,
+            0x70109,
+            0x80062,
+            0x80022,
+            0x900a5,
+            0x80002,
+            0x80082,
+            0x80042,
+            0x900e5,
+            0x70105,
+            0x8005a,
+            0x8001a,
+            0x90095,
+            0x70115,
+            0x8007a,
+            0x8003a,
+            0x900d5,
+            0x7010d,
+            0x8006a,
+            0x8002a,
+            0x900b5,
+            0x8000a,
+            0x8008a,
+            0x8004a,
+            0x900f5,
+            0x70103,
+            0x80056,
+            0x80016,
+            0x8011e,
+            0x70113,
+            0x80076,
+            0x80036,
+            0x900cd,
+            0x7010b,
+            0x80066,
+            0x80026,
+            0x900ad,
+            0x80006,
+            0x80086,
+            0x80046,
+            0x900ed,
+            0x70107,
+            0x8005e,
+            0x8001e,
+            0x9009d,
+            0x70117,
+            0x8007e,
+            0x8003e,
+            0x900dd,
+            0x7010f,
+            0x8006e,
+            0x8002e,
+            0x900bd,
+            0x8000e,
+            0x8008e,
+            0x8004e,
+            0x900fd,
+            0x70100,
+            0x80051,
+            0x80011,
+            0x80119,
+            0x70110,
+            0x80071,
+            0x80031,
+            0x900c3,
+            0x70108,
+            0x80061,
+            0x80021,
+            0x900a3,
+            0x80001,
+            0x80081,
+            0x80041,
+            0x900e3,
+            0x70104,
+            0x80059,
+            0x80019,
+            0x90093,
+            0x70114,
+            0x80079,
+            0x80039,
+            0x900d3,
+            0x7010c,
+            0x80069,
+            0x80029,
+            0x900b3,
+            0x80009,
+            0x80089,
+            0x80049,
+            0x900f3,
+            0x70102,
+            0x80055,
+            0x80015,
+            0x8011d,
+            0x70112,
+            0x80075,
+            0x80035,
+            0x900cb,
+            0x7010a,
+            0x80065,
+            0x80025,
+            0x900ab,
+            0x80005,
+            0x80085,
+            0x80045,
+            0x900eb,
+            0x70106,
+            0x8005d,
+            0x8001d,
+            0x9009b,
+            0x70116,
+            0x8007d,
+            0x8003d,
+            0x900db,
+            0x7010e,
+            0x8006d,
+            0x8002d,
+            0x900bb,
+            0x8000d,
+            0x8008d,
+            0x8004d,
+            0x900fb,
+            0x70101,
+            0x80053,
+            0x80013,
+            0x8011b,
+            0x70111,
+            0x80073,
+            0x80033,
+            0x900c7,
+            0x70109,
+            0x80063,
+            0x80023,
+            0x900a7,
+            0x80003,
+            0x80083,
+            0x80043,
+            0x900e7,
+            0x70105,
+            0x8005b,
+            0x8001b,
+            0x90097,
+            0x70115,
+            0x8007b,
+            0x8003b,
+            0x900d7,
+            0x7010d,
+            0x8006b,
+            0x8002b,
+            0x900b7,
+            0x8000b,
+            0x8008b,
+            0x8004b,
+            0x900f7,
+            0x70103,
+            0x80057,
+            0x80017,
+            0x8011f,
+            0x70113,
+            0x80077,
+            0x80037,
+            0x900cf,
+            0x7010b,
+            0x80067,
+            0x80027,
+            0x900af,
+            0x80007,
+            0x80087,
+            0x80047,
+            0x900ef,
+            0x70107,
+            0x8005f,
+            0x8001f,
+            0x9009f,
+            0x70117,
+            0x8007f,
+            0x8003f,
+            0x900df,
+            0x7010f,
+            0x8006f,
+            0x8002f,
+            0x900bf,
+            0x8000f,
+            0x8008f,
+            0x8004f,
+            0x900ff
+          ]),
+          9
+        ];
+        var fixedDistCodeTab = [
+          new Int32Array([
+            0x50000,
+            0x50010,
+            0x50008,
+            0x50018,
+            0x50004,
+            0x50014,
+            0x5000c,
+            0x5001c,
+            0x50002,
+            0x50012,
+            0x5000a,
+            0x5001a,
+            0x50006,
+            0x50016,
+            0x5000e,
+            0x00000,
+            0x50001,
+            0x50011,
+            0x50009,
+            0x50019,
+            0x50005,
+            0x50015,
+            0x5000d,
+            0x5001d,
+            0x50003,
+            0x50013,
+            0x5000b,
+            0x5001b,
+            0x50007,
+            0x50017,
+            0x5000f,
+            0x00000
+          ]),
+          5
+        ];
+        function FlateStream(str, maybeLength) {
+          this.str = str;
+          this.dict = str.dict;
+          var cmf = str.getByte();
+          var flg = str.getByte();
+          if (cmf === -1 || flg === -1) {
+            error('Invalid header in flate stream: ' + cmf + ', ' + flg);
+          }
+          if ((cmf & 0x0f) !== 0x08) {
+            error('Unknown compression method in flate stream: ' + cmf + ', ' + flg);
+          }
+          if (((cmf << 8) + flg) % 31 !== 0) {
+            error('Bad FCHECK in flate stream: ' + cmf + ', ' + flg);
+          }
+          if (flg & 0x20) {
+            error('FDICT bit set in flate stream: ' + cmf + ', ' + flg);
+          }
+          this.codeSize = 0;
+          this.codeBuf = 0;
+          DecodeStream.call(this, maybeLength);
+        }
+        FlateStream.prototype = Object.create(DecodeStream.prototype);
+        FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
+          var str = this.str;
+          var codeSize = this.codeSize;
+          var codeBuf = this.codeBuf;
+          var b;
+          while (codeSize < bits) {
+            if ((b = str.getByte()) === -1) {
+              error('Bad encoding in flate stream');
+            }
+            codeBuf |= b << codeSize;
+            codeSize += 8;
+          }
+          b = codeBuf & (1 << bits) - 1;
+          this.codeBuf = codeBuf >> bits;
+          this.codeSize = codeSize -= bits;
+          return b;
+        };
+        FlateStream.prototype.getCode = function FlateStream_getCode(table) {
+          var str = this.str;
+          var codes = table[0];
+          var maxLen = table[1];
+          var codeSize = this.codeSize;
+          var codeBuf = this.codeBuf;
+          var b;
+          while (codeSize < maxLen) {
+            if ((b = str.getByte()) === -1) {
+              // premature end of stream. code might however still be valid.
+              // codeSize < codeLen check below guards against incomplete codeVal.
+              break;
+            }
+            codeBuf |= b << codeSize;
+            codeSize += 8;
+          }
+          var code = codes[codeBuf & (1 << maxLen) - 1];
+          var codeLen = code >> 16;
+          var codeVal = code & 0xffff;
+          if (codeLen < 1 || codeSize < codeLen) {
+            error('Bad encoding in flate stream');
+          }
+          this.codeBuf = codeBuf >> codeLen;
+          this.codeSize = codeSize - codeLen;
+          return codeVal;
+        };
+        FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(lengths) {
+          var n = lengths.length;
+          // find max code length
+          var maxLen = 0;
+          var i;
+          for (i = 0; i < n; ++i) {
+            if (lengths[i] > maxLen) {
+              maxLen = lengths[i];
+            }
+          }
+          // build the table
+          var size = 1 << maxLen;
+          var codes = new Int32Array(size);
+          for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
+            for (var val = 0; val < n; ++val) {
+              if (lengths[val] === len) {
+                // bit-reverse the code
+                var code2 = 0;
+                var t = code;
+                for (i = 0; i < len; ++i) {
+                  code2 = code2 << 1 | t & 1;
+                  t >>= 1;
+                }
+                // fill the table entries
+                for (i = code2; i < size; i += skip) {
+                  codes[i] = len << 16 | val;
+                }
+                ++code;
+              }
+            }
+          }
+          return [
+            codes,
+            maxLen
+          ];
+        };
+        FlateStream.prototype.readBlock = function FlateStream_readBlock() {
+          var buffer, len;
+          var str = this.str;
+          // read block header
+          var hdr = this.getBits(3);
+          if (hdr & 1) {
+            this.eof = true;
+          }
+          hdr >>= 1;
+          if (hdr === 0) {
+            // uncompressed block
+            var b;
+            if ((b = str.getByte()) === -1) {
+              error('Bad block header in flate stream');
+            }
+            var blockLen = b;
+            if ((b = str.getByte()) === -1) {
+              error('Bad block header in flate stream');
+            }
+            blockLen |= b << 8;
+            if ((b = str.getByte()) === -1) {
+              error('Bad block header in flate stream');
+            }
+            var check = b;
+            if ((b = str.getByte()) === -1) {
+              error('Bad block header in flate stream');
+            }
+            check |= b << 8;
+            if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
+              // Ignoring error for bad "empty" block (see issue 1277)
+              error('Bad uncompressed block length in flate stream');
+            }
+            this.codeBuf = 0;
+            this.codeSize = 0;
+            var bufferLength = this.bufferLength;
+            buffer = this.ensureBuffer(bufferLength + blockLen);
+            var end = bufferLength + blockLen;
+            this.bufferLength = end;
+            if (blockLen === 0) {
+              if (str.peekByte() === -1) {
+                this.eof = true;
+              }
+            } else {
+              for (var n = bufferLength; n < end; ++n) {
+                if ((b = str.getByte()) === -1) {
+                  this.eof = true;
+                  break;
+                }
+                buffer[n] = b;
+              }
+            }
+            return;
+          }
+          var litCodeTable;
+          var distCodeTable;
+          if (hdr === 1) {
+            // compressed block, fixed codes
+            litCodeTable = fixedLitCodeTab;
+            distCodeTable = fixedDistCodeTab;
+          } else if (hdr === 2) {
+            // compressed block, dynamic codes
+            var numLitCodes = this.getBits(5) + 257;
+            var numDistCodes = this.getBits(5) + 1;
+            var numCodeLenCodes = this.getBits(4) + 4;
+            // build the code lengths code table
+            var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
+            var i;
+            for (i = 0; i < numCodeLenCodes; ++i) {
+              codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
+            }
+            var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
+            // build the literal and distance code tables
+            len = 0;
+            i = 0;
+            var codes = numLitCodes + numDistCodes;
+            var codeLengths = new Uint8Array(codes);
+            var bitsLength, bitsOffset, what;
+            while (i < codes) {
+              var code = this.getCode(codeLenCodeTab);
+              if (code === 16) {
+                bitsLength = 2;
+                bitsOffset = 3;
+                what = len;
+              } else if (code === 17) {
+                bitsLength = 3;
+                bitsOffset = 3;
+                what = len = 0;
+              } else if (code === 18) {
+                bitsLength = 7;
+                bitsOffset = 11;
+                what = len = 0;
+              } else {
+                codeLengths[i++] = len = code;
+                continue;
+              }
+              var repeatLength = this.getBits(bitsLength) + bitsOffset;
+              while (repeatLength-- > 0) {
+                codeLengths[i++] = what;
+              }
+            }
+            litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
+            distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
+          } else {
+            error('Unknown block type in flate stream');
+          }
+          buffer = this.buffer;
+          var limit = buffer ? buffer.length : 0;
+          var pos = this.bufferLength;
+          while (true) {
+            var code1 = this.getCode(litCodeTable);
+            if (code1 < 256) {
+              if (pos + 1 >= limit) {
+                buffer = this.ensureBuffer(pos + 1);
+                limit = buffer.length;
+              }
+              buffer[pos++] = code1;
+              continue;
+            }
+            if (code1 === 256) {
+              this.bufferLength = pos;
+              return;
+            }
+            code1 -= 257;
+            code1 = lengthDecode[code1];
+            var code2 = code1 >> 16;
+            if (code2 > 0) {
+              code2 = this.getBits(code2);
+            }
+            len = (code1 & 0xffff) + code2;
+            code1 = this.getCode(distCodeTable);
+            code1 = distDecode[code1];
+            code2 = code1 >> 16;
+            if (code2 > 0) {
+              code2 = this.getBits(code2);
+            }
+            var dist = (code1 & 0xffff) + code2;
+            if (pos + len >= limit) {
+              buffer = this.ensureBuffer(pos + len);
+              limit = buffer.length;
+            }
+            for (var k = 0; k < len; ++k, ++pos) {
+              buffer[pos] = buffer[pos - dist];
+            }
+          }
+        };
+        return FlateStream;
+      }();
+      var PredictorStream = function PredictorStreamClosure() {
+        function PredictorStream(str, maybeLength, params) {
+          if (!isDict(params)) {
+            return str;
+          }
+          // no prediction
+          var predictor = this.predictor = params.get('Predictor') || 1;
+          if (predictor <= 1) {
+            return str;
+          }
+          // no prediction
+          if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
+            error('Unsupported predictor: ' + predictor);
+          }
+          if (predictor === 2) {
+            this.readBlock = this.readBlockTiff;
+          } else {
+            this.readBlock = this.readBlockPng;
+          }
+          this.str = str;
+          this.dict = str.dict;
+          var colors = this.colors = params.get('Colors') || 1;
+          var bits = this.bits = params.get('BitsPerComponent') || 8;
+          var columns = this.columns = params.get('Columns') || 1;
+          this.pixBytes = colors * bits + 7 >> 3;
+          this.rowBytes = columns * colors * bits + 7 >> 3;
+          DecodeStream.call(this, maybeLength);
+          return this;
+        }
+        PredictorStream.prototype = Object.create(DecodeStream.prototype);
+        PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
+          var rowBytes = this.rowBytes;
+          var bufferLength = this.bufferLength;
+          var buffer = this.ensureBuffer(bufferLength + rowBytes);
+          var bits = this.bits;
+          var colors = this.colors;
+          var rawBytes = this.str.getBytes(rowBytes);
+          this.eof = !rawBytes.length;
+          if (this.eof) {
+            return;
+          }
+          var inbuf = 0, outbuf = 0;
+          var inbits = 0, outbits = 0;
+          var pos = bufferLength;
+          var i;
+          if (bits === 1) {
+            for (i = 0; i < rowBytes; ++i) {
+              var c = rawBytes[i];
+              inbuf = inbuf << 8 | c;
+              // bitwise addition is exclusive or
+              // first shift inbuf and then add
+              buffer[pos++] = (c ^ inbuf >> colors) & 0xFF;
+              // truncate inbuf (assumes colors < 16)
+              inbuf &= 0xFFFF;
+            }
+          } else if (bits === 8) {
+            for (i = 0; i < colors; ++i) {
+              buffer[pos++] = rawBytes[i];
+            }
+            for (; i < rowBytes; ++i) {
+              buffer[pos] = buffer[pos - colors] + rawBytes[i];
+              pos++;
+            }
+          } else {
+            var compArray = new Uint8Array(colors + 1);
+            var bitMask = (1 << bits) - 1;
+            var j = 0, k = bufferLength;
+            var columns = this.columns;
+            for (i = 0; i < columns; ++i) {
+              for (var kk = 0; kk < colors; ++kk) {
+                if (inbits < bits) {
+                  inbuf = inbuf << 8 | rawBytes[j++] & 0xFF;
+                  inbits += 8;
+                }
+                compArray[kk] = compArray[kk] + (inbuf >> inbits - bits) & bitMask;
+                inbits -= bits;
+                outbuf = outbuf << bits | compArray[kk];
+                outbits += bits;
+                if (outbits >= 8) {
+                  buffer[k++] = outbuf >> outbits - 8 & 0xFF;
+                  outbits -= 8;
+                }
+              }
+            }
+            if (outbits > 0) {
+              buffer[k++] = (outbuf << 8 - outbits) + (inbuf & (1 << 8 - outbits) - 1);
+            }
+          }
+          this.bufferLength += rowBytes;
+        };
+        PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
+          var rowBytes = this.rowBytes;
+          var pixBytes = this.pixBytes;
+          var predictor = this.str.getByte();
+          var rawBytes = this.str.getBytes(rowBytes);
+          this.eof = !rawBytes.length;
+          if (this.eof) {
+            return;
+          }
+          var bufferLength = this.bufferLength;
+          var buffer = this.ensureBuffer(bufferLength + rowBytes);
+          var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
+          if (prevRow.length === 0) {
+            prevRow = new Uint8Array(rowBytes);
+          }
+          var i, j = bufferLength, up, c;
+          switch (predictor) {
+          case 0:
+            for (i = 0; i < rowBytes; ++i) {
+              buffer[j++] = rawBytes[i];
+            }
+            break;
+          case 1:
+            for (i = 0; i < pixBytes; ++i) {
+              buffer[j++] = rawBytes[i];
+            }
+            for (; i < rowBytes; ++i) {
+              buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xFF;
+              j++;
+            }
+            break;
+          case 2:
+            for (i = 0; i < rowBytes; ++i) {
+              buffer[j++] = prevRow[i] + rawBytes[i] & 0xFF;
+            }
+            break;
+          case 3:
+            for (i = 0; i < pixBytes; ++i) {
+              buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
+            }
+            for (; i < rowBytes; ++i) {
+              buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xFF;
+              j++;
+            }
+            break;
+          case 4:
+            // we need to save the up left pixels values. the simplest way
+            // is to create a new buffer
+            for (i = 0; i < pixBytes; ++i) {
+              up = prevRow[i];
+              c = rawBytes[i];
+              buffer[j++] = up + c;
+            }
+            for (; i < rowBytes; ++i) {
+              up = prevRow[i];
+              var upLeft = prevRow[i - pixBytes];
+              var left = buffer[j - pixBytes];
+              var p = left + up - upLeft;
+              var pa = p - left;
+              if (pa < 0) {
+                pa = -pa;
+              }
+              var pb = p - up;
+              if (pb < 0) {
+                pb = -pb;
+              }
+              var pc = p - upLeft;
+              if (pc < 0) {
+                pc = -pc;
+              }
+              c = rawBytes[i];
+              if (pa <= pb && pa <= pc) {
+                buffer[j++] = left + c;
+              } else if (pb <= pc) {
+                buffer[j++] = up + c;
+              } else {
+                buffer[j++] = upLeft + c;
+              }
+            }
+            break;
+          default:
+            error('Unsupported predictor: ' + predictor);
+          }
+          this.bufferLength += rowBytes;
+        };
+        return PredictorStream;
+      }();
+      /**
+       * Depending on the type of JPEG a JpegStream is handled in different ways. For
+       * JPEG's that are supported natively such as DeviceGray and DeviceRGB the image
+       * data is stored and then loaded by the browser.  For unsupported JPEG's we use
+       * a library to decode these images and the stream behaves like all the other
+       * DecodeStreams.
+       */
+      var JpegStream = function JpegStreamClosure() {
+        function JpegStream(stream, maybeLength, dict, params) {
+          // Some images may contain 'junk' before the SOI (start-of-image) marker.
+          // Note: this seems to mainly affect inline images.
+          var ch;
+          while ((ch = stream.getByte()) !== -1) {
+            if (ch === 0xFF) {
+              // Find the first byte of the SOI marker (0xFFD8).
+              stream.skip(-1);
+              // Reset the stream position to the SOI.
+              break;
+            }
+          }
+          this.stream = stream;
+          this.maybeLength = maybeLength;
+          this.dict = dict;
+          this.params = params;
+          DecodeStream.call(this, maybeLength);
+        }
+        JpegStream.prototype = Object.create(DecodeStream.prototype);
+        Object.defineProperty(JpegStream.prototype, 'bytes', {
+          get: function JpegStream_bytes() {
+            // If this.maybeLength is null, we'll get the entire stream.
+            return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));
+          },
+          configurable: true
+        });
+        JpegStream.prototype.ensureBuffer = function JpegStream_ensureBuffer(req) {
+          if (this.bufferLength) {
+            return;
+          }
+          var jpegImage = new JpegImage();
+          // Checking if values need to be transformed before conversion.
+          var decodeArr = this.dict.getArray('Decode', 'D');
+          if (this.forceRGB && isArray(decodeArr)) {
+            var bitsPerComponent = this.dict.get('BitsPerComponent') || 8;
+            var decodeArrLength = decodeArr.length;
+            var transform = new Int32Array(decodeArrLength);
+            var transformNeeded = false;
+            var maxValue = (1 << bitsPerComponent) - 1;
+            for (var i = 0; i < decodeArrLength; i += 2) {
+              transform[i] = (decodeArr[i + 1] - decodeArr[i]) * 256 | 0;
+              transform[i + 1] = decodeArr[i] * maxValue | 0;
+              if (transform[i] !== 256 || transform[i + 1] !== 0) {
+                transformNeeded = true;
+              }
+            }
+            if (transformNeeded) {
+              jpegImage.decodeTransform = transform;
+            }
+          }
+          // Fetching the 'ColorTransform' entry, if it exists.
+          if (isDict(this.params)) {
+            var colorTransform = this.params.get('ColorTransform');
+            if (isInt(colorTransform)) {
+              jpegImage.colorTransform = colorTransform;
+            }
+          }
+          jpegImage.parse(this.bytes);
+          var data = jpegImage.getData(this.drawWidth, this.drawHeight, this.forceRGB);
+          this.buffer = data;
+          this.bufferLength = data.length;
+          this.eof = true;
+        };
+        JpegStream.prototype.getBytes = function JpegStream_getBytes(length) {
+          this.ensureBuffer();
+          return this.buffer;
+        };
+        JpegStream.prototype.getIR = function JpegStream_getIR(forceDataSchema) {
+          return createObjectURL(this.bytes, 'image/jpeg', forceDataSchema);
+        };
+        return JpegStream;
+      }();
+      /**
+       * For JPEG 2000's we use a library to decode these images and
+       * the stream behaves like all the other DecodeStreams.
+       */
+      var JpxStream = function JpxStreamClosure() {
+        function JpxStream(stream, maybeLength, dict, params) {
+          this.stream = stream;
+          this.maybeLength = maybeLength;
+          this.dict = dict;
+          this.params = params;
+          DecodeStream.call(this, maybeLength);
+        }
+        JpxStream.prototype = Object.create(DecodeStream.prototype);
+        Object.defineProperty(JpxStream.prototype, 'bytes', {
+          get: function JpxStream_bytes() {
+            // If this.maybeLength is null, we'll get the entire stream.
+            return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));
+          },
+          configurable: true
+        });
+        JpxStream.prototype.ensureBuffer = function JpxStream_ensureBuffer(req) {
+          if (this.bufferLength) {
+            return;
+          }
+          var jpxImage = new JpxImage();
+          jpxImage.parse(this.bytes);
+          var width = jpxImage.width;
+          var height = jpxImage.height;
+          var componentsCount = jpxImage.componentsCount;
+          var tileCount = jpxImage.tiles.length;
+          if (tileCount === 1) {
+            this.buffer = jpxImage.tiles[0].items;
+          } else {
+            var data = new Uint8Array(width * height * componentsCount);
+            for (var k = 0; k < tileCount; k++) {
+              var tileComponents = jpxImage.tiles[k];
+              var tileWidth = tileComponents.width;
+              var tileHeight = tileComponents.height;
+              var tileLeft = tileComponents.left;
+              var tileTop = tileComponents.top;
+              var src = tileComponents.items;
+              var srcPosition = 0;
+              var dataPosition = (width * tileTop + tileLeft) * componentsCount;
+              var imgRowSize = width * componentsCount;
+              var tileRowSize = tileWidth * componentsCount;
+              for (var j = 0; j < tileHeight; j++) {
+                var rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize);
+                data.set(rowBytes, dataPosition);
+                srcPosition += tileRowSize;
+                dataPosition += imgRowSize;
+              }
+            }
+            this.buffer = data;
+          }
+          this.bufferLength = this.buffer.length;
+          this.eof = true;
+        };
+        return JpxStream;
+      }();
+      /**
+       * For JBIG2's we use a library to decode these images and
+       * the stream behaves like all the other DecodeStreams.
+       */
+      var Jbig2Stream = function Jbig2StreamClosure() {
+        function Jbig2Stream(stream, maybeLength, dict, params) {
+          this.stream = stream;
+          this.maybeLength = maybeLength;
+          this.dict = dict;
+          this.params = params;
+          DecodeStream.call(this, maybeLength);
+        }
+        Jbig2Stream.prototype = Object.create(DecodeStream.prototype);
+        Object.defineProperty(Jbig2Stream.prototype, 'bytes', {
+          get: function Jbig2Stream_bytes() {
+            // If this.maybeLength is null, we'll get the entire stream.
+            return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));
+          },
+          configurable: true
+        });
+        Jbig2Stream.prototype.ensureBuffer = function Jbig2Stream_ensureBuffer(req) {
+          if (this.bufferLength) {
+            return;
+          }
+          var jbig2Image = new Jbig2Image();
+          var chunks = [];
+          if (isDict(this.params)) {
+            var globalsStream = this.params.get('JBIG2Globals');
+            if (isStream(globalsStream)) {
+              var globals = globalsStream.getBytes();
+              chunks.push({
+                data: globals,
+                start: 0,
+                end: globals.length
+              });
+            }
+          }
+          chunks.push({
+            data: this.bytes,
+            start: 0,
+            end: this.bytes.length
+          });
+          var data = jbig2Image.parseChunks(chunks);
+          var dataLength = data.length;
+          // JBIG2 had black as 1 and white as 0, inverting the colors
+          for (var i = 0; i < dataLength; i++) {
+            data[i] ^= 0xFF;
+          }
+          this.buffer = data;
+          this.bufferLength = dataLength;
+          this.eof = true;
+        };
+        return Jbig2Stream;
+      }();
+      var DecryptStream = function DecryptStreamClosure() {
+        function DecryptStream(str, maybeLength, decrypt) {
+          this.str = str;
+          this.dict = str.dict;
+          this.decrypt = decrypt;
+          this.nextChunk = null;
+          this.initialized = false;
+          DecodeStream.call(this, maybeLength);
+        }
+        var chunkSize = 512;
+        DecryptStream.prototype = Object.create(DecodeStream.prototype);
+        DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
+          var chunk;
+          if (this.initialized) {
+            chunk = this.nextChunk;
+          } else {
+            chunk = this.str.getBytes(chunkSize);
+            this.initialized = true;
+          }
+          if (!chunk || chunk.length === 0) {
+            this.eof = true;
+            return;
+          }
+          this.nextChunk = this.str.getBytes(chunkSize);
+          var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
+          var decrypt = this.decrypt;
+          chunk = decrypt(chunk, !hasMoreData);
+          var bufferLength = this.bufferLength;
+          var i, n = chunk.length;
+          var buffer = this.ensureBuffer(bufferLength + n);
+          for (i = 0; i < n; i++) {
+            buffer[bufferLength++] = chunk[i];
+          }
+          this.bufferLength = bufferLength;
+        };
+        return DecryptStream;
+      }();
+      var Ascii85Stream = function Ascii85StreamClosure() {
+        function Ascii85Stream(str, maybeLength) {
+          this.str = str;
+          this.dict = str.dict;
+          this.input = new Uint8Array(5);
+          // Most streams increase in size when decoded, but Ascii85 streams
+          // typically shrink by ~20%.
+          if (maybeLength) {
+            maybeLength = 0.8 * maybeLength;
+          }
+          DecodeStream.call(this, maybeLength);
+        }
+        Ascii85Stream.prototype = Object.create(DecodeStream.prototype);
+        Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
+          var TILDA_CHAR = 0x7E;
+          // '~'
+          var Z_LOWER_CHAR = 0x7A;
+          // 'z'
+          var EOF = -1;
+          var str = this.str;
+          var c = str.getByte();
+          while (isSpace(c)) {
+            c = str.getByte();
+          }
+          if (c === EOF || c === TILDA_CHAR) {
+            this.eof = true;
+            return;
+          }
+          var bufferLength = this.bufferLength, buffer;
+          var i;
+          // special code for z
+          if (c === Z_LOWER_CHAR) {
+            buffer = this.ensureBuffer(bufferLength + 4);
+            for (i = 0; i < 4; ++i) {
+              buffer[bufferLength + i] = 0;
+            }
+            this.bufferLength += 4;
+          } else {
+            var input = this.input;
+            input[0] = c;
+            for (i = 1; i < 5; ++i) {
+              c = str.getByte();
+              while (isSpace(c)) {
+                c = str.getByte();
+              }
+              input[i] = c;
+              if (c === EOF || c === TILDA_CHAR) {
+                break;
+              }
+            }
+            buffer = this.ensureBuffer(bufferLength + i - 1);
+            this.bufferLength += i - 1;
+            // partial ending;
+            if (i < 5) {
+              for (; i < 5; ++i) {
+                input[i] = 0x21 + 84;
+              }
+              this.eof = true;
+            }
+            var t = 0;
+            for (i = 0; i < 5; ++i) {
+              t = t * 85 + (input[i] - 0x21);
+            }
+            for (i = 3; i >= 0; --i) {
+              buffer[bufferLength + i] = t & 0xFF;
+              t >>= 8;
+            }
+          }
+        };
+        return Ascii85Stream;
+      }();
+      var AsciiHexStream = function AsciiHexStreamClosure() {
+        function AsciiHexStream(str, maybeLength) {
+          this.str = str;
+          this.dict = str.dict;
+          this.firstDigit = -1;
+          // Most streams increase in size when decoded, but AsciiHex streams shrink
+          // by 50%.
+          if (maybeLength) {
+            maybeLength = 0.5 * maybeLength;
+          }
+          DecodeStream.call(this, maybeLength);
+        }
+        AsciiHexStream.prototype = Object.create(DecodeStream.prototype);
+        AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
+          var UPSTREAM_BLOCK_SIZE = 8000;
+          var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
+          if (!bytes.length) {
+            this.eof = true;
+            return;
+          }
+          var maxDecodeLength = bytes.length + 1 >> 1;
+          var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
+          var bufferLength = this.bufferLength;
+          var firstDigit = this.firstDigit;
+          for (var i = 0, ii = bytes.length; i < ii; i++) {
+            var ch = bytes[i], digit;
+            if (ch >= 0x30 && ch <= 0x39) {
+              // '0'-'9'
+              digit = ch & 0x0F;
+            } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
+              // 'A'-'Z', 'a'-'z'
+              digit = (ch & 0x0F) + 9;
+            } else if (ch === 0x3E) {
+              // '>'
+              this.eof = true;
+              break;
+            } else {
+              // probably whitespace
+              continue;
+            }
+            // ignoring
+            if (firstDigit < 0) {
+              firstDigit = digit;
+            } else {
+              buffer[bufferLength++] = firstDigit << 4 | digit;
+              firstDigit = -1;
+            }
+          }
+          if (firstDigit >= 0 && this.eof) {
+            // incomplete byte
+            buffer[bufferLength++] = firstDigit << 4;
+            firstDigit = -1;
+          }
+          this.firstDigit = firstDigit;
+          this.bufferLength = bufferLength;
+        };
+        return AsciiHexStream;
+      }();
+      var RunLengthStream = function RunLengthStreamClosure() {
+        function RunLengthStream(str, maybeLength) {
+          this.str = str;
+          this.dict = str.dict;
+          DecodeStream.call(this, maybeLength);
+        }
+        RunLengthStream.prototype = Object.create(DecodeStream.prototype);
+        RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
+          // The repeatHeader has following format. The first byte defines type of run
+          // and amount of bytes to repeat/copy: n = 0 through 127 - copy next n bytes
+          // (in addition to the second byte from the header), n = 129 through 255 -
+          // duplicate the second byte from the header (257 - n) times, n = 128 - end.
+          var repeatHeader = this.str.getBytes(2);
+          if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
+            this.eof = true;
+            return;
+          }
+          var buffer;
+          var bufferLength = this.bufferLength;
+          var n = repeatHeader[0];
+          if (n < 128) {
+            // copy n bytes
+            buffer = this.ensureBuffer(bufferLength + n + 1);
+            buffer[bufferLength++] = repeatHeader[1];
+            if (n > 0) {
+              var source = this.str.getBytes(n);
+              buffer.set(source, bufferLength);
+              bufferLength += n;
+            }
+          } else {
+            n = 257 - n;
+            var b = repeatHeader[1];
+            buffer = this.ensureBuffer(bufferLength + n + 1);
+            for (var i = 0; i < n; i++) {
+              buffer[bufferLength++] = b;
+            }
+          }
+          this.bufferLength = bufferLength;
+        };
+        return RunLengthStream;
+      }();
+      var CCITTFaxStream = function CCITTFaxStreamClosure() {
+        var ccittEOL = -2;
+        var ccittEOF = -1;
+        var twoDimPass = 0;
+        var twoDimHoriz = 1;
+        var twoDimVert0 = 2;
+        var twoDimVertR1 = 3;
+        var twoDimVertL1 = 4;
+        var twoDimVertR2 = 5;
+        var twoDimVertL2 = 6;
+        var twoDimVertR3 = 7;
+        var twoDimVertL3 = 8;
+        var twoDimTable = [
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 000000x
+          [
+            7,
+            twoDimVertL3
+          ],
+          // 0000010
+          [
+            7,
+            twoDimVertR3
+          ],
+          // 0000011
+          [
+            6,
+            twoDimVertL2
+          ],
+          [
+            6,
+            twoDimVertL2
+          ],
+          // 000010x
+          [
+            6,
+            twoDimVertR2
+          ],
+          [
+            6,
+            twoDimVertR2
+          ],
+          // 000011x
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            4,
+            twoDimPass
+          ],
+          // 0001xxx
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            4,
+            twoDimPass
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          // 001xxxx
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimHoriz
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          // 010xxxx
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertL1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          // 011xxxx
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            3,
+            twoDimVertR1
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          // 1xxxxxx
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ],
+          [
+            1,
+            twoDimVert0
+          ]
+        ];
+        var whiteTable1 = [
+          [
+            -1,
+            -1
+          ],
+          // 00000
+          [
+            12,
+            ccittEOL
+          ],
+          // 00001
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 0001x
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 001xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 010xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 011xx
+          [
+            11,
+            1792
+          ],
+          [
+            11,
+            1792
+          ],
+          // 1000x
+          [
+            12,
+            1984
+          ],
+          // 10010
+          [
+            12,
+            2048
+          ],
+          // 10011
+          [
+            12,
+            2112
+          ],
+          // 10100
+          [
+            12,
+            2176
+          ],
+          // 10101
+          [
+            12,
+            2240
+          ],
+          // 10110
+          [
+            12,
+            2304
+          ],
+          // 10111
+          [
+            11,
+            1856
+          ],
+          [
+            11,
+            1856
+          ],
+          // 1100x
+          [
+            11,
+            1920
+          ],
+          [
+            11,
+            1920
+          ],
+          // 1101x
+          [
+            12,
+            2368
+          ],
+          // 11100
+          [
+            12,
+            2432
+          ],
+          // 11101
+          [
+            12,
+            2496
+          ],
+          // 11110
+          [
+            12,
+            2560
+          ]
+        ];
+        // 11111
+        var whiteTable2 = [
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 0000000xx
+          [
+            8,
+            29
+          ],
+          [
+            8,
+            29
+          ],
+          // 00000010x
+          [
+            8,
+            30
+          ],
+          [
+            8,
+            30
+          ],
+          // 00000011x
+          [
+            8,
+            45
+          ],
+          [
+            8,
+            45
+          ],
+          // 00000100x
+          [
+            8,
+            46
+          ],
+          [
+            8,
+            46
+          ],
+          // 00000101x
+          [
+            7,
+            22
+          ],
+          [
+            7,
+            22
+          ],
+          [
+            7,
+            22
+          ],
+          [
+            7,
+            22
+          ],
+          // 0000011xx
+          [
+            7,
+            23
+          ],
+          [
+            7,
+            23
+          ],
+          [
+            7,
+            23
+          ],
+          [
+            7,
+            23
+          ],
+          // 0000100xx
+          [
+            8,
+            47
+          ],
+          [
+            8,
+            47
+          ],
+          // 00001010x
+          [
+            8,
+            48
+          ],
+          [
+            8,
+            48
+          ],
+          // 00001011x
+          [
+            6,
+            13
+          ],
+          [
+            6,
+            13
+          ],
+          [
+            6,
+            13
+          ],
+          [
+            6,
+            13
+          ],
+          // 000011xxx
+          [
+            6,
+            13
+          ],
+          [
+            6,
+            13
+          ],
+          [
+            6,
+            13
+          ],
+          [
+            6,
+            13
+          ],
+          [
+            7,
+            20
+          ],
+          [
+            7,
+            20
+          ],
+          [
+            7,
+            20
+          ],
+          [
+            7,
+            20
+          ],
+          // 0001000xx
+          [
+            8,
+            33
+          ],
+          [
+            8,
+            33
+          ],
+          // 00010010x
+          [
+            8,
+            34
+          ],
+          [
+            8,
+            34
+          ],
+          // 00010011x
+          [
+            8,
+            35
+          ],
+          [
+            8,
+            35
+          ],
+          // 00010100x
+          [
+            8,
+            36
+          ],
+          [
+            8,
+            36
+          ],
+          // 00010101x
+          [
+            8,
+            37
+          ],
+          [
+            8,
+            37
+          ],
+          // 00010110x
+          [
+            8,
+            38
+          ],
+          [
+            8,
+            38
+          ],
+          // 00010111x
+          [
+            7,
+            19
+          ],
+          [
+            7,
+            19
+          ],
+          [
+            7,
+            19
+          ],
+          [
+            7,
+            19
+          ],
+          // 0001100xx
+          [
+            8,
+            31
+          ],
+          [
+            8,
+            31
+          ],
+          // 00011010x
+          [
+            8,
+            32
+          ],
+          [
+            8,
+            32
+          ],
+          // 00011011x
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            1
+          ],
+          // 000111xxx
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            1
+          ],
+          [
+            6,
+            12
+          ],
+          [
+            6,
+            12
+          ],
+          [
+            6,
+            12
+          ],
+          [
+            6,
+            12
+          ],
+          // 001000xxx
+          [
+            6,
+            12
+          ],
+          [
+            6,
+            12
+          ],
+          [
+            6,
+            12
+          ],
+          [
+            6,
+            12
+          ],
+          [
+            8,
+            53
+          ],
+          [
+            8,
+            53
+          ],
+          // 00100100x
+          [
+            8,
+            54
+          ],
+          [
+            8,
+            54
+          ],
+          // 00100101x
+          [
+            7,
+            26
+          ],
+          [
+            7,
+            26
+          ],
+          [
+            7,
+            26
+          ],
+          [
+            7,
+            26
+          ],
+          // 0010011xx
+          [
+            8,
+            39
+          ],
+          [
+            8,
+            39
+          ],
+          // 00101000x
+          [
+            8,
+            40
+          ],
+          [
+            8,
+            40
+          ],
+          // 00101001x
+          [
+            8,
+            41
+          ],
+          [
+            8,
+            41
+          ],
+          // 00101010x
+          [
+            8,
+            42
+          ],
+          [
+            8,
+            42
+          ],
+          // 00101011x
+          [
+            8,
+            43
+          ],
+          [
+            8,
+            43
+          ],
+          // 00101100x
+          [
+            8,
+            44
+          ],
+          [
+            8,
+            44
+          ],
+          // 00101101x
+          [
+            7,
+            21
+          ],
+          [
+            7,
+            21
+          ],
+          [
+            7,
+            21
+          ],
+          [
+            7,
+            21
+          ],
+          // 0010111xx
+          [
+            7,
+            28
+          ],
+          [
+            7,
+            28
+          ],
+          [
+            7,
+            28
+          ],
+          [
+            7,
+            28
+          ],
+          // 0011000xx
+          [
+            8,
+            61
+          ],
+          [
+            8,
+            61
+          ],
+          // 00110010x
+          [
+            8,
+            62
+          ],
+          [
+            8,
+            62
+          ],
+          // 00110011x
+          [
+            8,
+            63
+          ],
+          [
+            8,
+            63
+          ],
+          // 00110100x
+          [
+            8,
+            0
+          ],
+          [
+            8,
+            0
+          ],
+          // 00110101x
+          [
+            8,
+            320
+          ],
+          [
+            8,
+            320
+          ],
+          // 00110110x
+          [
+            8,
+            384
+          ],
+          [
+            8,
+            384
+          ],
+          // 00110111x
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          // 00111xxxx
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            10
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          // 01000xxxx
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            5,
+            11
+          ],
+          [
+            7,
+            27
+          ],
+          [
+            7,
+            27
+          ],
+          [
+            7,
+            27
+          ],
+          [
+            7,
+            27
+          ],
+          // 0100100xx
+          [
+            8,
+            59
+          ],
+          [
+            8,
+            59
+          ],
+          // 01001010x
+          [
+            8,
+            60
+          ],
+          [
+            8,
+            60
+          ],
+          // 01001011x
+          [
+            9,
+            1472
+          ],
+          // 010011000
+          [
+            9,
+            1536
+          ],
+          // 010011001
+          [
+            9,
+            1600
+          ],
+          // 010011010
+          [
+            9,
+            1728
+          ],
+          // 010011011
+          [
+            7,
+            18
+          ],
+          [
+            7,
+            18
+          ],
+          [
+            7,
+            18
+          ],
+          [
+            7,
+            18
+          ],
+          // 0100111xx
+          [
+            7,
+            24
+          ],
+          [
+            7,
+            24
+          ],
+          [
+            7,
+            24
+          ],
+          [
+            7,
+            24
+          ],
+          // 0101000xx
+          [
+            8,
+            49
+          ],
+          [
+            8,
+            49
+          ],
+          // 01010010x
+          [
+            8,
+            50
+          ],
+          [
+            8,
+            50
+          ],
+          // 01010011x
+          [
+            8,
+            51
+          ],
+          [
+            8,
+            51
+          ],
+          // 01010100x
+          [
+            8,
+            52
+          ],
+          [
+            8,
+            52
+          ],
+          // 01010101x
+          [
+            7,
+            25
+          ],
+          [
+            7,
+            25
+          ],
+          [
+            7,
+            25
+          ],
+          [
+            7,
+            25
+          ],
+          // 0101011xx
+          [
+            8,
+            55
+          ],
+          [
+            8,
+            55
+          ],
+          // 01011000x
+          [
+            8,
+            56
+          ],
+          [
+            8,
+            56
+          ],
+          // 01011001x
+          [
+            8,
+            57
+          ],
+          [
+            8,
+            57
+          ],
+          // 01011010x
+          [
+            8,
+            58
+          ],
+          [
+            8,
+            58
+          ],
+          // 01011011x
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            192
+          ],
+          // 010111xxx
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            192
+          ],
+          [
+            6,
+            1664
+          ],
+          [
+            6,
+            1664
+          ],
+          [
+            6,
+            1664
+          ],
+          [
+            6,
+            1664
+          ],
+          // 011000xxx
+          [
+            6,
+            1664
+          ],
+          [
+            6,
+            1664
+          ],
+          [
+            6,
+            1664
+          ],
+          [
+            6,
+            1664
+          ],
+          [
+            8,
+            448
+          ],
+          [
+            8,
+            448
+          ],
+          // 01100100x
+          [
+            8,
+            512
+          ],
+          [
+            8,
+            512
+          ],
+          // 01100101x
+          [
+            9,
+            704
+          ],
+          // 011001100
+          [
+            9,
+            768
+          ],
+          // 011001101
+          [
+            8,
+            640
+          ],
+          [
+            8,
+            640
+          ],
+          // 01100111x
+          [
+            8,
+            576
+          ],
+          [
+            8,
+            576
+          ],
+          // 01101000x
+          [
+            9,
+            832
+          ],
+          // 011010010
+          [
+            9,
+            896
+          ],
+          // 011010011
+          [
+            9,
+            960
+          ],
+          // 011010100
+          [
+            9,
+            1024
+          ],
+          // 011010101
+          [
+            9,
+            1088
+          ],
+          // 011010110
+          [
+            9,
+            1152
+          ],
+          // 011010111
+          [
+            9,
+            1216
+          ],
+          // 011011000
+          [
+            9,
+            1280
+          ],
+          // 011011001
+          [
+            9,
+            1344
+          ],
+          // 011011010
+          [
+            9,
+            1408
+          ],
+          // 011011011
+          [
+            7,
+            256
+          ],
+          [
+            7,
+            256
+          ],
+          [
+            7,
+            256
+          ],
+          [
+            7,
+            256
+          ],
+          // 0110111xx
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          // 0111xxxxx
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            2
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          // 1000xxxxx
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            4,
+            3
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          // 10010xxxx
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            128
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          // 10011xxxx
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            8
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          // 10100xxxx
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            5,
+            9
+          ],
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            16
+          ],
+          // 101010xxx
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            16
+          ],
+          [
+            6,
+            17
+          ],
+          [
+            6,
+            17
+          ],
+          [
+            6,
+            17
+          ],
+          [
+            6,
+            17
+          ],
+          // 101011xxx
+          [
+            6,
+            17
+          ],
+          [
+            6,
+            17
+          ],
+          [
+            6,
+            17
+          ],
+          [
+            6,
+            17
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          // 1011xxxxx
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            4
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          // 1100xxxxx
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            14
+          ],
+          // 110100xxx
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            14
+          ],
+          [
+            6,
+            15
+          ],
+          [
+            6,
+            15
+          ],
+          [
+            6,
+            15
+          ],
+          [
+            6,
+            15
+          ],
+          // 110101xxx
+          [
+            6,
+            15
+          ],
+          [
+            6,
+            15
+          ],
+          [
+            6,
+            15
+          ],
+          [
+            6,
+            15
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          // 11011xxxx
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            5,
+            64
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          // 1110xxxxx
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          // 1111xxxxx
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ],
+          [
+            4,
+            7
+          ]
+        ];
+        var blackTable1 = [
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 000000000000x
+          [
+            12,
+            ccittEOL
+          ],
+          [
+            12,
+            ccittEOL
+          ],
+          // 000000000001x
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000001xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000010xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000011xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000100xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000101xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000110xx
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 00000000111xx
+          [
+            11,
+            1792
+          ],
+          [
+            11,
+            1792
+          ],
+          [
+            11,
+            1792
+          ],
+          [
+            11,
+            1792
+          ],
+          // 00000001000xx
+          [
+            12,
+            1984
+          ],
+          [
+            12,
+            1984
+          ],
+          // 000000010010x
+          [
+            12,
+            2048
+          ],
+          [
+            12,
+            2048
+          ],
+          // 000000010011x
+          [
+            12,
+            2112
+          ],
+          [
+            12,
+            2112
+          ],
+          // 000000010100x
+          [
+            12,
+            2176
+          ],
+          [
+            12,
+            2176
+          ],
+          // 000000010101x
+          [
+            12,
+            2240
+          ],
+          [
+            12,
+            2240
+          ],
+          // 000000010110x
+          [
+            12,
+            2304
+          ],
+          [
+            12,
+            2304
+          ],
+          // 000000010111x
+          [
+            11,
+            1856
+          ],
+          [
+            11,
+            1856
+          ],
+          [
+            11,
+            1856
+          ],
+          [
+            11,
+            1856
+          ],
+          // 00000001100xx
+          [
+            11,
+            1920
+          ],
+          [
+            11,
+            1920
+          ],
+          [
+            11,
+            1920
+          ],
+          [
+            11,
+            1920
+          ],
+          // 00000001101xx
+          [
+            12,
+            2368
+          ],
+          [
+            12,
+            2368
+          ],
+          // 000000011100x
+          [
+            12,
+            2432
+          ],
+          [
+            12,
+            2432
+          ],
+          // 000000011101x
+          [
+            12,
+            2496
+          ],
+          [
+            12,
+            2496
+          ],
+          // 000000011110x
+          [
+            12,
+            2560
+          ],
+          [
+            12,
+            2560
+          ],
+          // 000000011111x
+          [
+            10,
+            18
+          ],
+          [
+            10,
+            18
+          ],
+          [
+            10,
+            18
+          ],
+          [
+            10,
+            18
+          ],
+          // 0000001000xxx
+          [
+            10,
+            18
+          ],
+          [
+            10,
+            18
+          ],
+          [
+            10,
+            18
+          ],
+          [
+            10,
+            18
+          ],
+          [
+            12,
+            52
+          ],
+          [
+            12,
+            52
+          ],
+          // 000000100100x
+          [
+            13,
+            640
+          ],
+          // 0000001001010
+          [
+            13,
+            704
+          ],
+          // 0000001001011
+          [
+            13,
+            768
+          ],
+          // 0000001001100
+          [
+            13,
+            832
+          ],
+          // 0000001001101
+          [
+            12,
+            55
+          ],
+          [
+            12,
+            55
+          ],
+          // 000000100111x
+          [
+            12,
+            56
+          ],
+          [
+            12,
+            56
+          ],
+          // 000000101000x
+          [
+            13,
+            1280
+          ],
+          // 0000001010010
+          [
+            13,
+            1344
+          ],
+          // 0000001010011
+          [
+            13,
+            1408
+          ],
+          // 0000001010100
+          [
+            13,
+            1472
+          ],
+          // 0000001010101
+          [
+            12,
+            59
+          ],
+          [
+            12,
+            59
+          ],
+          // 000000101011x
+          [
+            12,
+            60
+          ],
+          [
+            12,
+            60
+          ],
+          // 000000101100x
+          [
+            13,
+            1536
+          ],
+          // 0000001011010
+          [
+            13,
+            1600
+          ],
+          // 0000001011011
+          [
+            11,
+            24
+          ],
+          [
+            11,
+            24
+          ],
+          [
+            11,
+            24
+          ],
+          [
+            11,
+            24
+          ],
+          // 00000010111xx
+          [
+            11,
+            25
+          ],
+          [
+            11,
+            25
+          ],
+          [
+            11,
+            25
+          ],
+          [
+            11,
+            25
+          ],
+          // 00000011000xx
+          [
+            13,
+            1664
+          ],
+          // 0000001100100
+          [
+            13,
+            1728
+          ],
+          // 0000001100101
+          [
+            12,
+            320
+          ],
+          [
+            12,
+            320
+          ],
+          // 000000110011x
+          [
+            12,
+            384
+          ],
+          [
+            12,
+            384
+          ],
+          // 000000110100x
+          [
+            12,
+            448
+          ],
+          [
+            12,
+            448
+          ],
+          // 000000110101x
+          [
+            13,
+            512
+          ],
+          // 0000001101100
+          [
+            13,
+            576
+          ],
+          // 0000001101101
+          [
+            12,
+            53
+          ],
+          [
+            12,
+            53
+          ],
+          // 000000110111x
+          [
+            12,
+            54
+          ],
+          [
+            12,
+            54
+          ],
+          // 000000111000x
+          [
+            13,
+            896
+          ],
+          // 0000001110010
+          [
+            13,
+            960
+          ],
+          // 0000001110011
+          [
+            13,
+            1024
+          ],
+          // 0000001110100
+          [
+            13,
+            1088
+          ],
+          // 0000001110101
+          [
+            13,
+            1152
+          ],
+          // 0000001110110
+          [
+            13,
+            1216
+          ],
+          // 0000001110111
+          [
+            10,
+            64
+          ],
+          [
+            10,
+            64
+          ],
+          [
+            10,
+            64
+          ],
+          [
+            10,
+            64
+          ],
+          // 0000001111xxx
+          [
+            10,
+            64
+          ],
+          [
+            10,
+            64
+          ],
+          [
+            10,
+            64
+          ],
+          [
+            10,
+            64
+          ]
+        ];
+        var blackTable2 = [
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          // 00000100xxxx
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            8,
+            13
+          ],
+          [
+            11,
+            23
+          ],
+          [
+            11,
+            23
+          ],
+          // 00000101000x
+          [
+            12,
+            50
+          ],
+          // 000001010010
+          [
+            12,
+            51
+          ],
+          // 000001010011
+          [
+            12,
+            44
+          ],
+          // 000001010100
+          [
+            12,
+            45
+          ],
+          // 000001010101
+          [
+            12,
+            46
+          ],
+          // 000001010110
+          [
+            12,
+            47
+          ],
+          // 000001010111
+          [
+            12,
+            57
+          ],
+          // 000001011000
+          [
+            12,
+            58
+          ],
+          // 000001011001
+          [
+            12,
+            61
+          ],
+          // 000001011010
+          [
+            12,
+            256
+          ],
+          // 000001011011
+          [
+            10,
+            16
+          ],
+          [
+            10,
+            16
+          ],
+          [
+            10,
+            16
+          ],
+          [
+            10,
+            16
+          ],
+          // 0000010111xx
+          [
+            10,
+            17
+          ],
+          [
+            10,
+            17
+          ],
+          [
+            10,
+            17
+          ],
+          [
+            10,
+            17
+          ],
+          // 0000011000xx
+          [
+            12,
+            48
+          ],
+          // 000001100100
+          [
+            12,
+            49
+          ],
+          // 000001100101
+          [
+            12,
+            62
+          ],
+          // 000001100110
+          [
+            12,
+            63
+          ],
+          // 000001100111
+          [
+            12,
+            30
+          ],
+          // 000001101000
+          [
+            12,
+            31
+          ],
+          // 000001101001
+          [
+            12,
+            32
+          ],
+          // 000001101010
+          [
+            12,
+            33
+          ],
+          // 000001101011
+          [
+            12,
+            40
+          ],
+          // 000001101100
+          [
+            12,
+            41
+          ],
+          // 000001101101
+          [
+            11,
+            22
+          ],
+          [
+            11,
+            22
+          ],
+          // 00000110111x
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          // 00000111xxxx
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            8,
+            14
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          // 0000100xxxxx
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            10
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          // 0000101xxxxx
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            7,
+            11
+          ],
+          [
+            9,
+            15
+          ],
+          [
+            9,
+            15
+          ],
+          [
+            9,
+            15
+          ],
+          [
+            9,
+            15
+          ],
+          // 000011000xxx
+          [
+            9,
+            15
+          ],
+          [
+            9,
+            15
+          ],
+          [
+            9,
+            15
+          ],
+          [
+            9,
+            15
+          ],
+          [
+            12,
+            128
+          ],
+          // 000011001000
+          [
+            12,
+            192
+          ],
+          // 000011001001
+          [
+            12,
+            26
+          ],
+          // 000011001010
+          [
+            12,
+            27
+          ],
+          // 000011001011
+          [
+            12,
+            28
+          ],
+          // 000011001100
+          [
+            12,
+            29
+          ],
+          // 000011001101
+          [
+            11,
+            19
+          ],
+          [
+            11,
+            19
+          ],
+          // 00001100111x
+          [
+            11,
+            20
+          ],
+          [
+            11,
+            20
+          ],
+          // 00001101000x
+          [
+            12,
+            34
+          ],
+          // 000011010010
+          [
+            12,
+            35
+          ],
+          // 000011010011
+          [
+            12,
+            36
+          ],
+          // 000011010100
+          [
+            12,
+            37
+          ],
+          // 000011010101
+          [
+            12,
+            38
+          ],
+          // 000011010110
+          [
+            12,
+            39
+          ],
+          // 000011010111
+          [
+            11,
+            21
+          ],
+          [
+            11,
+            21
+          ],
+          // 00001101100x
+          [
+            12,
+            42
+          ],
+          // 000011011010
+          [
+            12,
+            43
+          ],
+          // 000011011011
+          [
+            10,
+            0
+          ],
+          [
+            10,
+            0
+          ],
+          [
+            10,
+            0
+          ],
+          [
+            10,
+            0
+          ],
+          // 0000110111xx
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          // 0000111xxxxx
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ],
+          [
+            7,
+            12
+          ]
+        ];
+        var blackTable3 = [
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          [
+            -1,
+            -1
+          ],
+          // 0000xx
+          [
+            6,
+            9
+          ],
+          // 000100
+          [
+            6,
+            8
+          ],
+          // 000101
+          [
+            5,
+            7
+          ],
+          [
+            5,
+            7
+          ],
+          // 00011x
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          [
+            4,
+            6
+          ],
+          // 0010xx
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          [
+            4,
+            5
+          ],
+          // 0011xx
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            1
+          ],
+          // 010xxx
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            1
+          ],
+          [
+            3,
+            4
+          ],
+          [
+            3,
+            4
+          ],
+          [
+            3,
+            4
+          ],
+          [
+            3,
+            4
+          ],
+          // 011xxx
+          [
+            3,
+            4
+          ],
+          [
+            3,
+            4
+          ],
+          [
+            3,
+            4
+          ],
+          [
+            3,
+            4
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          // 10xxxx
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            3
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          // 11xxxx
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ],
+          [
+            2,
+            2
+          ]
+        ];
+        function CCITTFaxStream(str, maybeLength, params) {
+          this.str = str;
+          this.dict = str.dict;
+          params = params || Dict.empty;
+          this.encoding = params.get('K') || 0;
+          this.eoline = params.get('EndOfLine') || false;
+          this.byteAlign = params.get('EncodedByteAlign') || false;
+          this.columns = params.get('Columns') || 1728;
+          this.rows = params.get('Rows') || 0;
+          var eoblock = params.get('EndOfBlock');
+          if (eoblock === null || eoblock === undefined) {
+            eoblock = true;
+          }
+          this.eoblock = eoblock;
+          this.black = params.get('BlackIs1') || false;
+          this.codingLine = new Uint32Array(this.columns + 1);
+          this.refLine = new Uint32Array(this.columns + 2);
+          this.codingLine[0] = this.columns;
+          this.codingPos = 0;
+          this.row = 0;
+          this.nextLine2D = this.encoding < 0;
+          this.inputBits = 0;
+          this.inputBuf = 0;
+          this.outputBits = 0;
+          var code1;
+          while ((code1 = this.lookBits(12)) === 0) {
+            this.eatBits(1);
+          }
+          if (code1 === 1) {
+            this.eatBits(12);
+          }
+          if (this.encoding > 0) {
+            this.nextLine2D = !this.lookBits(1);
+            this.eatBits(1);
+          }
+          DecodeStream.call(this, maybeLength);
+        }
+        CCITTFaxStream.prototype = Object.create(DecodeStream.prototype);
+        CCITTFaxStream.prototype.readBlock = function CCITTFaxStream_readBlock() {
+          while (!this.eof) {
+            var c = this.lookChar();
+            this.ensureBuffer(this.bufferLength + 1);
+            this.buffer[this.bufferLength++] = c;
+          }
+        };
+        CCITTFaxStream.prototype.addPixels = function ccittFaxStreamAddPixels(a1, blackPixels) {
+          var codingLine = this.codingLine;
+          var codingPos = this.codingPos;
+          if (a1 > codingLine[codingPos]) {
+            if (a1 > this.columns) {
+              info('row is wrong length');
+              this.err = true;
+              a1 = this.columns;
+            }
+            if (codingPos & 1 ^ blackPixels) {
+              ++codingPos;
+            }
+            codingLine[codingPos] = a1;
+          }
+          this.codingPos = codingPos;
+        };
+        CCITTFaxStream.prototype.addPixelsNeg = function ccittFaxStreamAddPixelsNeg(a1, blackPixels) {
+          var codingLine = this.codingLine;
+          var codingPos = this.codingPos;
+          if (a1 > codingLine[codingPos]) {
+            if (a1 > this.columns) {
+              info('row is wrong length');
+              this.err = true;
+              a1 = this.columns;
+            }
+            if (codingPos & 1 ^ blackPixels) {
+              ++codingPos;
+            }
+            codingLine[codingPos] = a1;
+          } else if (a1 < codingLine[codingPos]) {
+            if (a1 < 0) {
+              info('invalid code');
+              this.err = true;
+              a1 = 0;
+            }
+            while (codingPos > 0 && a1 < codingLine[codingPos - 1]) {
+              --codingPos;
+            }
+            codingLine[codingPos] = a1;
+          }
+          this.codingPos = codingPos;
+        };
+        CCITTFaxStream.prototype.lookChar = function CCITTFaxStream_lookChar() {
+          var refLine = this.refLine;
+          var codingLine = this.codingLine;
+          var columns = this.columns;
+          var refPos, blackPixels, bits, i;
+          if (this.outputBits === 0) {
+            if (this.eof) {
+              return null;
+            }
+            this.err = false;
+            var code1, code2, code3;
+            if (this.nextLine2D) {
+              for (i = 0; codingLine[i] < columns; ++i) {
+                refLine[i] = codingLine[i];
+              }
+              refLine[i++] = columns;
+              refLine[i] = columns;
+              codingLine[0] = 0;
+              this.codingPos = 0;
+              refPos = 0;
+              blackPixels = 0;
+              while (codingLine[this.codingPos] < columns) {
+                code1 = this.getTwoDimCode();
+                switch (code1) {
+                case twoDimPass:
+                  this.addPixels(refLine[refPos + 1], blackPixels);
+                  if (refLine[refPos + 1] < columns) {
+                    refPos += 2;
+                  }
+                  break;
+                case twoDimHoriz:
+                  code1 = code2 = 0;
+                  if (blackPixels) {
+                    do {
+                      code1 += code3 = this.getBlackCode();
+                    } while (code3 >= 64);
+                    do {
+                      code2 += code3 = this.getWhiteCode();
+                    } while (code3 >= 64);
+                  } else {
+                    do {
+                      code1 += code3 = this.getWhiteCode();
+                    } while (code3 >= 64);
+                    do {
+                      code2 += code3 = this.getBlackCode();
+                    } while (code3 >= 64);
+                  }
+                  this.addPixels(codingLine[this.codingPos] + code1, blackPixels);
+                  if (codingLine[this.codingPos] < columns) {
+                    this.addPixels(codingLine[this.codingPos] + code2, blackPixels ^ 1);
+                  }
+                  while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                    refPos += 2;
+                  }
+                  break;
+                case twoDimVertR3:
+                  this.addPixels(refLine[refPos] + 3, blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    ++refPos;
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case twoDimVertR2:
+                  this.addPixels(refLine[refPos] + 2, blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    ++refPos;
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case twoDimVertR1:
+                  this.addPixels(refLine[refPos] + 1, blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    ++refPos;
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case twoDimVert0:
+                  this.addPixels(refLine[refPos], blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    ++refPos;
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case twoDimVertL3:
+                  this.addPixelsNeg(refLine[refPos] - 3, blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    if (refPos > 0) {
+                      --refPos;
+                    } else {
+                      ++refPos;
+                    }
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case twoDimVertL2:
+                  this.addPixelsNeg(refLine[refPos] - 2, blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    if (refPos > 0) {
+                      --refPos;
+                    } else {
+                      ++refPos;
+                    }
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case twoDimVertL1:
+                  this.addPixelsNeg(refLine[refPos] - 1, blackPixels);
+                  blackPixels ^= 1;
+                  if (codingLine[this.codingPos] < columns) {
+                    if (refPos > 0) {
+                      --refPos;
+                    } else {
+                      ++refPos;
+                    }
+                    while (refLine[refPos] <= codingLine[this.codingPos] && refLine[refPos] < columns) {
+                      refPos += 2;
+                    }
+                  }
+                  break;
+                case ccittEOF:
+                  this.addPixels(columns, 0);
+                  this.eof = true;
+                  break;
+                default:
+                  info('bad 2d code');
+                  this.addPixels(columns, 0);
+                  this.err = true;
+                }
+              }
+            } else {
+              codingLine[0] = 0;
+              this.codingPos = 0;
+              blackPixels = 0;
+              while (codingLine[this.codingPos] < columns) {
+                code1 = 0;
+                if (blackPixels) {
+                  do {
+                    code1 += code3 = this.getBlackCode();
+                  } while (code3 >= 64);
+                } else {
+                  do {
+                    code1 += code3 = this.getWhiteCode();
+                  } while (code3 >= 64);
+                }
+                this.addPixels(codingLine[this.codingPos] + code1, blackPixels);
+                blackPixels ^= 1;
+              }
+            }
+            var gotEOL = false;
+            if (this.byteAlign) {
+              this.inputBits &= ~7;
+            }
+            if (!this.eoblock && this.row === this.rows - 1) {
+              this.eof = true;
+            } else {
+              code1 = this.lookBits(12);
+              if (this.eoline) {
+                while (code1 !== ccittEOF && code1 !== 1) {
+                  this.eatBits(1);
+                  code1 = this.lookBits(12);
+                }
+              } else {
+                while (code1 === 0) {
+                  this.eatBits(1);
+                  code1 = this.lookBits(12);
+                }
+              }
+              if (code1 === 1) {
+                this.eatBits(12);
+                gotEOL = true;
+              } else if (code1 === ccittEOF) {
+                this.eof = true;
+              }
+            }
+            if (!this.eof && this.encoding > 0) {
+              this.nextLine2D = !this.lookBits(1);
+              this.eatBits(1);
+            }
+            if (this.eoblock && gotEOL && this.byteAlign) {
+              code1 = this.lookBits(12);
+              if (code1 === 1) {
+                this.eatBits(12);
+                if (this.encoding > 0) {
+                  this.lookBits(1);
+                  this.eatBits(1);
+                }
+                if (this.encoding >= 0) {
+                  for (i = 0; i < 4; ++i) {
+                    code1 = this.lookBits(12);
+                    if (code1 !== 1) {
+                      info('bad rtc code: ' + code1);
+                    }
+                    this.eatBits(12);
+                    if (this.encoding > 0) {
+                      this.lookBits(1);
+                      this.eatBits(1);
+                    }
+                  }
+                }
+                this.eof = true;
+              }
+            } else if (this.err && this.eoline) {
+              while (true) {
+                code1 = this.lookBits(13);
+                if (code1 === ccittEOF) {
+                  this.eof = true;
+                  return null;
+                }
+                if (code1 >> 1 === 1) {
+                  break;
+                }
+                this.eatBits(1);
+              }
+              this.eatBits(12);
+              if (this.encoding > 0) {
+                this.eatBits(1);
+                this.nextLine2D = !(code1 & 1);
+              }
+            }
+            if (codingLine[0] > 0) {
+              this.outputBits = codingLine[this.codingPos = 0];
+            } else {
+              this.outputBits = codingLine[this.codingPos = 1];
+            }
+            this.row++;
+          }
+          var c;
+          if (this.outputBits >= 8) {
+            c = this.codingPos & 1 ? 0 : 0xFF;
+            this.outputBits -= 8;
+            if (this.outputBits === 0 && codingLine[this.codingPos] < columns) {
+              this.codingPos++;
+              this.outputBits = codingLine[this.codingPos] - codingLine[this.codingPos - 1];
+            }
+          } else {
+            bits = 8;
+            c = 0;
+            do {
+              if (this.outputBits > bits) {
+                c <<= bits;
+                if (!(this.codingPos & 1)) {
+                  c |= 0xFF >> 8 - bits;
+                }
+                this.outputBits -= bits;
+                bits = 0;
+              } else {
+                c <<= this.outputBits;
+                if (!(this.codingPos & 1)) {
+                  c |= 0xFF >> 8 - this.outputBits;
+                }
+                bits -= this.outputBits;
+                this.outputBits = 0;
+                if (codingLine[this.codingPos] < columns) {
+                  this.codingPos++;
+                  this.outputBits = codingLine[this.codingPos] - codingLine[this.codingPos - 1];
+                } else if (bits > 0) {
+                  c <<= bits;
+                  bits = 0;
+                }
+              }
+            } while (bits);
+          }
+          if (this.black) {
+            c ^= 0xFF;
+          }
+          return c;
+        };
+        // This functions returns the code found from the table.
+        // The start and end parameters set the boundaries for searching the table.
+        // The limit parameter is optional. Function returns an array with three
+        // values. The first array element indicates whether a valid code is being
+        // returned. The second array element is the actual code. The third array
+        // element indicates whether EOF was reached.
+        CCITTFaxStream.prototype.findTableCode = function ccittFaxStreamFindTableCode(start, end, table, limit) {
+          var limitValue = limit || 0;
+          for (var i = start; i <= end; ++i) {
+            var code = this.lookBits(i);
+            if (code === ccittEOF) {
+              return [
+                true,
+                1,
+                false
+              ];
+            }
+            if (i < end) {
+              code <<= end - i;
+            }
+            if (!limitValue || code >= limitValue) {
+              var p = table[code - limitValue];
+              if (p[0] === i) {
+                this.eatBits(i);
+                return [
+                  true,
+                  p[1],
+                  true
+                ];
+              }
+            }
+          }
+          return [
+            false,
+            0,
+            false
+          ];
+        };
+        CCITTFaxStream.prototype.getTwoDimCode = function ccittFaxStreamGetTwoDimCode() {
+          var code = 0;
+          var p;
+          if (this.eoblock) {
+            code = this.lookBits(7);
+            p = twoDimTable[code];
+            if (p && p[0] > 0) {
+              this.eatBits(p[0]);
+              return p[1];
+            }
+          } else {
+            var result = this.findTableCode(1, 7, twoDimTable);
+            if (result[0] && result[2]) {
+              return result[1];
+            }
+          }
+          info('Bad two dim code');
+          return ccittEOF;
+        };
+        CCITTFaxStream.prototype.getWhiteCode = function ccittFaxStreamGetWhiteCode() {
+          var code = 0;
+          var p;
+          if (this.eoblock) {
+            code = this.lookBits(12);
+            if (code === ccittEOF) {
+              return 1;
+            }
+            if (code >> 5 === 0) {
+              p = whiteTable1[code];
+            } else {
+              p = whiteTable2[code >> 3];
+            }
+            if (p[0] > 0) {
+              this.eatBits(p[0]);
+              return p[1];
+            }
+          } else {
+            var result = this.findTableCode(1, 9, whiteTable2);
+            if (result[0]) {
+              return result[1];
+            }
+            result = this.findTableCode(11, 12, whiteTable1);
+            if (result[0]) {
+              return result[1];
+            }
+          }
+          info('bad white code');
+          this.eatBits(1);
+          return 1;
+        };
+        CCITTFaxStream.prototype.getBlackCode = function ccittFaxStreamGetBlackCode() {
+          var code, p;
+          if (this.eoblock) {
+            code = this.lookBits(13);
+            if (code === ccittEOF) {
+              return 1;
+            }
+            if (code >> 7 === 0) {
+              p = blackTable1[code];
+            } else if (code >> 9 === 0 && code >> 7 !== 0) {
+              p = blackTable2[(code >> 1) - 64];
+            } else {
+              p = blackTable3[code >> 7];
+            }
+            if (p[0] > 0) {
+              this.eatBits(p[0]);
+              return p[1];
+            }
+          } else {
+            var result = this.findTableCode(2, 6, blackTable3);
+            if (result[0]) {
+              return result[1];
+            }
+            result = this.findTableCode(7, 12, blackTable2, 64);
+            if (result[0]) {
+              return result[1];
+            }
+            result = this.findTableCode(10, 13, blackTable1);
+            if (result[0]) {
+              return result[1];
+            }
+          }
+          info('bad black code');
+          this.eatBits(1);
+          return 1;
+        };
+        CCITTFaxStream.prototype.lookBits = function CCITTFaxStream_lookBits(n) {
+          var c;
+          while (this.inputBits < n) {
+            if ((c = this.str.getByte()) === -1) {
+              if (this.inputBits === 0) {
+                return ccittEOF;
+              }
+              return this.inputBuf << n - this.inputBits & 0xFFFF >> 16 - n;
+            }
+            this.inputBuf = this.inputBuf << 8 | c;
+            this.inputBits += 8;
+          }
+          return this.inputBuf >> this.inputBits - n & 0xFFFF >> 16 - n;
+        };
+        CCITTFaxStream.prototype.eatBits = function CCITTFaxStream_eatBits(n) {
+          if ((this.inputBits -= n) < 0) {
+            this.inputBits = 0;
+          }
+        };
+        return CCITTFaxStream;
+      }();
+      var LZWStream = function LZWStreamClosure() {
+        function LZWStream(str, maybeLength, earlyChange) {
+          this.str = str;
+          this.dict = str.dict;
+          this.cachedData = 0;
+          this.bitsCached = 0;
+          var maxLzwDictionarySize = 4096;
+          var lzwState = {
+            earlyChange: earlyChange,
+            codeLength: 9,
+            nextCode: 258,
+            dictionaryValues: new Uint8Array(maxLzwDictionarySize),
+            dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
+            dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
+            currentSequence: new Uint8Array(maxLzwDictionarySize),
+            currentSequenceLength: 0
+          };
+          for (var i = 0; i < 256; ++i) {
+            lzwState.dictionaryValues[i] = i;
+            lzwState.dictionaryLengths[i] = 1;
+          }
+          this.lzwState = lzwState;
+          DecodeStream.call(this, maybeLength);
+        }
+        LZWStream.prototype = Object.create(DecodeStream.prototype);
+        LZWStream.prototype.readBits = function LZWStream_readBits(n) {
+          var bitsCached = this.bitsCached;
+          var cachedData = this.cachedData;
+          while (bitsCached < n) {
+            var c = this.str.getByte();
+            if (c === -1) {
+              this.eof = true;
+              return null;
+            }
+            cachedData = cachedData << 8 | c;
+            bitsCached += 8;
+          }
+          this.bitsCached = bitsCached -= n;
+          this.cachedData = cachedData;
+          this.lastCode = null;
+          return cachedData >>> bitsCached & (1 << n) - 1;
+        };
+        LZWStream.prototype.readBlock = function LZWStream_readBlock() {
+          var blockSize = 512;
+          var estimatedDecodedSize = blockSize * 2, decodedSizeDelta = blockSize;
+          var i, j, q;
+          var lzwState = this.lzwState;
+          if (!lzwState) {
+            return;
+          }
+          // eof was found
+          var earlyChange = lzwState.earlyChange;
+          var nextCode = lzwState.nextCode;
+          var dictionaryValues = lzwState.dictionaryValues;
+          var dictionaryLengths = lzwState.dictionaryLengths;
+          var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
+          var codeLength = lzwState.codeLength;
+          var prevCode = lzwState.prevCode;
+          var currentSequence = lzwState.currentSequence;
+          var currentSequenceLength = lzwState.currentSequenceLength;
+          var decodedLength = 0;
+          var currentBufferLength = this.bufferLength;
+          var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
+          for (i = 0; i < blockSize; i++) {
+            var code = this.readBits(codeLength);
+            var hasPrev = currentSequenceLength > 0;
+            if (code < 256) {
+              currentSequence[0] = code;
+              currentSequenceLength = 1;
+            } else if (code >= 258) {
+              if (code < nextCode) {
+                currentSequenceLength = dictionaryLengths[code];
+                for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {
+                  currentSequence[j] = dictionaryValues[q];
+                  q = dictionaryPrevCodes[q];
+                }
+              } else {
+                currentSequence[currentSequenceLength++] = currentSequence[0];
+              }
+            } else if (code === 256) {
+              codeLength = 9;
+              nextCode = 258;
+              currentSequenceLength = 0;
+              continue;
+            } else {
+              this.eof = true;
+              delete this.lzwState;
+              break;
+            }
+            if (hasPrev) {
+              dictionaryPrevCodes[nextCode] = prevCode;
+              dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1;
+              dictionaryValues[nextCode] = currentSequence[0];
+              nextCode++;
+              codeLength = nextCode + earlyChange & nextCode + earlyChange - 1 ? codeLength : Math.min(Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1, 12) | 0;
+            }
+            prevCode = code;
+            decodedLength += currentSequenceLength;
+            if (estimatedDecodedSize < decodedLength) {
+              do {
+                estimatedDecodedSize += decodedSizeDelta;
+              } while (estimatedDecodedSize < decodedLength);
+              buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
+            }
+            for (j = 0; j < currentSequenceLength; j++) {
+              buffer[currentBufferLength++] = currentSequence[j];
+            }
+          }
+          lzwState.nextCode = nextCode;
+          lzwState.codeLength = codeLength;
+          lzwState.prevCode = prevCode;
+          lzwState.currentSequenceLength = currentSequenceLength;
+          this.bufferLength = currentBufferLength;
+        };
+        return LZWStream;
+      }();
+      var NullStream = function NullStreamClosure() {
+        function NullStream() {
+          Stream.call(this, new Uint8Array(0));
+        }
+        NullStream.prototype = Stream.prototype;
+        return NullStream;
+      }();
+      exports.Ascii85Stream = Ascii85Stream;
+      exports.AsciiHexStream = AsciiHexStream;
+      exports.CCITTFaxStream = CCITTFaxStream;
+      exports.DecryptStream = DecryptStream;
+      exports.DecodeStream = DecodeStream;
+      exports.FlateStream = FlateStream;
+      exports.Jbig2Stream = Jbig2Stream;
+      exports.JpegStream = JpegStream;
+      exports.JpxStream = JpxStream;
+      exports.NullStream = NullStream;
+      exports.PredictorStream = PredictorStream;
+      exports.RunLengthStream = RunLengthStream;
+      exports.Stream = Stream;
+      exports.StreamsSequenceStream = StreamsSequenceStream;
+      exports.StringStream = StringStream;
+      exports.LZWStream = LZWStream;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreCrypto = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream) {
+      var PasswordException = sharedUtil.PasswordException;
+      var PasswordResponses = sharedUtil.PasswordResponses;
+      var bytesToString = sharedUtil.bytesToString;
+      var warn = sharedUtil.warn;
+      var error = sharedUtil.error;
+      var assert = sharedUtil.assert;
+      var isInt = sharedUtil.isInt;
+      var stringToBytes = sharedUtil.stringToBytes;
+      var utf8StringToString = sharedUtil.utf8StringToString;
+      var Name = corePrimitives.Name;
+      var isName = corePrimitives.isName;
+      var isDict = corePrimitives.isDict;
+      var DecryptStream = coreStream.DecryptStream;
+      var ARCFourCipher = function ARCFourCipherClosure() {
+        function ARCFourCipher(key) {
+          this.a = 0;
+          this.b = 0;
+          var s = new Uint8Array(256);
+          var i, j = 0, tmp, keyLength = key.length;
+          for (i = 0; i < 256; ++i) {
+            s[i] = i;
+          }
+          for (i = 0; i < 256; ++i) {
+            tmp = s[i];
+            j = j + tmp + key[i % keyLength] & 0xFF;
+            s[i] = s[j];
+            s[j] = tmp;
+          }
+          this.s = s;
+        }
+        ARCFourCipher.prototype = {
+          encryptBlock: function ARCFourCipher_encryptBlock(data) {
+            var i, n = data.length, tmp, tmp2;
+            var a = this.a, b = this.b, s = this.s;
+            var output = new Uint8Array(n);
+            for (i = 0; i < n; ++i) {
+              a = a + 1 & 0xFF;
+              tmp = s[a];
+              b = b + tmp & 0xFF;
+              tmp2 = s[b];
+              s[a] = tmp2;
+              s[b] = tmp;
+              output[i] = data[i] ^ s[tmp + tmp2 & 0xFF];
+            }
+            this.a = a;
+            this.b = b;
+            return output;
+          }
+        };
+        ARCFourCipher.prototype.decryptBlock = ARCFourCipher.prototype.encryptBlock;
+        return ARCFourCipher;
+      }();
+      var calculateMD5 = function calculateMD5Closure() {
+        var r = new Uint8Array([
+          7,
+          12,
+          17,
+          22,
+          7,
+          12,
+          17,
+          22,
+          7,
+          12,
+          17,
+          22,
+          7,
+          12,
+          17,
+          22,
+          5,
+          9,
+          14,
+          20,
+          5,
+          9,
+          14,
+          20,
+          5,
+          9,
+          14,
+          20,
+          5,
+          9,
+          14,
+          20,
+          4,
+          11,
+          16,
+          23,
+          4,
+          11,
+          16,
+          23,
+          4,
+          11,
+          16,
+          23,
+          4,
+          11,
+          16,
+          23,
+          6,
+          10,
+          15,
+          21,
+          6,
+          10,
+          15,
+          21,
+          6,
+          10,
+          15,
+          21,
+          6,
+          10,
+          15,
+          21
+        ]);
+        var k = new Int32Array([
+          -680876936,
+          -389564586,
+          606105819,
+          -1044525330,
+          -176418897,
+          1200080426,
+          -1473231341,
+          -45705983,
+          1770035416,
+          -1958414417,
+          -42063,
+          -1990404162,
+          1804603682,
+          -40341101,
+          -1502002290,
+          1236535329,
+          -165796510,
+          -1069501632,
+          643717713,
+          -373897302,
+          -701558691,
+          38016083,
+          -660478335,
+          -405537848,
+          568446438,
+          -1019803690,
+          -187363961,
+          1163531501,
+          -1444681467,
+          -51403784,
+          1735328473,
+          -1926607734,
+          -378558,
+          -2022574463,
+          1839030562,
+          -35309556,
+          -1530992060,
+          1272893353,
+          -155497632,
+          -1094730640,
+          681279174,
+          -358537222,
+          -722521979,
+          76029189,
+          -640364487,
+          -421815835,
+          530742520,
+          -995338651,
+          -198630844,
+          1126891415,
+          -1416354905,
+          -57434055,
+          1700485571,
+          -1894986606,
+          -1051523,
+          -2054922799,
+          1873313359,
+          -30611744,
+          -1560198380,
+          1309151649,
+          -145523070,
+          -1120210379,
+          718787259,
+          -343485551
+        ]);
+        function hash(data, offset, length) {
+          var h0 = 1732584193, h1 = -271733879, h2 = -1732584194, h3 = 271733878;
+          // pre-processing
+          var paddedLength = length + 72 & ~63;
+          // data + 9 extra bytes
+          var padded = new Uint8Array(paddedLength);
+          var i, j, n;
+          for (i = 0; i < length; ++i) {
+            padded[i] = data[offset++];
+          }
+          padded[i++] = 0x80;
+          n = paddedLength - 8;
+          while (i < n) {
+            padded[i++] = 0;
+          }
+          padded[i++] = length << 3 & 0xFF;
+          padded[i++] = length >> 5 & 0xFF;
+          padded[i++] = length >> 13 & 0xFF;
+          padded[i++] = length >> 21 & 0xFF;
+          padded[i++] = length >>> 29 & 0xFF;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          var w = new Int32Array(16);
+          for (i = 0; i < paddedLength;) {
+            for (j = 0; j < 16; ++j, i += 4) {
+              w[j] = padded[i] | padded[i + 1] << 8 | padded[i + 2] << 16 | padded[i + 3] << 24;
+            }
+            var a = h0, b = h1, c = h2, d = h3, f, g;
+            for (j = 0; j < 64; ++j) {
+              if (j < 16) {
+                f = b & c | ~b & d;
+                g = j;
+              } else if (j < 32) {
+                f = d & b | ~d & c;
+                g = 5 * j + 1 & 15;
+              } else if (j < 48) {
+                f = b ^ c ^ d;
+                g = 3 * j + 5 & 15;
+              } else {
+                f = c ^ (b | ~d);
+                g = 7 * j & 15;
+              }
+              var tmp = d, rotateArg = a + f + k[j] + w[g] | 0, rotate = r[j];
+              d = c;
+              c = b;
+              b = b + (rotateArg << rotate | rotateArg >>> 32 - rotate) | 0;
+              a = tmp;
+            }
+            h0 = h0 + a | 0;
+            h1 = h1 + b | 0;
+            h2 = h2 + c | 0;
+            h3 = h3 + d | 0;
+          }
+          return new Uint8Array([
+            h0 & 0xFF,
+            h0 >> 8 & 0xFF,
+            h0 >> 16 & 0xFF,
+            h0 >>> 24 & 0xFF,
+            h1 & 0xFF,
+            h1 >> 8 & 0xFF,
+            h1 >> 16 & 0xFF,
+            h1 >>> 24 & 0xFF,
+            h2 & 0xFF,
+            h2 >> 8 & 0xFF,
+            h2 >> 16 & 0xFF,
+            h2 >>> 24 & 0xFF,
+            h3 & 0xFF,
+            h3 >> 8 & 0xFF,
+            h3 >> 16 & 0xFF,
+            h3 >>> 24 & 0xFF
+          ]);
+        }
+        return hash;
+      }();
+      var Word64 = function Word64Closure() {
+        function Word64(highInteger, lowInteger) {
+          this.high = highInteger | 0;
+          this.low = lowInteger | 0;
+        }
+        Word64.prototype = {
+          and: function Word64_and(word) {
+            this.high &= word.high;
+            this.low &= word.low;
+          },
+          xor: function Word64_xor(word) {
+            this.high ^= word.high;
+            this.low ^= word.low;
+          },
+          or: function Word64_or(word) {
+            this.high |= word.high;
+            this.low |= word.low;
+          },
+          shiftRight: function Word64_shiftRight(places) {
+            if (places >= 32) {
+              this.low = this.high >>> places - 32 | 0;
+              this.high = 0;
+            } else {
+              this.low = this.low >>> places | this.high << 32 - places;
+              this.high = this.high >>> places | 0;
+            }
+          },
+          shiftLeft: function Word64_shiftLeft(places) {
+            if (places >= 32) {
+              this.high = this.low << places - 32;
+              this.low = 0;
+            } else {
+              this.high = this.high << places | this.low >>> 32 - places;
+              this.low = this.low << places;
+            }
+          },
+          rotateRight: function Word64_rotateRight(places) {
+            var low, high;
+            if (places & 32) {
+              high = this.low;
+              low = this.high;
+            } else {
+              low = this.low;
+              high = this.high;
+            }
+            places &= 31;
+            this.low = low >>> places | high << 32 - places;
+            this.high = high >>> places | low << 32 - places;
+          },
+          not: function Word64_not() {
+            this.high = ~this.high;
+            this.low = ~this.low;
+          },
+          add: function Word64_add(word) {
+            var lowAdd = (this.low >>> 0) + (word.low >>> 0);
+            var highAdd = (this.high >>> 0) + (word.high >>> 0);
+            if (lowAdd > 0xFFFFFFFF) {
+              highAdd += 1;
+            }
+            this.low = lowAdd | 0;
+            this.high = highAdd | 0;
+          },
+          copyTo: function Word64_copyTo(bytes, offset) {
+            bytes[offset] = this.high >>> 24 & 0xFF;
+            bytes[offset + 1] = this.high >> 16 & 0xFF;
+            bytes[offset + 2] = this.high >> 8 & 0xFF;
+            bytes[offset + 3] = this.high & 0xFF;
+            bytes[offset + 4] = this.low >>> 24 & 0xFF;
+            bytes[offset + 5] = this.low >> 16 & 0xFF;
+            bytes[offset + 6] = this.low >> 8 & 0xFF;
+            bytes[offset + 7] = this.low & 0xFF;
+          },
+          assign: function Word64_assign(word) {
+            this.high = word.high;
+            this.low = word.low;
+          }
+        };
+        return Word64;
+      }();
+      var calculateSHA256 = function calculateSHA256Closure() {
+        function rotr(x, n) {
+          return x >>> n | x << 32 - n;
+        }
+        function ch(x, y, z) {
+          return x & y ^ ~x & z;
+        }
+        function maj(x, y, z) {
+          return x & y ^ x & z ^ y & z;
+        }
+        function sigma(x) {
+          return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
+        }
+        function sigmaPrime(x) {
+          return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
+        }
+        function littleSigma(x) {
+          return rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3;
+        }
+        function littleSigmaPrime(x) {
+          return rotr(x, 17) ^ rotr(x, 19) ^ x >>> 10;
+        }
+        var k = [
+          0x428a2f98,
+          0x71374491,
+          0xb5c0fbcf,
+          0xe9b5dba5,
+          0x3956c25b,
+          0x59f111f1,
+          0x923f82a4,
+          0xab1c5ed5,
+          0xd807aa98,
+          0x12835b01,
+          0x243185be,
+          0x550c7dc3,
+          0x72be5d74,
+          0x80deb1fe,
+          0x9bdc06a7,
+          0xc19bf174,
+          0xe49b69c1,
+          0xefbe4786,
+          0x0fc19dc6,
+          0x240ca1cc,
+          0x2de92c6f,
+          0x4a7484aa,
+          0x5cb0a9dc,
+          0x76f988da,
+          0x983e5152,
+          0xa831c66d,
+          0xb00327c8,
+          0xbf597fc7,
+          0xc6e00bf3,
+          0xd5a79147,
+          0x06ca6351,
+          0x14292967,
+          0x27b70a85,
+          0x2e1b2138,
+          0x4d2c6dfc,
+          0x53380d13,
+          0x650a7354,
+          0x766a0abb,
+          0x81c2c92e,
+          0x92722c85,
+          0xa2bfe8a1,
+          0xa81a664b,
+          0xc24b8b70,
+          0xc76c51a3,
+          0xd192e819,
+          0xd6990624,
+          0xf40e3585,
+          0x106aa070,
+          0x19a4c116,
+          0x1e376c08,
+          0x2748774c,
+          0x34b0bcb5,
+          0x391c0cb3,
+          0x4ed8aa4a,
+          0x5b9cca4f,
+          0x682e6ff3,
+          0x748f82ee,
+          0x78a5636f,
+          0x84c87814,
+          0x8cc70208,
+          0x90befffa,
+          0xa4506ceb,
+          0xbef9a3f7,
+          0xc67178f2
+        ];
+        function hash(data, offset, length) {
+          // initial hash values
+          var h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a, h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+          // pre-processing
+          var paddedLength = Math.ceil((length + 9) / 64) * 64;
+          var padded = new Uint8Array(paddedLength);
+          var i, j, n;
+          for (i = 0; i < length; ++i) {
+            padded[i] = data[offset++];
+          }
+          padded[i++] = 0x80;
+          n = paddedLength - 8;
+          while (i < n) {
+            padded[i++] = 0;
+          }
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = length >>> 29 & 0xFF;
+          padded[i++] = length >> 21 & 0xFF;
+          padded[i++] = length >> 13 & 0xFF;
+          padded[i++] = length >> 5 & 0xFF;
+          padded[i++] = length << 3 & 0xFF;
+          var w = new Uint32Array(64);
+          // for each 512 bit block
+          for (i = 0; i < paddedLength;) {
+            for (j = 0; j < 16; ++j) {
+              w[j] = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
+              i += 4;
+            }
+            for (j = 16; j < 64; ++j) {
+              w[j] = littleSigmaPrime(w[j - 2]) + w[j - 7] + littleSigma(w[j - 15]) + w[j - 16] | 0;
+            }
+            var a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7, t1, t2;
+            for (j = 0; j < 64; ++j) {
+              t1 = h + sigmaPrime(e) + ch(e, f, g) + k[j] + w[j];
+              t2 = sigma(a) + maj(a, b, c);
+              h = g;
+              g = f;
+              f = e;
+              e = d + t1 | 0;
+              d = c;
+              c = b;
+              b = a;
+              a = t1 + t2 | 0;
+            }
+            h0 = h0 + a | 0;
+            h1 = h1 + b | 0;
+            h2 = h2 + c | 0;
+            h3 = h3 + d | 0;
+            h4 = h4 + e | 0;
+            h5 = h5 + f | 0;
+            h6 = h6 + g | 0;
+            h7 = h7 + h | 0;
+          }
+          return new Uint8Array([
+            h0 >> 24 & 0xFF,
+            h0 >> 16 & 0xFF,
+            h0 >> 8 & 0xFF,
+            h0 & 0xFF,
+            h1 >> 24 & 0xFF,
+            h1 >> 16 & 0xFF,
+            h1 >> 8 & 0xFF,
+            h1 & 0xFF,
+            h2 >> 24 & 0xFF,
+            h2 >> 16 & 0xFF,
+            h2 >> 8 & 0xFF,
+            h2 & 0xFF,
+            h3 >> 24 & 0xFF,
+            h3 >> 16 & 0xFF,
+            h3 >> 8 & 0xFF,
+            h3 & 0xFF,
+            h4 >> 24 & 0xFF,
+            h4 >> 16 & 0xFF,
+            h4 >> 8 & 0xFF,
+            h4 & 0xFF,
+            h5 >> 24 & 0xFF,
+            h5 >> 16 & 0xFF,
+            h5 >> 8 & 0xFF,
+            h5 & 0xFF,
+            h6 >> 24 & 0xFF,
+            h6 >> 16 & 0xFF,
+            h6 >> 8 & 0xFF,
+            h6 & 0xFF,
+            h7 >> 24 & 0xFF,
+            h7 >> 16 & 0xFF,
+            h7 >> 8 & 0xFF,
+            h7 & 0xFF
+          ]);
+        }
+        return hash;
+      }();
+      var calculateSHA512 = function calculateSHA512Closure() {
+        function ch(result, x, y, z, tmp) {
+          result.assign(x);
+          result.and(y);
+          tmp.assign(x);
+          tmp.not();
+          tmp.and(z);
+          result.xor(tmp);
+        }
+        function maj(result, x, y, z, tmp) {
+          result.assign(x);
+          result.and(y);
+          tmp.assign(x);
+          tmp.and(z);
+          result.xor(tmp);
+          tmp.assign(y);
+          tmp.and(z);
+          result.xor(tmp);
+        }
+        function sigma(result, x, tmp) {
+          result.assign(x);
+          result.rotateRight(28);
+          tmp.assign(x);
+          tmp.rotateRight(34);
+          result.xor(tmp);
+          tmp.assign(x);
+          tmp.rotateRight(39);
+          result.xor(tmp);
+        }
+        function sigmaPrime(result, x, tmp) {
+          result.assign(x);
+          result.rotateRight(14);
+          tmp.assign(x);
+          tmp.rotateRight(18);
+          result.xor(tmp);
+          tmp.assign(x);
+          tmp.rotateRight(41);
+          result.xor(tmp);
+        }
+        function littleSigma(result, x, tmp) {
+          result.assign(x);
+          result.rotateRight(1);
+          tmp.assign(x);
+          tmp.rotateRight(8);
+          result.xor(tmp);
+          tmp.assign(x);
+          tmp.shiftRight(7);
+          result.xor(tmp);
+        }
+        function littleSigmaPrime(result, x, tmp) {
+          result.assign(x);
+          result.rotateRight(19);
+          tmp.assign(x);
+          tmp.rotateRight(61);
+          result.xor(tmp);
+          tmp.assign(x);
+          tmp.shiftRight(6);
+          result.xor(tmp);
+        }
+        var k = [
+          new Word64(0x428a2f98, 0xd728ae22),
+          new Word64(0x71374491, 0x23ef65cd),
+          new Word64(0xb5c0fbcf, 0xec4d3b2f),
+          new Word64(0xe9b5dba5, 0x8189dbbc),
+          new Word64(0x3956c25b, 0xf348b538),
+          new Word64(0x59f111f1, 0xb605d019),
+          new Word64(0x923f82a4, 0xaf194f9b),
+          new Word64(0xab1c5ed5, 0xda6d8118),
+          new Word64(0xd807aa98, 0xa3030242),
+          new Word64(0x12835b01, 0x45706fbe),
+          new Word64(0x243185be, 0x4ee4b28c),
+          new Word64(0x550c7dc3, 0xd5ffb4e2),
+          new Word64(0x72be5d74, 0xf27b896f),
+          new Word64(0x80deb1fe, 0x3b1696b1),
+          new Word64(0x9bdc06a7, 0x25c71235),
+          new Word64(0xc19bf174, 0xcf692694),
+          new Word64(0xe49b69c1, 0x9ef14ad2),
+          new Word64(0xefbe4786, 0x384f25e3),
+          new Word64(0x0fc19dc6, 0x8b8cd5b5),
+          new Word64(0x240ca1cc, 0x77ac9c65),
+          new Word64(0x2de92c6f, 0x592b0275),
+          new Word64(0x4a7484aa, 0x6ea6e483),
+          new Word64(0x5cb0a9dc, 0xbd41fbd4),
+          new Word64(0x76f988da, 0x831153b5),
+          new Word64(0x983e5152, 0xee66dfab),
+          new Word64(0xa831c66d, 0x2db43210),
+          new Word64(0xb00327c8, 0x98fb213f),
+          new Word64(0xbf597fc7, 0xbeef0ee4),
+          new Word64(0xc6e00bf3, 0x3da88fc2),
+          new Word64(0xd5a79147, 0x930aa725),
+          new Word64(0x06ca6351, 0xe003826f),
+          new Word64(0x14292967, 0x0a0e6e70),
+          new Word64(0x27b70a85, 0x46d22ffc),
+          new Word64(0x2e1b2138, 0x5c26c926),
+          new Word64(0x4d2c6dfc, 0x5ac42aed),
+          new Word64(0x53380d13, 0x9d95b3df),
+          new Word64(0x650a7354, 0x8baf63de),
+          new Word64(0x766a0abb, 0x3c77b2a8),
+          new Word64(0x81c2c92e, 0x47edaee6),
+          new Word64(0x92722c85, 0x1482353b),
+          new Word64(0xa2bfe8a1, 0x4cf10364),
+          new Word64(0xa81a664b, 0xbc423001),
+          new Word64(0xc24b8b70, 0xd0f89791),
+          new Word64(0xc76c51a3, 0x0654be30),
+          new Word64(0xd192e819, 0xd6ef5218),
+          new Word64(0xd6990624, 0x5565a910),
+          new Word64(0xf40e3585, 0x5771202a),
+          new Word64(0x106aa070, 0x32bbd1b8),
+          new Word64(0x19a4c116, 0xb8d2d0c8),
+          new Word64(0x1e376c08, 0x5141ab53),
+          new Word64(0x2748774c, 0xdf8eeb99),
+          new Word64(0x34b0bcb5, 0xe19b48a8),
+          new Word64(0x391c0cb3, 0xc5c95a63),
+          new Word64(0x4ed8aa4a, 0xe3418acb),
+          new Word64(0x5b9cca4f, 0x7763e373),
+          new Word64(0x682e6ff3, 0xd6b2b8a3),
+          new Word64(0x748f82ee, 0x5defb2fc),
+          new Word64(0x78a5636f, 0x43172f60),
+          new Word64(0x84c87814, 0xa1f0ab72),
+          new Word64(0x8cc70208, 0x1a6439ec),
+          new Word64(0x90befffa, 0x23631e28),
+          new Word64(0xa4506ceb, 0xde82bde9),
+          new Word64(0xbef9a3f7, 0xb2c67915),
+          new Word64(0xc67178f2, 0xe372532b),
+          new Word64(0xca273ece, 0xea26619c),
+          new Word64(0xd186b8c7, 0x21c0c207),
+          new Word64(0xeada7dd6, 0xcde0eb1e),
+          new Word64(0xf57d4f7f, 0xee6ed178),
+          new Word64(0x06f067aa, 0x72176fba),
+          new Word64(0x0a637dc5, 0xa2c898a6),
+          new Word64(0x113f9804, 0xbef90dae),
+          new Word64(0x1b710b35, 0x131c471b),
+          new Word64(0x28db77f5, 0x23047d84),
+          new Word64(0x32caab7b, 0x40c72493),
+          new Word64(0x3c9ebe0a, 0x15c9bebc),
+          new Word64(0x431d67c4, 0x9c100d4c),
+          new Word64(0x4cc5d4be, 0xcb3e42b6),
+          new Word64(0x597f299c, 0xfc657e2a),
+          new Word64(0x5fcb6fab, 0x3ad6faec),
+          new Word64(0x6c44198c, 0x4a475817)
+        ];
+        function hash(data, offset, length, mode384) {
+          mode384 = !!mode384;
+          // initial hash values
+          var h0, h1, h2, h3, h4, h5, h6, h7;
+          if (!mode384) {
+            h0 = new Word64(0x6a09e667, 0xf3bcc908);
+            h1 = new Word64(0xbb67ae85, 0x84caa73b);
+            h2 = new Word64(0x3c6ef372, 0xfe94f82b);
+            h3 = new Word64(0xa54ff53a, 0x5f1d36f1);
+            h4 = new Word64(0x510e527f, 0xade682d1);
+            h5 = new Word64(0x9b05688c, 0x2b3e6c1f);
+            h6 = new Word64(0x1f83d9ab, 0xfb41bd6b);
+            h7 = new Word64(0x5be0cd19, 0x137e2179);
+          } else {
+            // SHA384 is exactly the same
+            // except with different starting values and a trimmed result
+            h0 = new Word64(0xcbbb9d5d, 0xc1059ed8);
+            h1 = new Word64(0x629a292a, 0x367cd507);
+            h2 = new Word64(0x9159015a, 0x3070dd17);
+            h3 = new Word64(0x152fecd8, 0xf70e5939);
+            h4 = new Word64(0x67332667, 0xffc00b31);
+            h5 = new Word64(0x8eb44a87, 0x68581511);
+            h6 = new Word64(0xdb0c2e0d, 0x64f98fa7);
+            h7 = new Word64(0x47b5481d, 0xbefa4fa4);
+          }
+          // pre-processing
+          var paddedLength = Math.ceil((length + 17) / 128) * 128;
+          var padded = new Uint8Array(paddedLength);
+          var i, j, n;
+          for (i = 0; i < length; ++i) {
+            padded[i] = data[offset++];
+          }
+          padded[i++] = 0x80;
+          n = paddedLength - 16;
+          while (i < n) {
+            padded[i++] = 0;
+          }
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = 0;
+          padded[i++] = length >>> 29 & 0xFF;
+          padded[i++] = length >> 21 & 0xFF;
+          padded[i++] = length >> 13 & 0xFF;
+          padded[i++] = length >> 5 & 0xFF;
+          padded[i++] = length << 3 & 0xFF;
+          var w = new Array(80);
+          for (i = 0; i < 80; i++) {
+            w[i] = new Word64(0, 0);
+          }
+          var a = new Word64(0, 0), b = new Word64(0, 0), c = new Word64(0, 0);
+          var d = new Word64(0, 0), e = new Word64(0, 0), f = new Word64(0, 0);
+          var g = new Word64(0, 0), h = new Word64(0, 0);
+          var t1 = new Word64(0, 0), t2 = new Word64(0, 0);
+          var tmp1 = new Word64(0, 0), tmp2 = new Word64(0, 0), tmp3;
+          // for each 1024 bit block
+          for (i = 0; i < paddedLength;) {
+            for (j = 0; j < 16; ++j) {
+              w[j].high = padded[i] << 24 | padded[i + 1] << 16 | padded[i + 2] << 8 | padded[i + 3];
+              w[j].low = padded[i + 4] << 24 | padded[i + 5] << 16 | padded[i + 6] << 8 | padded[i + 7];
+              i += 8;
+            }
+            for (j = 16; j < 80; ++j) {
+              tmp3 = w[j];
+              littleSigmaPrime(tmp3, w[j - 2], tmp2);
+              tmp3.add(w[j - 7]);
+              littleSigma(tmp1, w[j - 15], tmp2);
+              tmp3.add(tmp1);
+              tmp3.add(w[j - 16]);
+            }
+            a.assign(h0);
+            b.assign(h1);
+            c.assign(h2);
+            d.assign(h3);
+            e.assign(h4);
+            f.assign(h5);
+            g.assign(h6);
+            h.assign(h7);
+            for (j = 0; j < 80; ++j) {
+              t1.assign(h);
+              sigmaPrime(tmp1, e, tmp2);
+              t1.add(tmp1);
+              ch(tmp1, e, f, g, tmp2);
+              t1.add(tmp1);
+              t1.add(k[j]);
+              t1.add(w[j]);
+              sigma(t2, a, tmp2);
+              maj(tmp1, a, b, c, tmp2);
+              t2.add(tmp1);
+              tmp3 = h;
+              h = g;
+              g = f;
+              f = e;
+              d.add(t1);
+              e = d;
+              d = c;
+              c = b;
+              b = a;
+              tmp3.assign(t1);
+              tmp3.add(t2);
+              a = tmp3;
+            }
+            h0.add(a);
+            h1.add(b);
+            h2.add(c);
+            h3.add(d);
+            h4.add(e);
+            h5.add(f);
+            h6.add(g);
+            h7.add(h);
+          }
+          var result;
+          if (!mode384) {
+            result = new Uint8Array(64);
+            h0.copyTo(result, 0);
+            h1.copyTo(result, 8);
+            h2.copyTo(result, 16);
+            h3.copyTo(result, 24);
+            h4.copyTo(result, 32);
+            h5.copyTo(result, 40);
+            h6.copyTo(result, 48);
+            h7.copyTo(result, 56);
+          } else {
+            result = new Uint8Array(48);
+            h0.copyTo(result, 0);
+            h1.copyTo(result, 8);
+            h2.copyTo(result, 16);
+            h3.copyTo(result, 24);
+            h4.copyTo(result, 32);
+            h5.copyTo(result, 40);
+          }
+          return result;
+        }
+        return hash;
+      }();
+      var calculateSHA384 = function calculateSHA384Closure() {
+        function hash(data, offset, length) {
+          return calculateSHA512(data, offset, length, true);
+        }
+        return hash;
+      }();
+      var NullCipher = function NullCipherClosure() {
+        function NullCipher() {
+        }
+        NullCipher.prototype = {
+          decryptBlock: function NullCipher_decryptBlock(data) {
+            return data;
+          }
+        };
+        return NullCipher;
+      }();
+      var AES128Cipher = function AES128CipherClosure() {
+        var rcon = new Uint8Array([
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d
+        ]);
+        var s = new Uint8Array([
+          0x63,
+          0x7c,
+          0x77,
+          0x7b,
+          0xf2,
+          0x6b,
+          0x6f,
+          0xc5,
+          0x30,
+          0x01,
+          0x67,
+          0x2b,
+          0xfe,
+          0xd7,
+          0xab,
+          0x76,
+          0xca,
+          0x82,
+          0xc9,
+          0x7d,
+          0xfa,
+          0x59,
+          0x47,
+          0xf0,
+          0xad,
+          0xd4,
+          0xa2,
+          0xaf,
+          0x9c,
+          0xa4,
+          0x72,
+          0xc0,
+          0xb7,
+          0xfd,
+          0x93,
+          0x26,
+          0x36,
+          0x3f,
+          0xf7,
+          0xcc,
+          0x34,
+          0xa5,
+          0xe5,
+          0xf1,
+          0x71,
+          0xd8,
+          0x31,
+          0x15,
+          0x04,
+          0xc7,
+          0x23,
+          0xc3,
+          0x18,
+          0x96,
+          0x05,
+          0x9a,
+          0x07,
+          0x12,
+          0x80,
+          0xe2,
+          0xeb,
+          0x27,
+          0xb2,
+          0x75,
+          0x09,
+          0x83,
+          0x2c,
+          0x1a,
+          0x1b,
+          0x6e,
+          0x5a,
+          0xa0,
+          0x52,
+          0x3b,
+          0xd6,
+          0xb3,
+          0x29,
+          0xe3,
+          0x2f,
+          0x84,
+          0x53,
+          0xd1,
+          0x00,
+          0xed,
+          0x20,
+          0xfc,
+          0xb1,
+          0x5b,
+          0x6a,
+          0xcb,
+          0xbe,
+          0x39,
+          0x4a,
+          0x4c,
+          0x58,
+          0xcf,
+          0xd0,
+          0xef,
+          0xaa,
+          0xfb,
+          0x43,
+          0x4d,
+          0x33,
+          0x85,
+          0x45,
+          0xf9,
+          0x02,
+          0x7f,
+          0x50,
+          0x3c,
+          0x9f,
+          0xa8,
+          0x51,
+          0xa3,
+          0x40,
+          0x8f,
+          0x92,
+          0x9d,
+          0x38,
+          0xf5,
+          0xbc,
+          0xb6,
+          0xda,
+          0x21,
+          0x10,
+          0xff,
+          0xf3,
+          0xd2,
+          0xcd,
+          0x0c,
+          0x13,
+          0xec,
+          0x5f,
+          0x97,
+          0x44,
+          0x17,
+          0xc4,
+          0xa7,
+          0x7e,
+          0x3d,
+          0x64,
+          0x5d,
+          0x19,
+          0x73,
+          0x60,
+          0x81,
+          0x4f,
+          0xdc,
+          0x22,
+          0x2a,
+          0x90,
+          0x88,
+          0x46,
+          0xee,
+          0xb8,
+          0x14,
+          0xde,
+          0x5e,
+          0x0b,
+          0xdb,
+          0xe0,
+          0x32,
+          0x3a,
+          0x0a,
+          0x49,
+          0x06,
+          0x24,
+          0x5c,
+          0xc2,
+          0xd3,
+          0xac,
+          0x62,
+          0x91,
+          0x95,
+          0xe4,
+          0x79,
+          0xe7,
+          0xc8,
+          0x37,
+          0x6d,
+          0x8d,
+          0xd5,
+          0x4e,
+          0xa9,
+          0x6c,
+          0x56,
+          0xf4,
+          0xea,
+          0x65,
+          0x7a,
+          0xae,
+          0x08,
+          0xba,
+          0x78,
+          0x25,
+          0x2e,
+          0x1c,
+          0xa6,
+          0xb4,
+          0xc6,
+          0xe8,
+          0xdd,
+          0x74,
+          0x1f,
+          0x4b,
+          0xbd,
+          0x8b,
+          0x8a,
+          0x70,
+          0x3e,
+          0xb5,
+          0x66,
+          0x48,
+          0x03,
+          0xf6,
+          0x0e,
+          0x61,
+          0x35,
+          0x57,
+          0xb9,
+          0x86,
+          0xc1,
+          0x1d,
+          0x9e,
+          0xe1,
+          0xf8,
+          0x98,
+          0x11,
+          0x69,
+          0xd9,
+          0x8e,
+          0x94,
+          0x9b,
+          0x1e,
+          0x87,
+          0xe9,
+          0xce,
+          0x55,
+          0x28,
+          0xdf,
+          0x8c,
+          0xa1,
+          0x89,
+          0x0d,
+          0xbf,
+          0xe6,
+          0x42,
+          0x68,
+          0x41,
+          0x99,
+          0x2d,
+          0x0f,
+          0xb0,
+          0x54,
+          0xbb,
+          0x16
+        ]);
+        var inv_s = new Uint8Array([
+          0x52,
+          0x09,
+          0x6a,
+          0xd5,
+          0x30,
+          0x36,
+          0xa5,
+          0x38,
+          0xbf,
+          0x40,
+          0xa3,
+          0x9e,
+          0x81,
+          0xf3,
+          0xd7,
+          0xfb,
+          0x7c,
+          0xe3,
+          0x39,
+          0x82,
+          0x9b,
+          0x2f,
+          0xff,
+          0x87,
+          0x34,
+          0x8e,
+          0x43,
+          0x44,
+          0xc4,
+          0xde,
+          0xe9,
+          0xcb,
+          0x54,
+          0x7b,
+          0x94,
+          0x32,
+          0xa6,
+          0xc2,
+          0x23,
+          0x3d,
+          0xee,
+          0x4c,
+          0x95,
+          0x0b,
+          0x42,
+          0xfa,
+          0xc3,
+          0x4e,
+          0x08,
+          0x2e,
+          0xa1,
+          0x66,
+          0x28,
+          0xd9,
+          0x24,
+          0xb2,
+          0x76,
+          0x5b,
+          0xa2,
+          0x49,
+          0x6d,
+          0x8b,
+          0xd1,
+          0x25,
+          0x72,
+          0xf8,
+          0xf6,
+          0x64,
+          0x86,
+          0x68,
+          0x98,
+          0x16,
+          0xd4,
+          0xa4,
+          0x5c,
+          0xcc,
+          0x5d,
+          0x65,
+          0xb6,
+          0x92,
+          0x6c,
+          0x70,
+          0x48,
+          0x50,
+          0xfd,
+          0xed,
+          0xb9,
+          0xda,
+          0x5e,
+          0x15,
+          0x46,
+          0x57,
+          0xa7,
+          0x8d,
+          0x9d,
+          0x84,
+          0x90,
+          0xd8,
+          0xab,
+          0x00,
+          0x8c,
+          0xbc,
+          0xd3,
+          0x0a,
+          0xf7,
+          0xe4,
+          0x58,
+          0x05,
+          0xb8,
+          0xb3,
+          0x45,
+          0x06,
+          0xd0,
+          0x2c,
+          0x1e,
+          0x8f,
+          0xca,
+          0x3f,
+          0x0f,
+          0x02,
+          0xc1,
+          0xaf,
+          0xbd,
+          0x03,
+          0x01,
+          0x13,
+          0x8a,
+          0x6b,
+          0x3a,
+          0x91,
+          0x11,
+          0x41,
+          0x4f,
+          0x67,
+          0xdc,
+          0xea,
+          0x97,
+          0xf2,
+          0xcf,
+          0xce,
+          0xf0,
+          0xb4,
+          0xe6,
+          0x73,
+          0x96,
+          0xac,
+          0x74,
+          0x22,
+          0xe7,
+          0xad,
+          0x35,
+          0x85,
+          0xe2,
+          0xf9,
+          0x37,
+          0xe8,
+          0x1c,
+          0x75,
+          0xdf,
+          0x6e,
+          0x47,
+          0xf1,
+          0x1a,
+          0x71,
+          0x1d,
+          0x29,
+          0xc5,
+          0x89,
+          0x6f,
+          0xb7,
+          0x62,
+          0x0e,
+          0xaa,
+          0x18,
+          0xbe,
+          0x1b,
+          0xfc,
+          0x56,
+          0x3e,
+          0x4b,
+          0xc6,
+          0xd2,
+          0x79,
+          0x20,
+          0x9a,
+          0xdb,
+          0xc0,
+          0xfe,
+          0x78,
+          0xcd,
+          0x5a,
+          0xf4,
+          0x1f,
+          0xdd,
+          0xa8,
+          0x33,
+          0x88,
+          0x07,
+          0xc7,
+          0x31,
+          0xb1,
+          0x12,
+          0x10,
+          0x59,
+          0x27,
+          0x80,
+          0xec,
+          0x5f,
+          0x60,
+          0x51,
+          0x7f,
+          0xa9,
+          0x19,
+          0xb5,
+          0x4a,
+          0x0d,
+          0x2d,
+          0xe5,
+          0x7a,
+          0x9f,
+          0x93,
+          0xc9,
+          0x9c,
+          0xef,
+          0xa0,
+          0xe0,
+          0x3b,
+          0x4d,
+          0xae,
+          0x2a,
+          0xf5,
+          0xb0,
+          0xc8,
+          0xeb,
+          0xbb,
+          0x3c,
+          0x83,
+          0x53,
+          0x99,
+          0x61,
+          0x17,
+          0x2b,
+          0x04,
+          0x7e,
+          0xba,
+          0x77,
+          0xd6,
+          0x26,
+          0xe1,
+          0x69,
+          0x14,
+          0x63,
+          0x55,
+          0x21,
+          0x0c,
+          0x7d
+        ]);
+        var mixCol = new Uint8Array(256);
+        for (var i = 0; i < 256; i++) {
+          if (i < 128) {
+            mixCol[i] = i << 1;
+          } else {
+            mixCol[i] = i << 1 ^ 0x1b;
+          }
+        }
+        var mix = new Uint32Array([
+          0x00000000,
+          0x0e090d0b,
+          0x1c121a16,
+          0x121b171d,
+          0x3824342c,
+          0x362d3927,
+          0x24362e3a,
+          0x2a3f2331,
+          0x70486858,
+          0x7e416553,
+          0x6c5a724e,
+          0x62537f45,
+          0x486c5c74,
+          0x4665517f,
+          0x547e4662,
+          0x5a774b69,
+          0xe090d0b0,
+          0xee99ddbb,
+          0xfc82caa6,
+          0xf28bc7ad,
+          0xd8b4e49c,
+          0xd6bde997,
+          0xc4a6fe8a,
+          0xcaaff381,
+          0x90d8b8e8,
+          0x9ed1b5e3,
+          0x8ccaa2fe,
+          0x82c3aff5,
+          0xa8fc8cc4,
+          0xa6f581cf,
+          0xb4ee96d2,
+          0xbae79bd9,
+          0xdb3bbb7b,
+          0xd532b670,
+          0xc729a16d,
+          0xc920ac66,
+          0xe31f8f57,
+          0xed16825c,
+          0xff0d9541,
+          0xf104984a,
+          0xab73d323,
+          0xa57ade28,
+          0xb761c935,
+          0xb968c43e,
+          0x9357e70f,
+          0x9d5eea04,
+          0x8f45fd19,
+          0x814cf012,
+          0x3bab6bcb,
+          0x35a266c0,
+          0x27b971dd,
+          0x29b07cd6,
+          0x038f5fe7,
+          0x0d8652ec,
+          0x1f9d45f1,
+          0x119448fa,
+          0x4be30393,
+          0x45ea0e98,
+          0x57f11985,
+          0x59f8148e,
+          0x73c737bf,
+          0x7dce3ab4,
+          0x6fd52da9,
+          0x61dc20a2,
+          0xad766df6,
+          0xa37f60fd,
+          0xb16477e0,
+          0xbf6d7aeb,
+          0x955259da,
+          0x9b5b54d1,
+          0x894043cc,
+          0x87494ec7,
+          0xdd3e05ae,
+          0xd33708a5,
+          0xc12c1fb8,
+          0xcf2512b3,
+          0xe51a3182,
+          0xeb133c89,
+          0xf9082b94,
+          0xf701269f,
+          0x4de6bd46,
+          0x43efb04d,
+          0x51f4a750,
+          0x5ffdaa5b,
+          0x75c2896a,
+          0x7bcb8461,
+          0x69d0937c,
+          0x67d99e77,
+          0x3daed51e,
+          0x33a7d815,
+          0x21bccf08,
+          0x2fb5c203,
+          0x058ae132,
+          0x0b83ec39,
+          0x1998fb24,
+          0x1791f62f,
+          0x764dd68d,
+          0x7844db86,
+          0x6a5fcc9b,
+          0x6456c190,
+          0x4e69e2a1,
+          0x4060efaa,
+          0x527bf8b7,
+          0x5c72f5bc,
+          0x0605bed5,
+          0x080cb3de,
+          0x1a17a4c3,
+          0x141ea9c8,
+          0x3e218af9,
+          0x302887f2,
+          0x223390ef,
+          0x2c3a9de4,
+          0x96dd063d,
+          0x98d40b36,
+          0x8acf1c2b,
+          0x84c61120,
+          0xaef93211,
+          0xa0f03f1a,
+          0xb2eb2807,
+          0xbce2250c,
+          0xe6956e65,
+          0xe89c636e,
+          0xfa877473,
+          0xf48e7978,
+          0xdeb15a49,
+          0xd0b85742,
+          0xc2a3405f,
+          0xccaa4d54,
+          0x41ecdaf7,
+          0x4fe5d7fc,
+          0x5dfec0e1,
+          0x53f7cdea,
+          0x79c8eedb,
+          0x77c1e3d0,
+          0x65daf4cd,
+          0x6bd3f9c6,
+          0x31a4b2af,
+          0x3fadbfa4,
+          0x2db6a8b9,
+          0x23bfa5b2,
+          0x09808683,
+          0x07898b88,
+          0x15929c95,
+          0x1b9b919e,
+          0xa17c0a47,
+          0xaf75074c,
+          0xbd6e1051,
+          0xb3671d5a,
+          0x99583e6b,
+          0x97513360,
+          0x854a247d,
+          0x8b432976,
+          0xd134621f,
+          0xdf3d6f14,
+          0xcd267809,
+          0xc32f7502,
+          0xe9105633,
+          0xe7195b38,
+          0xf5024c25,
+          0xfb0b412e,
+          0x9ad7618c,
+          0x94de6c87,
+          0x86c57b9a,
+          0x88cc7691,
+          0xa2f355a0,
+          0xacfa58ab,
+          0xbee14fb6,
+          0xb0e842bd,
+          0xea9f09d4,
+          0xe49604df,
+          0xf68d13c2,
+          0xf8841ec9,
+          0xd2bb3df8,
+          0xdcb230f3,
+          0xcea927ee,
+          0xc0a02ae5,
+          0x7a47b13c,
+          0x744ebc37,
+          0x6655ab2a,
+          0x685ca621,
+          0x42638510,
+          0x4c6a881b,
+          0x5e719f06,
+          0x5078920d,
+          0x0a0fd964,
+          0x0406d46f,
+          0x161dc372,
+          0x1814ce79,
+          0x322bed48,
+          0x3c22e043,
+          0x2e39f75e,
+          0x2030fa55,
+          0xec9ab701,
+          0xe293ba0a,
+          0xf088ad17,
+          0xfe81a01c,
+          0xd4be832d,
+          0xdab78e26,
+          0xc8ac993b,
+          0xc6a59430,
+          0x9cd2df59,
+          0x92dbd252,
+          0x80c0c54f,
+          0x8ec9c844,
+          0xa4f6eb75,
+          0xaaffe67e,
+          0xb8e4f163,
+          0xb6edfc68,
+          0x0c0a67b1,
+          0x02036aba,
+          0x10187da7,
+          0x1e1170ac,
+          0x342e539d,
+          0x3a275e96,
+          0x283c498b,
+          0x26354480,
+          0x7c420fe9,
+          0x724b02e2,
+          0x605015ff,
+          0x6e5918f4,
+          0x44663bc5,
+          0x4a6f36ce,
+          0x587421d3,
+          0x567d2cd8,
+          0x37a10c7a,
+          0x39a80171,
+          0x2bb3166c,
+          0x25ba1b67,
+          0x0f853856,
+          0x018c355d,
+          0x13972240,
+          0x1d9e2f4b,
+          0x47e96422,
+          0x49e06929,
+          0x5bfb7e34,
+          0x55f2733f,
+          0x7fcd500e,
+          0x71c45d05,
+          0x63df4a18,
+          0x6dd64713,
+          0xd731dcca,
+          0xd938d1c1,
+          0xcb23c6dc,
+          0xc52acbd7,
+          0xef15e8e6,
+          0xe11ce5ed,
+          0xf307f2f0,
+          0xfd0efffb,
+          0xa779b492,
+          0xa970b999,
+          0xbb6bae84,
+          0xb562a38f,
+          0x9f5d80be,
+          0x91548db5,
+          0x834f9aa8,
+          0x8d4697a3
+        ]);
+        function expandKey128(cipherKey) {
+          var b = 176, result = new Uint8Array(b);
+          result.set(cipherKey);
+          for (var j = 16, i = 1; j < b; ++i) {
+            // RotWord
+            var t1 = result[j - 3], t2 = result[j - 2], t3 = result[j - 1], t4 = result[j - 4];
+            // SubWord
+            t1 = s[t1];
+            t2 = s[t2];
+            t3 = s[t3];
+            t4 = s[t4];
+            // Rcon
+            t1 = t1 ^ rcon[i];
+            for (var n = 0; n < 4; ++n) {
+              result[j] = t1 ^= result[j - 16];
+              j++;
+              result[j] = t2 ^= result[j - 16];
+              j++;
+              result[j] = t3 ^= result[j - 16];
+              j++;
+              result[j] = t4 ^= result[j - 16];
+              j++;
+            }
+          }
+          return result;
+        }
+        function decrypt128(input, key) {
+          var state = new Uint8Array(16);
+          state.set(input);
+          var i, j, k;
+          var t, u, v;
+          // AddRoundKey
+          for (j = 0, k = 160; j < 16; ++j, ++k) {
+            state[j] ^= key[k];
+          }
+          for (i = 9; i >= 1; --i) {
+            // InvShiftRows
+            t = state[13];
+            state[13] = state[9];
+            state[9] = state[5];
+            state[5] = state[1];
+            state[1] = t;
+            t = state[14];
+            u = state[10];
+            state[14] = state[6];
+            state[10] = state[2];
+            state[6] = t;
+            state[2] = u;
+            t = state[15];
+            u = state[11];
+            v = state[7];
+            state[15] = state[3];
+            state[11] = t;
+            state[7] = u;
+            state[3] = v;
+            // InvSubBytes
+            for (j = 0; j < 16; ++j) {
+              state[j] = inv_s[state[j]];
+            }
+            // AddRoundKey
+            for (j = 0, k = i * 16; j < 16; ++j, ++k) {
+              state[j] ^= key[k];
+            }
+            // InvMixColumns
+            for (j = 0; j < 16; j += 4) {
+              var s0 = mix[state[j]], s1 = mix[state[j + 1]], s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];
+              t = s0 ^ s1 >>> 8 ^ s1 << 24 ^ s2 >>> 16 ^ s2 << 16 ^ s3 >>> 24 ^ s3 << 8;
+              state[j] = t >>> 24 & 0xFF;
+              state[j + 1] = t >> 16 & 0xFF;
+              state[j + 2] = t >> 8 & 0xFF;
+              state[j + 3] = t & 0xFF;
+            }
+          }
+          // InvShiftRows
+          t = state[13];
+          state[13] = state[9];
+          state[9] = state[5];
+          state[5] = state[1];
+          state[1] = t;
+          t = state[14];
+          u = state[10];
+          state[14] = state[6];
+          state[10] = state[2];
+          state[6] = t;
+          state[2] = u;
+          t = state[15];
+          u = state[11];
+          v = state[7];
+          state[15] = state[3];
+          state[11] = t;
+          state[7] = u;
+          state[3] = v;
+          for (j = 0; j < 16; ++j) {
+            // InvSubBytes
+            state[j] = inv_s[state[j]];
+            // AddRoundKey
+            state[j] ^= key[j];
+          }
+          return state;
+        }
+        function encrypt128(input, key) {
+          var t, u, v, k;
+          var state = new Uint8Array(16);
+          state.set(input);
+          for (j = 0; j < 16; ++j) {
+            // AddRoundKey
+            state[j] ^= key[j];
+          }
+          for (i = 1; i < 10; i++) {
+            //SubBytes
+            for (j = 0; j < 16; ++j) {
+              state[j] = s[state[j]];
+            }
+            //ShiftRows
+            v = state[1];
+            state[1] = state[5];
+            state[5] = state[9];
+            state[9] = state[13];
+            state[13] = v;
+            v = state[2];
+            u = state[6];
+            state[2] = state[10];
+            state[6] = state[14];
+            state[10] = v;
+            state[14] = u;
+            v = state[3];
+            u = state[7];
+            t = state[11];
+            state[3] = state[15];
+            state[7] = v;
+            state[11] = u;
+            state[15] = t;
+            //MixColumns
+            for (var j = 0; j < 16; j += 4) {
+              var s0 = state[j + 0], s1 = state[j + 1];
+              var s2 = state[j + 2], s3 = state[j + 3];
+              t = s0 ^ s1 ^ s2 ^ s3;
+              state[j + 0] ^= t ^ mixCol[s0 ^ s1];
+              state[j + 1] ^= t ^ mixCol[s1 ^ s2];
+              state[j + 2] ^= t ^ mixCol[s2 ^ s3];
+              state[j + 3] ^= t ^ mixCol[s3 ^ s0];
+            }
+            //AddRoundKey
+            for (j = 0, k = i * 16; j < 16; ++j, ++k) {
+              state[j] ^= key[k];
+            }
+          }
+          //SubBytes
+          for (j = 0; j < 16; ++j) {
+            state[j] = s[state[j]];
+          }
+          //ShiftRows
+          v = state[1];
+          state[1] = state[5];
+          state[5] = state[9];
+          state[9] = state[13];
+          state[13] = v;
+          v = state[2];
+          u = state[6];
+          state[2] = state[10];
+          state[6] = state[14];
+          state[10] = v;
+          state[14] = u;
+          v = state[3];
+          u = state[7];
+          t = state[11];
+          state[3] = state[15];
+          state[7] = v;
+          state[11] = u;
+          state[15] = t;
+          //AddRoundKey
+          for (j = 0, k = 160; j < 16; ++j, ++k) {
+            state[j] ^= key[k];
+          }
+          return state;
+        }
+        function AES128Cipher(key) {
+          this.key = expandKey128(key);
+          this.buffer = new Uint8Array(16);
+          this.bufferPosition = 0;
+        }
+        function decryptBlock2(data, finalize) {
+          var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [], iv = this.iv;
+          for (i = 0; i < sourceLength; ++i) {
+            buffer[bufferLength] = data[i];
+            ++bufferLength;
+            if (bufferLength < 16) {
+              continue;
+            }
+            // buffer is full, decrypting
+            var plain = decrypt128(buffer, this.key);
+            // xor-ing the IV vector to get plain text
+            for (j = 0; j < 16; ++j) {
+              plain[j] ^= iv[j];
+            }
+            iv = buffer;
+            result.push(plain);
+            buffer = new Uint8Array(16);
+            bufferLength = 0;
+          }
+          // saving incomplete buffer
+          this.buffer = buffer;
+          this.bufferLength = bufferLength;
+          this.iv = iv;
+          if (result.length === 0) {
+            return new Uint8Array([]);
+          }
+          // combining plain text blocks into one
+          var outputLength = 16 * result.length;
+          if (finalize) {
+            // undo a padding that is described in RFC 2898
+            var lastBlock = result[result.length - 1];
+            var psLen = lastBlock[15];
+            if (psLen <= 16) {
+              for (i = 15, ii = 16 - psLen; i >= ii; --i) {
+                if (lastBlock[i] !== psLen) {
+                  // Invalid padding, assume that the block has no padding.
+                  psLen = 0;
+                  break;
+                }
+              }
+              outputLength -= psLen;
+              result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
+            }
+          }
+          var output = new Uint8Array(outputLength);
+          for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+            output.set(result[i], j);
+          }
+          return output;
+        }
+        AES128Cipher.prototype = {
+          decryptBlock: function AES128Cipher_decryptBlock(data, finalize) {
+            var i, sourceLength = data.length;
+            var buffer = this.buffer, bufferLength = this.bufferPosition;
+            // waiting for IV values -- they are at the start of the stream
+            for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {
+              buffer[bufferLength] = data[i];
+            }
+            if (bufferLength < 16) {
+              // need more data
+              this.bufferLength = bufferLength;
+              return new Uint8Array([]);
+            }
+            this.iv = buffer;
+            this.buffer = new Uint8Array(16);
+            this.bufferLength = 0;
+            // starting decryption
+            this.decryptBlock = decryptBlock2;
+            return this.decryptBlock(data.subarray(16), finalize);
+          },
+          encrypt: function AES128Cipher_encrypt(data, iv) {
+            var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [];
+            if (!iv) {
+              iv = new Uint8Array(16);
+            }
+            for (i = 0; i < sourceLength; ++i) {
+              buffer[bufferLength] = data[i];
+              ++bufferLength;
+              if (bufferLength < 16) {
+                continue;
+              }
+              for (j = 0; j < 16; ++j) {
+                buffer[j] ^= iv[j];
+              }
+              // buffer is full, encrypting
+              var cipher = encrypt128(buffer, this.key);
+              iv = cipher;
+              result.push(cipher);
+              buffer = new Uint8Array(16);
+              bufferLength = 0;
+            }
+            // saving incomplete buffer
+            this.buffer = buffer;
+            this.bufferLength = bufferLength;
+            this.iv = iv;
+            if (result.length === 0) {
+              return new Uint8Array([]);
+            }
+            // combining plain text blocks into one
+            var outputLength = 16 * result.length;
+            var output = new Uint8Array(outputLength);
+            for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+              output.set(result[i], j);
+            }
+            return output;
+          }
+        };
+        return AES128Cipher;
+      }();
+      var AES256Cipher = function AES256CipherClosure() {
+        var rcon = new Uint8Array([
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d,
+          0x01,
+          0x02,
+          0x04,
+          0x08,
+          0x10,
+          0x20,
+          0x40,
+          0x80,
+          0x1b,
+          0x36,
+          0x6c,
+          0xd8,
+          0xab,
+          0x4d,
+          0x9a,
+          0x2f,
+          0x5e,
+          0xbc,
+          0x63,
+          0xc6,
+          0x97,
+          0x35,
+          0x6a,
+          0xd4,
+          0xb3,
+          0x7d,
+          0xfa,
+          0xef,
+          0xc5,
+          0x91,
+          0x39,
+          0x72,
+          0xe4,
+          0xd3,
+          0xbd,
+          0x61,
+          0xc2,
+          0x9f,
+          0x25,
+          0x4a,
+          0x94,
+          0x33,
+          0x66,
+          0xcc,
+          0x83,
+          0x1d,
+          0x3a,
+          0x74,
+          0xe8,
+          0xcb,
+          0x8d
+        ]);
+        var s = new Uint8Array([
+          0x63,
+          0x7c,
+          0x77,
+          0x7b,
+          0xf2,
+          0x6b,
+          0x6f,
+          0xc5,
+          0x30,
+          0x01,
+          0x67,
+          0x2b,
+          0xfe,
+          0xd7,
+          0xab,
+          0x76,
+          0xca,
+          0x82,
+          0xc9,
+          0x7d,
+          0xfa,
+          0x59,
+          0x47,
+          0xf0,
+          0xad,
+          0xd4,
+          0xa2,
+          0xaf,
+          0x9c,
+          0xa4,
+          0x72,
+          0xc0,
+          0xb7,
+          0xfd,
+          0x93,
+          0x26,
+          0x36,
+          0x3f,
+          0xf7,
+          0xcc,
+          0x34,
+          0xa5,
+          0xe5,
+          0xf1,
+          0x71,
+          0xd8,
+          0x31,
+          0x15,
+          0x04,
+          0xc7,
+          0x23,
+          0xc3,
+          0x18,
+          0x96,
+          0x05,
+          0x9a,
+          0x07,
+          0x12,
+          0x80,
+          0xe2,
+          0xeb,
+          0x27,
+          0xb2,
+          0x75,
+          0x09,
+          0x83,
+          0x2c,
+          0x1a,
+          0x1b,
+          0x6e,
+          0x5a,
+          0xa0,
+          0x52,
+          0x3b,
+          0xd6,
+          0xb3,
+          0x29,
+          0xe3,
+          0x2f,
+          0x84,
+          0x53,
+          0xd1,
+          0x00,
+          0xed,
+          0x20,
+          0xfc,
+          0xb1,
+          0x5b,
+          0x6a,
+          0xcb,
+          0xbe,
+          0x39,
+          0x4a,
+          0x4c,
+          0x58,
+          0xcf,
+          0xd0,
+          0xef,
+          0xaa,
+          0xfb,
+          0x43,
+          0x4d,
+          0x33,
+          0x85,
+          0x45,
+          0xf9,
+          0x02,
+          0x7f,
+          0x50,
+          0x3c,
+          0x9f,
+          0xa8,
+          0x51,
+          0xa3,
+          0x40,
+          0x8f,
+          0x92,
+          0x9d,
+          0x38,
+          0xf5,
+          0xbc,
+          0xb6,
+          0xda,
+          0x21,
+          0x10,
+          0xff,
+          0xf3,
+          0xd2,
+          0xcd,
+          0x0c,
+          0x13,
+          0xec,
+          0x5f,
+          0x97,
+          0x44,
+          0x17,
+          0xc4,
+          0xa7,
+          0x7e,
+          0x3d,
+          0x64,
+          0x5d,
+          0x19,
+          0x73,
+          0x60,
+          0x81,
+          0x4f,
+          0xdc,
+          0x22,
+          0x2a,
+          0x90,
+          0x88,
+          0x46,
+          0xee,
+          0xb8,
+          0x14,
+          0xde,
+          0x5e,
+          0x0b,
+          0xdb,
+          0xe0,
+          0x32,
+          0x3a,
+          0x0a,
+          0x49,
+          0x06,
+          0x24,
+          0x5c,
+          0xc2,
+          0xd3,
+          0xac,
+          0x62,
+          0x91,
+          0x95,
+          0xe4,
+          0x79,
+          0xe7,
+          0xc8,
+          0x37,
+          0x6d,
+          0x8d,
+          0xd5,
+          0x4e,
+          0xa9,
+          0x6c,
+          0x56,
+          0xf4,
+          0xea,
+          0x65,
+          0x7a,
+          0xae,
+          0x08,
+          0xba,
+          0x78,
+          0x25,
+          0x2e,
+          0x1c,
+          0xa6,
+          0xb4,
+          0xc6,
+          0xe8,
+          0xdd,
+          0x74,
+          0x1f,
+          0x4b,
+          0xbd,
+          0x8b,
+          0x8a,
+          0x70,
+          0x3e,
+          0xb5,
+          0x66,
+          0x48,
+          0x03,
+          0xf6,
+          0x0e,
+          0x61,
+          0x35,
+          0x57,
+          0xb9,
+          0x86,
+          0xc1,
+          0x1d,
+          0x9e,
+          0xe1,
+          0xf8,
+          0x98,
+          0x11,
+          0x69,
+          0xd9,
+          0x8e,
+          0x94,
+          0x9b,
+          0x1e,
+          0x87,
+          0xe9,
+          0xce,
+          0x55,
+          0x28,
+          0xdf,
+          0x8c,
+          0xa1,
+          0x89,
+          0x0d,
+          0xbf,
+          0xe6,
+          0x42,
+          0x68,
+          0x41,
+          0x99,
+          0x2d,
+          0x0f,
+          0xb0,
+          0x54,
+          0xbb,
+          0x16
+        ]);
+        var inv_s = new Uint8Array([
+          0x52,
+          0x09,
+          0x6a,
+          0xd5,
+          0x30,
+          0x36,
+          0xa5,
+          0x38,
+          0xbf,
+          0x40,
+          0xa3,
+          0x9e,
+          0x81,
+          0xf3,
+          0xd7,
+          0xfb,
+          0x7c,
+          0xe3,
+          0x39,
+          0x82,
+          0x9b,
+          0x2f,
+          0xff,
+          0x87,
+          0x34,
+          0x8e,
+          0x43,
+          0x44,
+          0xc4,
+          0xde,
+          0xe9,
+          0xcb,
+          0x54,
+          0x7b,
+          0x94,
+          0x32,
+          0xa6,
+          0xc2,
+          0x23,
+          0x3d,
+          0xee,
+          0x4c,
+          0x95,
+          0x0b,
+          0x42,
+          0xfa,
+          0xc3,
+          0x4e,
+          0x08,
+          0x2e,
+          0xa1,
+          0x66,
+          0x28,
+          0xd9,
+          0x24,
+          0xb2,
+          0x76,
+          0x5b,
+          0xa2,
+          0x49,
+          0x6d,
+          0x8b,
+          0xd1,
+          0x25,
+          0x72,
+          0xf8,
+          0xf6,
+          0x64,
+          0x86,
+          0x68,
+          0x98,
+          0x16,
+          0xd4,
+          0xa4,
+          0x5c,
+          0xcc,
+          0x5d,
+          0x65,
+          0xb6,
+          0x92,
+          0x6c,
+          0x70,
+          0x48,
+          0x50,
+          0xfd,
+          0xed,
+          0xb9,
+          0xda,
+          0x5e,
+          0x15,
+          0x46,
+          0x57,
+          0xa7,
+          0x8d,
+          0x9d,
+          0x84,
+          0x90,
+          0xd8,
+          0xab,
+          0x00,
+          0x8c,
+          0xbc,
+          0xd3,
+          0x0a,
+          0xf7,
+          0xe4,
+          0x58,
+          0x05,
+          0xb8,
+          0xb3,
+          0x45,
+          0x06,
+          0xd0,
+          0x2c,
+          0x1e,
+          0x8f,
+          0xca,
+          0x3f,
+          0x0f,
+          0x02,
+          0xc1,
+          0xaf,
+          0xbd,
+          0x03,
+          0x01,
+          0x13,
+          0x8a,
+          0x6b,
+          0x3a,
+          0x91,
+          0x11,
+          0x41,
+          0x4f,
+          0x67,
+          0xdc,
+          0xea,
+          0x97,
+          0xf2,
+          0xcf,
+          0xce,
+          0xf0,
+          0xb4,
+          0xe6,
+          0x73,
+          0x96,
+          0xac,
+          0x74,
+          0x22,
+          0xe7,
+          0xad,
+          0x35,
+          0x85,
+          0xe2,
+          0xf9,
+          0x37,
+          0xe8,
+          0x1c,
+          0x75,
+          0xdf,
+          0x6e,
+          0x47,
+          0xf1,
+          0x1a,
+          0x71,
+          0x1d,
+          0x29,
+          0xc5,
+          0x89,
+          0x6f,
+          0xb7,
+          0x62,
+          0x0e,
+          0xaa,
+          0x18,
+          0xbe,
+          0x1b,
+          0xfc,
+          0x56,
+          0x3e,
+          0x4b,
+          0xc6,
+          0xd2,
+          0x79,
+          0x20,
+          0x9a,
+          0xdb,
+          0xc0,
+          0xfe,
+          0x78,
+          0xcd,
+          0x5a,
+          0xf4,
+          0x1f,
+          0xdd,
+          0xa8,
+          0x33,
+          0x88,
+          0x07,
+          0xc7,
+          0x31,
+          0xb1,
+          0x12,
+          0x10,
+          0x59,
+          0x27,
+          0x80,
+          0xec,
+          0x5f,
+          0x60,
+          0x51,
+          0x7f,
+          0xa9,
+          0x19,
+          0xb5,
+          0x4a,
+          0x0d,
+          0x2d,
+          0xe5,
+          0x7a,
+          0x9f,
+          0x93,
+          0xc9,
+          0x9c,
+          0xef,
+          0xa0,
+          0xe0,
+          0x3b,
+          0x4d,
+          0xae,
+          0x2a,
+          0xf5,
+          0xb0,
+          0xc8,
+          0xeb,
+          0xbb,
+          0x3c,
+          0x83,
+          0x53,
+          0x99,
+          0x61,
+          0x17,
+          0x2b,
+          0x04,
+          0x7e,
+          0xba,
+          0x77,
+          0xd6,
+          0x26,
+          0xe1,
+          0x69,
+          0x14,
+          0x63,
+          0x55,
+          0x21,
+          0x0c,
+          0x7d
+        ]);
+        var mixCol = new Uint8Array(256);
+        for (var i = 0; i < 256; i++) {
+          if (i < 128) {
+            mixCol[i] = i << 1;
+          } else {
+            mixCol[i] = i << 1 ^ 0x1b;
+          }
+        }
+        var mix = new Uint32Array([
+          0x00000000,
+          0x0e090d0b,
+          0x1c121a16,
+          0x121b171d,
+          0x3824342c,
+          0x362d3927,
+          0x24362e3a,
+          0x2a3f2331,
+          0x70486858,
+          0x7e416553,
+          0x6c5a724e,
+          0x62537f45,
+          0x486c5c74,
+          0x4665517f,
+          0x547e4662,
+          0x5a774b69,
+          0xe090d0b0,
+          0xee99ddbb,
+          0xfc82caa6,
+          0xf28bc7ad,
+          0xd8b4e49c,
+          0xd6bde997,
+          0xc4a6fe8a,
+          0xcaaff381,
+          0x90d8b8e8,
+          0x9ed1b5e3,
+          0x8ccaa2fe,
+          0x82c3aff5,
+          0xa8fc8cc4,
+          0xa6f581cf,
+          0xb4ee96d2,
+          0xbae79bd9,
+          0xdb3bbb7b,
+          0xd532b670,
+          0xc729a16d,
+          0xc920ac66,
+          0xe31f8f57,
+          0xed16825c,
+          0xff0d9541,
+          0xf104984a,
+          0xab73d323,
+          0xa57ade28,
+          0xb761c935,
+          0xb968c43e,
+          0x9357e70f,
+          0x9d5eea04,
+          0x8f45fd19,
+          0x814cf012,
+          0x3bab6bcb,
+          0x35a266c0,
+          0x27b971dd,
+          0x29b07cd6,
+          0x038f5fe7,
+          0x0d8652ec,
+          0x1f9d45f1,
+          0x119448fa,
+          0x4be30393,
+          0x45ea0e98,
+          0x57f11985,
+          0x59f8148e,
+          0x73c737bf,
+          0x7dce3ab4,
+          0x6fd52da9,
+          0x61dc20a2,
+          0xad766df6,
+          0xa37f60fd,
+          0xb16477e0,
+          0xbf6d7aeb,
+          0x955259da,
+          0x9b5b54d1,
+          0x894043cc,
+          0x87494ec7,
+          0xdd3e05ae,
+          0xd33708a5,
+          0xc12c1fb8,
+          0xcf2512b3,
+          0xe51a3182,
+          0xeb133c89,
+          0xf9082b94,
+          0xf701269f,
+          0x4de6bd46,
+          0x43efb04d,
+          0x51f4a750,
+          0x5ffdaa5b,
+          0x75c2896a,
+          0x7bcb8461,
+          0x69d0937c,
+          0x67d99e77,
+          0x3daed51e,
+          0x33a7d815,
+          0x21bccf08,
+          0x2fb5c203,
+          0x058ae132,
+          0x0b83ec39,
+          0x1998fb24,
+          0x1791f62f,
+          0x764dd68d,
+          0x7844db86,
+          0x6a5fcc9b,
+          0x6456c190,
+          0x4e69e2a1,
+          0x4060efaa,
+          0x527bf8b7,
+          0x5c72f5bc,
+          0x0605bed5,
+          0x080cb3de,
+          0x1a17a4c3,
+          0x141ea9c8,
+          0x3e218af9,
+          0x302887f2,
+          0x223390ef,
+          0x2c3a9de4,
+          0x96dd063d,
+          0x98d40b36,
+          0x8acf1c2b,
+          0x84c61120,
+          0xaef93211,
+          0xa0f03f1a,
+          0xb2eb2807,
+          0xbce2250c,
+          0xe6956e65,
+          0xe89c636e,
+          0xfa877473,
+          0xf48e7978,
+          0xdeb15a49,
+          0xd0b85742,
+          0xc2a3405f,
+          0xccaa4d54,
+          0x41ecdaf7,
+          0x4fe5d7fc,
+          0x5dfec0e1,
+          0x53f7cdea,
+          0x79c8eedb,
+          0x77c1e3d0,
+          0x65daf4cd,
+          0x6bd3f9c6,
+          0x31a4b2af,
+          0x3fadbfa4,
+          0x2db6a8b9,
+          0x23bfa5b2,
+          0x09808683,
+          0x07898b88,
+          0x15929c95,
+          0x1b9b919e,
+          0xa17c0a47,
+          0xaf75074c,
+          0xbd6e1051,
+          0xb3671d5a,
+          0x99583e6b,
+          0x97513360,
+          0x854a247d,
+          0x8b432976,
+          0xd134621f,
+          0xdf3d6f14,
+          0xcd267809,
+          0xc32f7502,
+          0xe9105633,
+          0xe7195b38,
+          0xf5024c25,
+          0xfb0b412e,
+          0x9ad7618c,
+          0x94de6c87,
+          0x86c57b9a,
+          0x88cc7691,
+          0xa2f355a0,
+          0xacfa58ab,
+          0xbee14fb6,
+          0xb0e842bd,
+          0xea9f09d4,
+          0xe49604df,
+          0xf68d13c2,
+          0xf8841ec9,
+          0xd2bb3df8,
+          0xdcb230f3,
+          0xcea927ee,
+          0xc0a02ae5,
+          0x7a47b13c,
+          0x744ebc37,
+          0x6655ab2a,
+          0x685ca621,
+          0x42638510,
+          0x4c6a881b,
+          0x5e719f06,
+          0x5078920d,
+          0x0a0fd964,
+          0x0406d46f,
+          0x161dc372,
+          0x1814ce79,
+          0x322bed48,
+          0x3c22e043,
+          0x2e39f75e,
+          0x2030fa55,
+          0xec9ab701,
+          0xe293ba0a,
+          0xf088ad17,
+          0xfe81a01c,
+          0xd4be832d,
+          0xdab78e26,
+          0xc8ac993b,
+          0xc6a59430,
+          0x9cd2df59,
+          0x92dbd252,
+          0x80c0c54f,
+          0x8ec9c844,
+          0xa4f6eb75,
+          0xaaffe67e,
+          0xb8e4f163,
+          0xb6edfc68,
+          0x0c0a67b1,
+          0x02036aba,
+          0x10187da7,
+          0x1e1170ac,
+          0x342e539d,
+          0x3a275e96,
+          0x283c498b,
+          0x26354480,
+          0x7c420fe9,
+          0x724b02e2,
+          0x605015ff,
+          0x6e5918f4,
+          0x44663bc5,
+          0x4a6f36ce,
+          0x587421d3,
+          0x567d2cd8,
+          0x37a10c7a,
+          0x39a80171,
+          0x2bb3166c,
+          0x25ba1b67,
+          0x0f853856,
+          0x018c355d,
+          0x13972240,
+          0x1d9e2f4b,
+          0x47e96422,
+          0x49e06929,
+          0x5bfb7e34,
+          0x55f2733f,
+          0x7fcd500e,
+          0x71c45d05,
+          0x63df4a18,
+          0x6dd64713,
+          0xd731dcca,
+          0xd938d1c1,
+          0xcb23c6dc,
+          0xc52acbd7,
+          0xef15e8e6,
+          0xe11ce5ed,
+          0xf307f2f0,
+          0xfd0efffb,
+          0xa779b492,
+          0xa970b999,
+          0xbb6bae84,
+          0xb562a38f,
+          0x9f5d80be,
+          0x91548db5,
+          0x834f9aa8,
+          0x8d4697a3
+        ]);
+        function expandKey256(cipherKey) {
+          var b = 240, result = new Uint8Array(b);
+          var r = 1;
+          result.set(cipherKey);
+          for (var j = 32, i = 1; j < b; ++i) {
+            if (j % 32 === 16) {
+              t1 = s[t1];
+              t2 = s[t2];
+              t3 = s[t3];
+              t4 = s[t4];
+            } else if (j % 32 === 0) {
+              // RotWord
+              var t1 = result[j - 3], t2 = result[j - 2], t3 = result[j - 1], t4 = result[j - 4];
+              // SubWord
+              t1 = s[t1];
+              t2 = s[t2];
+              t3 = s[t3];
+              t4 = s[t4];
+              // Rcon
+              t1 = t1 ^ r;
+              if ((r <<= 1) >= 256) {
+                r = (r ^ 0x1b) & 0xFF;
+              }
+            }
+            for (var n = 0; n < 4; ++n) {
+              result[j] = t1 ^= result[j - 32];
+              j++;
+              result[j] = t2 ^= result[j - 32];
+              j++;
+              result[j] = t3 ^= result[j - 32];
+              j++;
+              result[j] = t4 ^= result[j - 32];
+              j++;
+            }
+          }
+          return result;
+        }
+        function decrypt256(input, key) {
+          var state = new Uint8Array(16);
+          state.set(input);
+          var i, j, k;
+          var t, u, v;
+          // AddRoundKey
+          for (j = 0, k = 224; j < 16; ++j, ++k) {
+            state[j] ^= key[k];
+          }
+          for (i = 13; i >= 1; --i) {
+            // InvShiftRows
+            t = state[13];
+            state[13] = state[9];
+            state[9] = state[5];
+            state[5] = state[1];
+            state[1] = t;
+            t = state[14];
+            u = state[10];
+            state[14] = state[6];
+            state[10] = state[2];
+            state[6] = t;
+            state[2] = u;
+            t = state[15];
+            u = state[11];
+            v = state[7];
+            state[15] = state[3];
+            state[11] = t;
+            state[7] = u;
+            state[3] = v;
+            // InvSubBytes
+            for (j = 0; j < 16; ++j) {
+              state[j] = inv_s[state[j]];
+            }
+            // AddRoundKey
+            for (j = 0, k = i * 16; j < 16; ++j, ++k) {
+              state[j] ^= key[k];
+            }
+            // InvMixColumns
+            for (j = 0; j < 16; j += 4) {
+              var s0 = mix[state[j]], s1 = mix[state[j + 1]], s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];
+              t = s0 ^ s1 >>> 8 ^ s1 << 24 ^ s2 >>> 16 ^ s2 << 16 ^ s3 >>> 24 ^ s3 << 8;
+              state[j] = t >>> 24 & 0xFF;
+              state[j + 1] = t >> 16 & 0xFF;
+              state[j + 2] = t >> 8 & 0xFF;
+              state[j + 3] = t & 0xFF;
+            }
+          }
+          // InvShiftRows
+          t = state[13];
+          state[13] = state[9];
+          state[9] = state[5];
+          state[5] = state[1];
+          state[1] = t;
+          t = state[14];
+          u = state[10];
+          state[14] = state[6];
+          state[10] = state[2];
+          state[6] = t;
+          state[2] = u;
+          t = state[15];
+          u = state[11];
+          v = state[7];
+          state[15] = state[3];
+          state[11] = t;
+          state[7] = u;
+          state[3] = v;
+          for (j = 0; j < 16; ++j) {
+            // InvSubBytes
+            state[j] = inv_s[state[j]];
+            // AddRoundKey
+            state[j] ^= key[j];
+          }
+          return state;
+        }
+        function encrypt256(input, key) {
+          var t, u, v, k;
+          var state = new Uint8Array(16);
+          state.set(input);
+          for (j = 0; j < 16; ++j) {
+            // AddRoundKey
+            state[j] ^= key[j];
+          }
+          for (i = 1; i < 14; i++) {
+            //SubBytes
+            for (j = 0; j < 16; ++j) {
+              state[j] = s[state[j]];
+            }
+            //ShiftRows
+            v = state[1];
+            state[1] = state[5];
+            state[5] = state[9];
+            state[9] = state[13];
+            state[13] = v;
+            v = state[2];
+            u = state[6];
+            state[2] = state[10];
+            state[6] = state[14];
+            state[10] = v;
+            state[14] = u;
+            v = state[3];
+            u = state[7];
+            t = state[11];
+            state[3] = state[15];
+            state[7] = v;
+            state[11] = u;
+            state[15] = t;
+            //MixColumns
+            for (var j = 0; j < 16; j += 4) {
+              var s0 = state[j + 0], s1 = state[j + 1];
+              var s2 = state[j + 2], s3 = state[j + 3];
+              t = s0 ^ s1 ^ s2 ^ s3;
+              state[j + 0] ^= t ^ mixCol[s0 ^ s1];
+              state[j + 1] ^= t ^ mixCol[s1 ^ s2];
+              state[j + 2] ^= t ^ mixCol[s2 ^ s3];
+              state[j + 3] ^= t ^ mixCol[s3 ^ s0];
+            }
+            //AddRoundKey
+            for (j = 0, k = i * 16; j < 16; ++j, ++k) {
+              state[j] ^= key[k];
+            }
+          }
+          //SubBytes
+          for (j = 0; j < 16; ++j) {
+            state[j] = s[state[j]];
+          }
+          //ShiftRows
+          v = state[1];
+          state[1] = state[5];
+          state[5] = state[9];
+          state[9] = state[13];
+          state[13] = v;
+          v = state[2];
+          u = state[6];
+          state[2] = state[10];
+          state[6] = state[14];
+          state[10] = v;
+          state[14] = u;
+          v = state[3];
+          u = state[7];
+          t = state[11];
+          state[3] = state[15];
+          state[7] = v;
+          state[11] = u;
+          state[15] = t;
+          //AddRoundKey
+          for (j = 0, k = 224; j < 16; ++j, ++k) {
+            state[j] ^= key[k];
+          }
+          return state;
+        }
+        function AES256Cipher(key) {
+          this.key = expandKey256(key);
+          this.buffer = new Uint8Array(16);
+          this.bufferPosition = 0;
+        }
+        function decryptBlock2(data, finalize) {
+          var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [], iv = this.iv;
+          for (i = 0; i < sourceLength; ++i) {
+            buffer[bufferLength] = data[i];
+            ++bufferLength;
+            if (bufferLength < 16) {
+              continue;
+            }
+            // buffer is full, decrypting
+            var plain = decrypt256(buffer, this.key);
+            // xor-ing the IV vector to get plain text
+            for (j = 0; j < 16; ++j) {
+              plain[j] ^= iv[j];
+            }
+            iv = buffer;
+            result.push(plain);
+            buffer = new Uint8Array(16);
+            bufferLength = 0;
+          }
+          // saving incomplete buffer
+          this.buffer = buffer;
+          this.bufferLength = bufferLength;
+          this.iv = iv;
+          if (result.length === 0) {
+            return new Uint8Array([]);
+          }
+          // combining plain text blocks into one
+          var outputLength = 16 * result.length;
+          if (finalize) {
+            // undo a padding that is described in RFC 2898
+            var lastBlock = result[result.length - 1];
+            var psLen = lastBlock[15];
+            if (psLen <= 16) {
+              for (i = 15, ii = 16 - psLen; i >= ii; --i) {
+                if (lastBlock[i] !== psLen) {
+                  // Invalid padding, assume that the block has no padding.
+                  psLen = 0;
+                  break;
+                }
+              }
+              outputLength -= psLen;
+              result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
+            }
+          }
+          var output = new Uint8Array(outputLength);
+          for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+            output.set(result[i], j);
+          }
+          return output;
+        }
+        AES256Cipher.prototype = {
+          decryptBlock: function AES256Cipher_decryptBlock(data, finalize, iv) {
+            var i, sourceLength = data.length;
+            var buffer = this.buffer, bufferLength = this.bufferPosition;
+            // if not supplied an IV wait for IV values
+            // they are at the start of the stream
+            if (iv) {
+              this.iv = iv;
+            } else {
+              for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {
+                buffer[bufferLength] = data[i];
+              }
+              if (bufferLength < 16) {
+                //need more data
+                this.bufferLength = bufferLength;
+                return new Uint8Array([]);
+              }
+              this.iv = buffer;
+              data = data.subarray(16);
+            }
+            this.buffer = new Uint8Array(16);
+            this.bufferLength = 0;
+            // starting decryption
+            this.decryptBlock = decryptBlock2;
+            return this.decryptBlock(data, finalize);
+          },
+          encrypt: function AES256Cipher_encrypt(data, iv) {
+            var i, j, ii, sourceLength = data.length, buffer = this.buffer, bufferLength = this.bufferPosition, result = [];
+            if (!iv) {
+              iv = new Uint8Array(16);
+            }
+            for (i = 0; i < sourceLength; ++i) {
+              buffer[bufferLength] = data[i];
+              ++bufferLength;
+              if (bufferLength < 16) {
+                continue;
+              }
+              for (j = 0; j < 16; ++j) {
+                buffer[j] ^= iv[j];
+              }
+              // buffer is full, encrypting
+              var cipher = encrypt256(buffer, this.key);
+              this.iv = cipher;
+              result.push(cipher);
+              buffer = new Uint8Array(16);
+              bufferLength = 0;
+            }
+            // saving incomplete buffer
+            this.buffer = buffer;
+            this.bufferLength = bufferLength;
+            this.iv = iv;
+            if (result.length === 0) {
+              return new Uint8Array([]);
+            }
+            // combining plain text blocks into one
+            var outputLength = 16 * result.length;
+            var output = new Uint8Array(outputLength);
+            for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
+              output.set(result[i], j);
+            }
+            return output;
+          }
+        };
+        return AES256Cipher;
+      }();
+      var PDF17 = function PDF17Closure() {
+        function compareByteArrays(array1, array2) {
+          if (array1.length !== array2.length) {
+            return false;
+          }
+          for (var i = 0; i < array1.length; i++) {
+            if (array1[i] !== array2[i]) {
+              return false;
+            }
+          }
+          return true;
+        }
+        function PDF17() {
+        }
+        PDF17.prototype = {
+          checkOwnerPassword: function PDF17_checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
+            var hashData = new Uint8Array(password.length + 56);
+            hashData.set(password, 0);
+            hashData.set(ownerValidationSalt, password.length);
+            hashData.set(userBytes, password.length + ownerValidationSalt.length);
+            var result = calculateSHA256(hashData, 0, hashData.length);
+            return compareByteArrays(result, ownerPassword);
+          },
+          checkUserPassword: function PDF17_checkUserPassword(password, userValidationSalt, userPassword) {
+            var hashData = new Uint8Array(password.length + 8);
+            hashData.set(password, 0);
+            hashData.set(userValidationSalt, password.length);
+            var result = calculateSHA256(hashData, 0, hashData.length);
+            return compareByteArrays(result, userPassword);
+          },
+          getOwnerKey: function PDF17_getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
+            var hashData = new Uint8Array(password.length + 56);
+            hashData.set(password, 0);
+            hashData.set(ownerKeySalt, password.length);
+            hashData.set(userBytes, password.length + ownerKeySalt.length);
+            var key = calculateSHA256(hashData, 0, hashData.length);
+            var cipher = new AES256Cipher(key);
+            return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
+          },
+          getUserKey: function PDF17_getUserKey(password, userKeySalt, userEncryption) {
+            var hashData = new Uint8Array(password.length + 8);
+            hashData.set(password, 0);
+            hashData.set(userKeySalt, password.length);
+            //key is the decryption key for the UE string
+            var key = calculateSHA256(hashData, 0, hashData.length);
+            var cipher = new AES256Cipher(key);
+            return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
+          }
+        };
+        return PDF17;
+      }();
+      var PDF20 = function PDF20Closure() {
+        function concatArrays(array1, array2) {
+          var t = new Uint8Array(array1.length + array2.length);
+          t.set(array1, 0);
+          t.set(array2, array1.length);
+          return t;
+        }
+        function calculatePDF20Hash(password, input, userBytes) {
+          //This refers to Algorithm 2.B as defined in ISO 32000-2
+          var k = calculateSHA256(input, 0, input.length).subarray(0, 32);
+          var e = [0];
+          var i = 0;
+          while (i < 64 || e[e.length - 1] > i - 32) {
+            var arrayLength = password.length + k.length + userBytes.length;
+            var k1 = new Uint8Array(arrayLength * 64);
+            var array = concatArrays(password, k);
+            array = concatArrays(array, userBytes);
+            for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) {
+              k1.set(array, pos);
+            }
+            //AES128 CBC NO PADDING with
+            //first 16 bytes of k as the key and the second 16 as the iv.
+            var cipher = new AES128Cipher(k.subarray(0, 16));
+            e = cipher.encrypt(k1, k.subarray(16, 32));
+            //Now we have to take the first 16 bytes of an unsigned
+            //big endian integer... and compute the remainder
+            //modulo 3.... That is a fairly large number and
+            //JavaScript isn't going to handle that well...
+            //So we're using a trick that allows us to perform
+            //modulo math byte by byte
+            var remainder = 0;
+            for (var z = 0; z < 16; z++) {
+              remainder *= 256 % 3;
+              remainder %= 3;
+              remainder += (e[z] >>> 0) % 3;
+              remainder %= 3;
+            }
+            if (remainder === 0) {
+              k = calculateSHA256(e, 0, e.length);
+            } else if (remainder === 1) {
+              k = calculateSHA384(e, 0, e.length);
+            } else if (remainder === 2) {
+              k = calculateSHA512(e, 0, e.length);
+            }
+            i++;
+          }
+          return k.subarray(0, 32);
+        }
+        function PDF20() {
+        }
+        function compareByteArrays(array1, array2) {
+          if (array1.length !== array2.length) {
+            return false;
+          }
+          for (var i = 0; i < array1.length; i++) {
+            if (array1[i] !== array2[i]) {
+              return false;
+            }
+          }
+          return true;
+        }
+        PDF20.prototype = {
+          hash: function PDF20_hash(password, concatBytes, userBytes) {
+            return calculatePDF20Hash(password, concatBytes, userBytes);
+          },
+          checkOwnerPassword: function PDF20_checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
+            var hashData = new Uint8Array(password.length + 56);
+            hashData.set(password, 0);
+            hashData.set(ownerValidationSalt, password.length);
+            hashData.set(userBytes, password.length + ownerValidationSalt.length);
+            var result = calculatePDF20Hash(password, hashData, userBytes);
+            return compareByteArrays(result, ownerPassword);
+          },
+          checkUserPassword: function PDF20_checkUserPassword(password, userValidationSalt, userPassword) {
+            var hashData = new Uint8Array(password.length + 8);
+            hashData.set(password, 0);
+            hashData.set(userValidationSalt, password.length);
+            var result = calculatePDF20Hash(password, hashData, []);
+            return compareByteArrays(result, userPassword);
+          },
+          getOwnerKey: function PDF20_getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
+            var hashData = new Uint8Array(password.length + 56);
+            hashData.set(password, 0);
+            hashData.set(ownerKeySalt, password.length);
+            hashData.set(userBytes, password.length + ownerKeySalt.length);
+            var key = calculatePDF20Hash(password, hashData, userBytes);
+            var cipher = new AES256Cipher(key);
+            return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
+          },
+          getUserKey: function PDF20_getUserKey(password, userKeySalt, userEncryption) {
+            var hashData = new Uint8Array(password.length + 8);
+            hashData.set(password, 0);
+            hashData.set(userKeySalt, password.length);
+            //key is the decryption key for the UE string
+            var key = calculatePDF20Hash(password, hashData, []);
+            var cipher = new AES256Cipher(key);
+            return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
+          }
+        };
+        return PDF20;
+      }();
+      var CipherTransform = function CipherTransformClosure() {
+        function CipherTransform(stringCipherConstructor, streamCipherConstructor) {
+          this.stringCipherConstructor = stringCipherConstructor;
+          this.streamCipherConstructor = streamCipherConstructor;
+        }
+        CipherTransform.prototype = {
+          createStream: function CipherTransform_createStream(stream, length) {
+            var cipher = new this.streamCipherConstructor();
+            return new DecryptStream(stream, length, function cipherTransformDecryptStream(data, finalize) {
+              return cipher.decryptBlock(data, finalize);
+            });
+          },
+          decryptString: function CipherTransform_decryptString(s) {
+            var cipher = new this.stringCipherConstructor();
+            var data = stringToBytes(s);
+            data = cipher.decryptBlock(data, true);
+            return bytesToString(data);
+          }
+        };
+        return CipherTransform;
+      }();
+      var CipherTransformFactory = function CipherTransformFactoryClosure() {
+        var defaultPasswordBytes = new Uint8Array([
+          0x28,
+          0xBF,
+          0x4E,
+          0x5E,
+          0x4E,
+          0x75,
+          0x8A,
+          0x41,
+          0x64,
+          0x00,
+          0x4E,
+          0x56,
+          0xFF,
+          0xFA,
+          0x01,
+          0x08,
+          0x2E,
+          0x2E,
+          0x00,
+          0xB6,
+          0xD0,
+          0x68,
+          0x3E,
+          0x80,
+          0x2F,
+          0x0C,
+          0xA9,
+          0xFE,
+          0x64,
+          0x53,
+          0x69,
+          0x7A
+        ]);
+        function createEncryptionKey20(revision, password, ownerPassword, ownerValidationSalt, ownerKeySalt, uBytes, userPassword, userValidationSalt, userKeySalt, ownerEncryption, userEncryption, perms) {
+          if (password) {
+            var passwordLength = Math.min(127, password.length);
+            password = password.subarray(0, passwordLength);
+          } else {
+            password = [];
+          }
+          var pdfAlgorithm;
+          if (revision === 6) {
+            pdfAlgorithm = new PDF20();
+          } else {
+            pdfAlgorithm = new PDF17();
+          }
+          if (pdfAlgorithm.checkUserPassword(password, userValidationSalt, userPassword)) {
+            return pdfAlgorithm.getUserKey(password, userKeySalt, userEncryption);
+          } else if (password.length && pdfAlgorithm.checkOwnerPassword(password, ownerValidationSalt, uBytes, ownerPassword)) {
+            return pdfAlgorithm.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
+          }
+          return null;
+        }
+        function prepareKeyData(fileId, password, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata) {
+          var hashDataSize = 40 + ownerPassword.length + fileId.length;
+          var hashData = new Uint8Array(hashDataSize), i = 0, j, n;
+          if (password) {
+            n = Math.min(32, password.length);
+            for (; i < n; ++i) {
+              hashData[i] = password[i];
+            }
+          }
+          j = 0;
+          while (i < 32) {
+            hashData[i++] = defaultPasswordBytes[j++];
+          }
+          // as now the padded password in the hashData[0..i]
+          for (j = 0, n = ownerPassword.length; j < n; ++j) {
+            hashData[i++] = ownerPassword[j];
+          }
+          hashData[i++] = flags & 0xFF;
+          hashData[i++] = flags >> 8 & 0xFF;
+          hashData[i++] = flags >> 16 & 0xFF;
+          hashData[i++] = flags >>> 24 & 0xFF;
+          for (j = 0, n = fileId.length; j < n; ++j) {
+            hashData[i++] = fileId[j];
+          }
+          if (revision >= 4 && !encryptMetadata) {
+            hashData[i++] = 0xFF;
+            hashData[i++] = 0xFF;
+            hashData[i++] = 0xFF;
+            hashData[i++] = 0xFF;
+          }
+          var hash = calculateMD5(hashData, 0, i);
+          var keyLengthInBytes = keyLength >> 3;
+          if (revision >= 3) {
+            for (j = 0; j < 50; ++j) {
+              hash = calculateMD5(hash, 0, keyLengthInBytes);
+            }
+          }
+          var encryptionKey = hash.subarray(0, keyLengthInBytes);
+          var cipher, checkData;
+          if (revision >= 3) {
+            for (i = 0; i < 32; ++i) {
+              hashData[i] = defaultPasswordBytes[i];
+            }
+            for (j = 0, n = fileId.length; j < n; ++j) {
+              hashData[i++] = fileId[j];
+            }
+            cipher = new ARCFourCipher(encryptionKey);
+            checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));
+            n = encryptionKey.length;
+            var derivedKey = new Uint8Array(n), k;
+            for (j = 1; j <= 19; ++j) {
+              for (k = 0; k < n; ++k) {
+                derivedKey[k] = encryptionKey[k] ^ j;
+              }
+              cipher = new ARCFourCipher(derivedKey);
+              checkData = cipher.encryptBlock(checkData);
+            }
+            for (j = 0, n = checkData.length; j < n; ++j) {
+              if (userPassword[j] !== checkData[j]) {
+                return null;
+              }
+            }
+          } else {
+            cipher = new ARCFourCipher(encryptionKey);
+            checkData = cipher.encryptBlock(defaultPasswordBytes);
+            for (j = 0, n = checkData.length; j < n; ++j) {
+              if (userPassword[j] !== checkData[j]) {
+                return null;
+              }
+            }
+          }
+          return encryptionKey;
+        }
+        function decodeUserPassword(password, ownerPassword, revision, keyLength) {
+          var hashData = new Uint8Array(32), i = 0, j, n;
+          n = Math.min(32, password.length);
+          for (; i < n; ++i) {
+            hashData[i] = password[i];
+          }
+          j = 0;
+          while (i < 32) {
+            hashData[i++] = defaultPasswordBytes[j++];
+          }
+          var hash = calculateMD5(hashData, 0, i);
+          var keyLengthInBytes = keyLength >> 3;
+          if (revision >= 3) {
+            for (j = 0; j < 50; ++j) {
+              hash = calculateMD5(hash, 0, hash.length);
+            }
+          }
+          var cipher, userPassword;
+          if (revision >= 3) {
+            userPassword = ownerPassword;
+            var derivedKey = new Uint8Array(keyLengthInBytes), k;
+            for (j = 19; j >= 0; j--) {
+              for (k = 0; k < keyLengthInBytes; ++k) {
+                derivedKey[k] = hash[k] ^ j;
+              }
+              cipher = new ARCFourCipher(derivedKey);
+              userPassword = cipher.encryptBlock(userPassword);
+            }
+          } else {
+            cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));
+            userPassword = cipher.encryptBlock(ownerPassword);
+          }
+          return userPassword;
+        }
+        var identityName = Name.get('Identity');
+        function CipherTransformFactory(dict, fileId, password) {
+          var filter = dict.get('Filter');
+          if (!isName(filter, 'Standard')) {
+            error('unknown encryption method');
+          }
+          this.dict = dict;
+          var algorithm = dict.get('V');
+          if (!isInt(algorithm) || algorithm !== 1 && algorithm !== 2 && algorithm !== 4 && algorithm !== 5) {
+            error('unsupported encryption algorithm');
+          }
+          this.algorithm = algorithm;
+          var keyLength = dict.get('Length');
+          if (!keyLength) {
+            // Spec asks to rely on encryption dictionary's Length entry, however
+            // some PDFs don't have it. Trying to recover.
+            if (algorithm <= 3) {
+              // For 1 and 2 it's fixed to 40-bit, for 3 40-bit is a minimal value.
+              keyLength = 40;
+            } else {
+              // Trying to find default handler -- it usually has Length.
+              var cfDict = dict.get('CF');
+              var streamCryptoName = dict.get('StmF');
+              if (isDict(cfDict) && isName(streamCryptoName)) {
+                cfDict.suppressEncryption = true;
+                // See comment below.
+                var handlerDict = cfDict.get(streamCryptoName.name);
+                keyLength = handlerDict && handlerDict.get('Length') || 128;
+                if (keyLength < 40) {
+                  // Sometimes it's incorrect value of bits, generators specify bytes.
+                  keyLength <<= 3;
+                }
+              }
+            }
+          }
+          if (!isInt(keyLength) || keyLength < 40 || keyLength % 8 !== 0) {
+            error('invalid key length');
+          }
+          // prepare keys
+          var ownerPassword = stringToBytes(dict.get('O')).subarray(0, 32);
+          var userPassword = stringToBytes(dict.get('U')).subarray(0, 32);
+          var flags = dict.get('P');
+          var revision = dict.get('R');
+          // meaningful when V is 4 or 5
+          var encryptMetadata = (algorithm === 4 || algorithm === 5) && dict.get('EncryptMetadata') !== false;
+          this.encryptMetadata = encryptMetadata;
+          var fileIdBytes = stringToBytes(fileId);
+          var passwordBytes;
+          if (password) {
+            if (revision === 6) {
+              try {
+                password = utf8StringToString(password);
+              } catch (ex) {
+                warn('CipherTransformFactory: ' + 'Unable to convert UTF8 encoded password.');
+              }
+            }
+            passwordBytes = stringToBytes(password);
+          }
+          var encryptionKey;
+          if (algorithm !== 5) {
+            encryptionKey = prepareKeyData(fileIdBytes, passwordBytes, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata);
+          } else {
+            var ownerValidationSalt = stringToBytes(dict.get('O')).subarray(32, 40);
+            var ownerKeySalt = stringToBytes(dict.get('O')).subarray(40, 48);
+            var uBytes = stringToBytes(dict.get('U')).subarray(0, 48);
+            var userValidationSalt = stringToBytes(dict.get('U')).subarray(32, 40);
+            var userKeySalt = stringToBytes(dict.get('U')).subarray(40, 48);
+            var ownerEncryption = stringToBytes(dict.get('OE'));
+            var userEncryption = stringToBytes(dict.get('UE'));
+            var perms = stringToBytes(dict.get('Perms'));
+            encryptionKey = createEncryptionKey20(revision, passwordBytes, ownerPassword, ownerValidationSalt, ownerKeySalt, uBytes, userPassword, userValidationSalt, userKeySalt, ownerEncryption, userEncryption, perms);
+          }
+          if (!encryptionKey && !password) {
+            throw new PasswordException('No password given', PasswordResponses.NEED_PASSWORD);
+          } else if (!encryptionKey && password) {
+            // Attempting use the password as an owner password
+            var decodedPassword = decodeUserPassword(passwordBytes, ownerPassword, revision, keyLength);
+            encryptionKey = prepareKeyData(fileIdBytes, decodedPassword, ownerPassword, userPassword, flags, revision, keyLength, encryptMetadata);
+          }
+          if (!encryptionKey) {
+            throw new PasswordException('Incorrect Password', PasswordResponses.INCORRECT_PASSWORD);
+          }
+          this.encryptionKey = encryptionKey;
+          if (algorithm >= 4) {
+            var cf = dict.get('CF');
+            if (isDict(cf)) {
+              // The 'CF' dictionary itself should not be encrypted, and by setting
+              // `suppressEncryption` we can prevent an infinite loop inside of
+              // `XRef_fetchUncompressed` if the dictionary contains indirect objects
+              // (fixes issue7665.pdf).
+              cf.suppressEncryption = true;
+            }
+            this.cf = cf;
+            this.stmf = dict.get('StmF') || identityName;
+            this.strf = dict.get('StrF') || identityName;
+            this.eff = dict.get('EFF') || this.stmf;
+          }
+        }
+        function buildObjectKey(num, gen, encryptionKey, isAes) {
+          var key = new Uint8Array(encryptionKey.length + 9), i, n;
+          for (i = 0, n = encryptionKey.length; i < n; ++i) {
+            key[i] = encryptionKey[i];
+          }
+          key[i++] = num & 0xFF;
+          key[i++] = num >> 8 & 0xFF;
+          key[i++] = num >> 16 & 0xFF;
+          key[i++] = gen & 0xFF;
+          key[i++] = gen >> 8 & 0xFF;
+          if (isAes) {
+            key[i++] = 0x73;
+            key[i++] = 0x41;
+            key[i++] = 0x6C;
+            key[i++] = 0x54;
+          }
+          var hash = calculateMD5(key, 0, i);
+          return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));
+        }
+        function buildCipherConstructor(cf, name, num, gen, key) {
+          assert(isName(name), 'Invalid crypt filter name.');
+          var cryptFilter = cf.get(name.name);
+          var cfm;
+          if (cryptFilter !== null && cryptFilter !== undefined) {
+            cfm = cryptFilter.get('CFM');
+          }
+          if (!cfm || cfm.name === 'None') {
+            return function cipherTransformFactoryBuildCipherConstructorNone() {
+              return new NullCipher();
+            };
+          }
+          if ('V2' === cfm.name) {
+            return function cipherTransformFactoryBuildCipherConstructorV2() {
+              return new ARCFourCipher(buildObjectKey(num, gen, key, false));
+            };
+          }
+          if ('AESV2' === cfm.name) {
+            return function cipherTransformFactoryBuildCipherConstructorAESV2() {
+              return new AES128Cipher(buildObjectKey(num, gen, key, true));
+            };
+          }
+          if ('AESV3' === cfm.name) {
+            return function cipherTransformFactoryBuildCipherConstructorAESV3() {
+              return new AES256Cipher(key);
+            };
+          }
+          error('Unknown crypto method');
+        }
+        CipherTransformFactory.prototype = {
+          createCipherTransform: function CipherTransformFactory_createCipherTransform(num, gen) {
+            if (this.algorithm === 4 || this.algorithm === 5) {
+              return new CipherTransform(buildCipherConstructor(this.cf, this.stmf, num, gen, this.encryptionKey), buildCipherConstructor(this.cf, this.strf, num, gen, this.encryptionKey));
+            }
+            // algorithms 1 and 2
+            var key = buildObjectKey(num, gen, this.encryptionKey, false);
+            var cipherConstructor = function buildCipherCipherConstructor() {
+              return new ARCFourCipher(key);
+            };
+            return new CipherTransform(cipherConstructor, cipherConstructor);
+          }
+        };
+        return CipherTransformFactory;
+      }();
+      exports.AES128Cipher = AES128Cipher;
+      exports.AES256Cipher = AES256Cipher;
+      exports.ARCFourCipher = ARCFourCipher;
+      exports.CipherTransformFactory = CipherTransformFactory;
+      exports.PDF17 = PDF17;
+      exports.PDF20 = PDF20;
+      exports.calculateMD5 = calculateMD5;
+      exports.calculateSHA256 = calculateSHA256;
+      exports.calculateSHA384 = calculateSHA384;
+      exports.calculateSHA512 = calculateSHA512;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreFontRenderer = {}, root.pdfjsSharedUtil, root.pdfjsCoreStream, root.pdfjsCoreGlyphList, root.pdfjsCoreEncodings, root.pdfjsCoreCFFParser);
+    }(this, function (exports, sharedUtil, coreStream, coreGlyphList, coreEncodings, coreCFFParser) {
+      var Util = sharedUtil.Util;
+      var bytesToString = sharedUtil.bytesToString;
+      var error = sharedUtil.error;
+      var Stream = coreStream.Stream;
+      var getGlyphsUnicode = coreGlyphList.getGlyphsUnicode;
+      var StandardEncoding = coreEncodings.StandardEncoding;
+      var CFFParser = coreCFFParser.CFFParser;
+      var FontRendererFactory = function FontRendererFactoryClosure() {
+        function getLong(data, offset) {
+          return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+        }
+        function getUshort(data, offset) {
+          return data[offset] << 8 | data[offset + 1];
+        }
+        function parseCmap(data, start, end) {
+          var offset = getUshort(data, start + 2) === 1 ? getLong(data, start + 8) : getLong(data, start + 16);
+          var format = getUshort(data, start + offset);
+          var length, ranges, p, i;
+          if (format === 4) {
+            length = getUshort(data, start + offset + 2);
+            var segCount = getUshort(data, start + offset + 6) >> 1;
+            p = start + offset + 14;
+            ranges = [];
+            for (i = 0; i < segCount; i++, p += 2) {
+              ranges[i] = { end: getUshort(data, p) };
+            }
+            p += 2;
+            for (i = 0; i < segCount; i++, p += 2) {
+              ranges[i].start = getUshort(data, p);
+            }
+            for (i = 0; i < segCount; i++, p += 2) {
+              ranges[i].idDelta = getUshort(data, p);
+            }
+            for (i = 0; i < segCount; i++, p += 2) {
+              var idOffset = getUshort(data, p);
+              if (idOffset === 0) {
+                continue;
+              }
+              ranges[i].ids = [];
+              for (var j = 0, jj = ranges[i].end - ranges[i].start + 1; j < jj; j++) {
+                ranges[i].ids[j] = getUshort(data, p + idOffset);
+                idOffset += 2;
+              }
+            }
+            return ranges;
+          } else if (format === 12) {
+            length = getLong(data, start + offset + 4);
+            var groups = getLong(data, start + offset + 12);
+            p = start + offset + 16;
+            ranges = [];
+            for (i = 0; i < groups; i++) {
+              ranges.push({
+                start: getLong(data, p),
+                end: getLong(data, p + 4),
+                idDelta: getLong(data, p + 8) - getLong(data, p)
+              });
+              p += 12;
+            }
+            return ranges;
+          }
+          error('not supported cmap: ' + format);
+        }
+        function parseCff(data, start, end, seacAnalysisEnabled) {
+          var properties = {};
+          var parser = new CFFParser(new Stream(data, start, end - start), properties, seacAnalysisEnabled);
+          var cff = parser.parse();
+          return {
+            glyphs: cff.charStrings.objects,
+            subrs: cff.topDict.privateDict && cff.topDict.privateDict.subrsIndex && cff.topDict.privateDict.subrsIndex.objects,
+            gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects
+          };
+        }
+        function parseGlyfTable(glyf, loca, isGlyphLocationsLong) {
+          var itemSize, itemDecode;
+          if (isGlyphLocationsLong) {
+            itemSize = 4;
+            itemDecode = function fontItemDecodeLong(data, offset) {
+              return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+            };
+          } else {
+            itemSize = 2;
+            itemDecode = function fontItemDecode(data, offset) {
+              return data[offset] << 9 | data[offset + 1] << 1;
+            };
+          }
+          var glyphs = [];
+          var startOffset = itemDecode(loca, 0);
+          for (var j = itemSize; j < loca.length; j += itemSize) {
+            var endOffset = itemDecode(loca, j);
+            glyphs.push(glyf.subarray(startOffset, endOffset));
+            startOffset = endOffset;
+          }
+          return glyphs;
+        }
+        function lookupCmap(ranges, unicode) {
+          var code = unicode.charCodeAt(0), gid = 0;
+          var l = 0, r = ranges.length - 1;
+          while (l < r) {
+            var c = l + r + 1 >> 1;
+            if (code < ranges[c].start) {
+              r = c - 1;
+            } else {
+              l = c;
+            }
+          }
+          if (ranges[l].start <= code && code <= ranges[l].end) {
+            gid = ranges[l].idDelta + (ranges[l].ids ? ranges[l].ids[code - ranges[l].start] : code) & 0xFFFF;
+          }
+          return {
+            charCode: code,
+            glyphId: gid
+          };
+        }
+        function compileGlyf(code, cmds, font) {
+          function moveTo(x, y) {
+            cmds.push({
+              cmd: 'moveTo',
+              args: [
+                x,
+                y
+              ]
+            });
+          }
+          function lineTo(x, y) {
+            cmds.push({
+              cmd: 'lineTo',
+              args: [
+                x,
+                y
+              ]
+            });
+          }
+          function quadraticCurveTo(xa, ya, x, y) {
+            cmds.push({
+              cmd: 'quadraticCurveTo',
+              args: [
+                xa,
+                ya,
+                x,
+                y
+              ]
+            });
+          }
+          var i = 0;
+          var numberOfContours = (code[i] << 24 | code[i + 1] << 16) >> 16;
+          var flags;
+          var x = 0, y = 0;
+          i += 10;
+          if (numberOfContours < 0) {
+            // composite glyph
+            do {
+              flags = code[i] << 8 | code[i + 1];
+              var glyphIndex = code[i + 2] << 8 | code[i + 3];
+              i += 4;
+              var arg1, arg2;
+              if (flags & 0x01) {
+                arg1 = (code[i] << 24 | code[i + 1] << 16) >> 16;
+                arg2 = (code[i + 2] << 24 | code[i + 3] << 16) >> 16;
+                i += 4;
+              } else {
+                arg1 = code[i++];
+                arg2 = code[i++];
+              }
+              if (flags & 0x02) {
+                x = arg1;
+                y = arg2;
+              } else {
+                x = 0;
+                y = 0;
+              }
+              // TODO "they are points" ?
+              var scaleX = 1, scaleY = 1, scale01 = 0, scale10 = 0;
+              if (flags & 0x08) {
+                scaleX = scaleY = (code[i] << 24 | code[i + 1] << 16) / 1073741824;
+                i += 2;
+              } else if (flags & 0x40) {
+                scaleX = (code[i] << 24 | code[i + 1] << 16) / 1073741824;
+                scaleY = (code[i + 2] << 24 | code[i + 3] << 16) / 1073741824;
+                i += 4;
+              } else if (flags & 0x80) {
+                scaleX = (code[i] << 24 | code[i + 1] << 16) / 1073741824;
+                scale01 = (code[i + 2] << 24 | code[i + 3] << 16) / 1073741824;
+                scale10 = (code[i + 4] << 24 | code[i + 5] << 16) / 1073741824;
+                scaleY = (code[i + 6] << 24 | code[i + 7] << 16) / 1073741824;
+                i += 8;
+              }
+              var subglyph = font.glyphs[glyphIndex];
+              if (subglyph) {
+                cmds.push({ cmd: 'save' });
+                cmds.push({
+                  cmd: 'transform',
+                  args: [
+                    scaleX,
+                    scale01,
+                    scale10,
+                    scaleY,
+                    x,
+                    y
+                  ]
+                });
+                compileGlyf(subglyph, cmds, font);
+                cmds.push({ cmd: 'restore' });
+              }
+            } while (flags & 0x20);
+          } else {
+            // simple glyph
+            var endPtsOfContours = [];
+            var j, jj;
+            for (j = 0; j < numberOfContours; j++) {
+              endPtsOfContours.push(code[i] << 8 | code[i + 1]);
+              i += 2;
+            }
+            var instructionLength = code[i] << 8 | code[i + 1];
+            i += 2 + instructionLength;
+            // skipping the instructions
+            var numberOfPoints = endPtsOfContours[endPtsOfContours.length - 1] + 1;
+            var points = [];
+            while (points.length < numberOfPoints) {
+              flags = code[i++];
+              var repeat = 1;
+              if (flags & 0x08) {
+                repeat += code[i++];
+              }
+              while (repeat-- > 0) {
+                points.push({ flags: flags });
+              }
+            }
+            for (j = 0; j < numberOfPoints; j++) {
+              switch (points[j].flags & 0x12) {
+              case 0x00:
+                x += (code[i] << 24 | code[i + 1] << 16) >> 16;
+                i += 2;
+                break;
+              case 0x02:
+                x -= code[i++];
+                break;
+              case 0x12:
+                x += code[i++];
+                break;
+              }
+              points[j].x = x;
+            }
+            for (j = 0; j < numberOfPoints; j++) {
+              switch (points[j].flags & 0x24) {
+              case 0x00:
+                y += (code[i] << 24 | code[i + 1] << 16) >> 16;
+                i += 2;
+                break;
+              case 0x04:
+                y -= code[i++];
+                break;
+              case 0x24:
+                y += code[i++];
+                break;
+              }
+              points[j].y = y;
+            }
+            var startPoint = 0;
+            for (i = 0; i < numberOfContours; i++) {
+              var endPoint = endPtsOfContours[i];
+              // contours might have implicit points, which is located in the middle
+              // between two neighboring off-curve points
+              var contour = points.slice(startPoint, endPoint + 1);
+              if (contour[0].flags & 1) {
+                contour.push(contour[0]);
+              } else // using start point at the contour end
+              if (contour[contour.length - 1].flags & 1) {
+                // first is off-curve point, trying to use one from the end
+                contour.unshift(contour[contour.length - 1]);
+              } else {
+                // start and end are off-curve points, creating implicit one
+                var p = {
+                  flags: 1,
+                  x: (contour[0].x + contour[contour.length - 1].x) / 2,
+                  y: (contour[0].y + contour[contour.length - 1].y) / 2
+                };
+                contour.unshift(p);
+                contour.push(p);
+              }
+              moveTo(contour[0].x, contour[0].y);
+              for (j = 1, jj = contour.length; j < jj; j++) {
+                if (contour[j].flags & 1) {
+                  lineTo(contour[j].x, contour[j].y);
+                } else if (contour[j + 1].flags & 1) {
+                  quadraticCurveTo(contour[j].x, contour[j].y, contour[j + 1].x, contour[j + 1].y);
+                  j++;
+                } else {
+                  quadraticCurveTo(contour[j].x, contour[j].y, (contour[j].x + contour[j + 1].x) / 2, (contour[j].y + contour[j + 1].y) / 2);
+                }
+              }
+              startPoint = endPoint + 1;
+            }
+          }
+        }
+        function compileCharString(code, cmds, font) {
+          var stack = [];
+          var x = 0, y = 0;
+          var stems = 0;
+          function moveTo(x, y) {
+            cmds.push({
+              cmd: 'moveTo',
+              args: [
+                x,
+                y
+              ]
+            });
+          }
+          function lineTo(x, y) {
+            cmds.push({
+              cmd: 'lineTo',
+              args: [
+                x,
+                y
+              ]
+            });
+          }
+          function bezierCurveTo(x1, y1, x2, y2, x, y) {
+            cmds.push({
+              cmd: 'bezierCurveTo',
+              args: [
+                x1,
+                y1,
+                x2,
+                y2,
+                x,
+                y
+              ]
+            });
+          }
+          function parse(code) {
+            var i = 0;
+            while (i < code.length) {
+              var stackClean = false;
+              var v = code[i++];
+              var xa, xb, ya, yb, y1, y2, y3, n, subrCode;
+              switch (v) {
+              case 1:
+                // hstem
+                stems += stack.length >> 1;
+                stackClean = true;
+                break;
+              case 3:
+                // vstem
+                stems += stack.length >> 1;
+                stackClean = true;
+                break;
+              case 4:
+                // vmoveto
+                y += stack.pop();
+                moveTo(x, y);
+                stackClean = true;
+                break;
+              case 5:
+                // rlineto
+                while (stack.length > 0) {
+                  x += stack.shift();
+                  y += stack.shift();
+                  lineTo(x, y);
+                }
+                break;
+              case 6:
+                // hlineto
+                while (stack.length > 0) {
+                  x += stack.shift();
+                  lineTo(x, y);
+                  if (stack.length === 0) {
+                    break;
+                  }
+                  y += stack.shift();
+                  lineTo(x, y);
+                }
+                break;
+              case 7:
+                // vlineto
+                while (stack.length > 0) {
+                  y += stack.shift();
+                  lineTo(x, y);
+                  if (stack.length === 0) {
+                    break;
+                  }
+                  x += stack.shift();
+                  lineTo(x, y);
+                }
+                break;
+              case 8:
+                // rrcurveto
+                while (stack.length > 0) {
+                  xa = x + stack.shift();
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + stack.shift();
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                }
+                break;
+              case 10:
+                // callsubr
+                n = stack.pop() + font.subrsBias;
+                subrCode = font.subrs[n];
+                if (subrCode) {
+                  parse(subrCode);
+                }
+                break;
+              case 11:
+                // return
+                return;
+              case 12:
+                v = code[i++];
+                switch (v) {
+                case 34:
+                  // flex
+                  xa = x + stack.shift();
+                  xb = xa + stack.shift();
+                  y1 = y + stack.shift();
+                  x = xb + stack.shift();
+                  bezierCurveTo(xa, y, xb, y1, x, y1);
+                  xa = x + stack.shift();
+                  xb = xa + stack.shift();
+                  x = xb + stack.shift();
+                  bezierCurveTo(xa, y1, xb, y, x, y);
+                  break;
+                case 35:
+                  // flex
+                  xa = x + stack.shift();
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + stack.shift();
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                  xa = x + stack.shift();
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + stack.shift();
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                  stack.pop();
+                  // fd
+                  break;
+                case 36:
+                  // hflex1
+                  xa = x + stack.shift();
+                  y1 = y + stack.shift();
+                  xb = xa + stack.shift();
+                  y2 = y1 + stack.shift();
+                  x = xb + stack.shift();
+                  bezierCurveTo(xa, y1, xb, y2, x, y2);
+                  xa = x + stack.shift();
+                  xb = xa + stack.shift();
+                  y3 = y2 + stack.shift();
+                  x = xb + stack.shift();
+                  bezierCurveTo(xa, y2, xb, y3, x, y);
+                  break;
+                case 37:
+                  // flex1
+                  var x0 = x, y0 = y;
+                  xa = x + stack.shift();
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + stack.shift();
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                  xa = x + stack.shift();
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb;
+                  y = yb;
+                  if (Math.abs(x - x0) > Math.abs(y - y0)) {
+                    x += stack.shift();
+                  } else {
+                    y += stack.shift();
+                  }
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                  break;
+                default:
+                  error('unknown operator: 12 ' + v);
+                }
+                break;
+              case 14:
+                // endchar
+                if (stack.length >= 4) {
+                  var achar = stack.pop();
+                  var bchar = stack.pop();
+                  y = stack.pop();
+                  x = stack.pop();
+                  cmds.push({ cmd: 'save' });
+                  cmds.push({
+                    cmd: 'translate',
+                    args: [
+                      x,
+                      y
+                    ]
+                  });
+                  var cmap = lookupCmap(font.cmap, String.fromCharCode(font.glyphNameMap[StandardEncoding[achar]]));
+                  compileCharString(font.glyphs[cmap.glyphId], cmds, font);
+                  cmds.push({ cmd: 'restore' });
+                  cmap = lookupCmap(font.cmap, String.fromCharCode(font.glyphNameMap[StandardEncoding[bchar]]));
+                  compileCharString(font.glyphs[cmap.glyphId], cmds, font);
+                }
+                return;
+              case 18:
+                // hstemhm
+                stems += stack.length >> 1;
+                stackClean = true;
+                break;
+              case 19:
+                // hintmask
+                stems += stack.length >> 1;
+                i += stems + 7 >> 3;
+                stackClean = true;
+                break;
+              case 20:
+                // cntrmask
+                stems += stack.length >> 1;
+                i += stems + 7 >> 3;
+                stackClean = true;
+                break;
+              case 21:
+                // rmoveto
+                y += stack.pop();
+                x += stack.pop();
+                moveTo(x, y);
+                stackClean = true;
+                break;
+              case 22:
+                // hmoveto
+                x += stack.pop();
+                moveTo(x, y);
+                stackClean = true;
+                break;
+              case 23:
+                // vstemhm
+                stems += stack.length >> 1;
+                stackClean = true;
+                break;
+              case 24:
+                // rcurveline
+                while (stack.length > 2) {
+                  xa = x + stack.shift();
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + stack.shift();
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                }
+                x += stack.shift();
+                y += stack.shift();
+                lineTo(x, y);
+                break;
+              case 25:
+                // rlinecurve
+                while (stack.length > 6) {
+                  x += stack.shift();
+                  y += stack.shift();
+                  lineTo(x, y);
+                }
+                xa = x + stack.shift();
+                ya = y + stack.shift();
+                xb = xa + stack.shift();
+                yb = ya + stack.shift();
+                x = xb + stack.shift();
+                y = yb + stack.shift();
+                bezierCurveTo(xa, ya, xb, yb, x, y);
+                break;
+              case 26:
+                // vvcurveto
+                if (stack.length % 2) {
+                  x += stack.shift();
+                }
+                while (stack.length > 0) {
+                  xa = x;
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb;
+                  y = yb + stack.shift();
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                }
+                break;
+              case 27:
+                // hhcurveto
+                if (stack.length % 2) {
+                  y += stack.shift();
+                }
+                while (stack.length > 0) {
+                  xa = x + stack.shift();
+                  ya = y;
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb;
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                }
+                break;
+              case 28:
+                stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
+                i += 2;
+                break;
+              case 29:
+                // callgsubr
+                n = stack.pop() + font.gsubrsBias;
+                subrCode = font.gsubrs[n];
+                if (subrCode) {
+                  parse(subrCode);
+                }
+                break;
+              case 30:
+                // vhcurveto
+                while (stack.length > 0) {
+                  xa = x;
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + (stack.length === 1 ? stack.shift() : 0);
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                  if (stack.length === 0) {
+                    break;
+                  }
+                  xa = x + stack.shift();
+                  ya = y;
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  y = yb + stack.shift();
+                  x = xb + (stack.length === 1 ? stack.shift() : 0);
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                }
+                break;
+              case 31:
+                // hvcurveto
+                while (stack.length > 0) {
+                  xa = x + stack.shift();
+                  ya = y;
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  y = yb + stack.shift();
+                  x = xb + (stack.length === 1 ? stack.shift() : 0);
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                  if (stack.length === 0) {
+                    break;
+                  }
+                  xa = x;
+                  ya = y + stack.shift();
+                  xb = xa + stack.shift();
+                  yb = ya + stack.shift();
+                  x = xb + stack.shift();
+                  y = yb + (stack.length === 1 ? stack.shift() : 0);
+                  bezierCurveTo(xa, ya, xb, yb, x, y);
+                }
+                break;
+              default:
+                if (v < 32) {
+                  error('unknown operator: ' + v);
+                }
+                if (v < 247) {
+                  stack.push(v - 139);
+                } else if (v < 251) {
+                  stack.push((v - 247) * 256 + code[i++] + 108);
+                } else if (v < 255) {
+                  stack.push(-(v - 251) * 256 - code[i++] - 108);
+                } else {
+                  stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
+                  i += 4;
+                }
+                break;
+              }
+              if (stackClean) {
+                stack.length = 0;
+              }
+            }
+          }
+          parse(code);
+        }
+        var noop = '';
+        function CompiledFont(fontMatrix) {
+          this.compiledGlyphs = Object.create(null);
+          this.compiledCharCodeToGlyphId = Object.create(null);
+          this.fontMatrix = fontMatrix;
+        }
+        CompiledFont.prototype = {
+          getPathJs: function (unicode) {
+            var cmap = lookupCmap(this.cmap, unicode);
+            var fn = this.compiledGlyphs[cmap.glyphId];
+            if (!fn) {
+              fn = this.compileGlyph(this.glyphs[cmap.glyphId]);
+              this.compiledGlyphs[cmap.glyphId] = fn;
+            }
+            if (this.compiledCharCodeToGlyphId[cmap.charCode] === undefined) {
+              this.compiledCharCodeToGlyphId[cmap.charCode] = cmap.glyphId;
+            }
+            return fn;
+          },
+          compileGlyph: function (code) {
+            if (!code || code.length === 0 || code[0] === 14) {
+              return noop;
+            }
+            var cmds = [];
+            cmds.push({ cmd: 'save' });
+            cmds.push({
+              cmd: 'transform',
+              args: this.fontMatrix.slice()
+            });
+            cmds.push({
+              cmd: 'scale',
+              args: [
+                'size',
+                '-size'
+              ]
+            });
+            this.compileGlyphImpl(code, cmds);
+            cmds.push({ cmd: 'restore' });
+            return cmds;
+          },
+          compileGlyphImpl: function () {
+            error('Children classes should implement this.');
+          },
+          hasBuiltPath: function (unicode) {
+            var cmap = lookupCmap(this.cmap, unicode);
+            return this.compiledGlyphs[cmap.glyphId] !== undefined && this.compiledCharCodeToGlyphId[cmap.charCode] !== undefined;
+          }
+        };
+        function TrueTypeCompiled(glyphs, cmap, fontMatrix) {
+          fontMatrix = fontMatrix || [
+            0.000488,
+            0,
+            0,
+            0.000488,
+            0,
+            0
+          ];
+          CompiledFont.call(this, fontMatrix);
+          this.glyphs = glyphs;
+          this.cmap = cmap;
+        }
+        Util.inherit(TrueTypeCompiled, CompiledFont, {
+          compileGlyphImpl: function (code, cmds) {
+            compileGlyf(code, cmds, this);
+          }
+        });
+        function Type2Compiled(cffInfo, cmap, fontMatrix, glyphNameMap) {
+          fontMatrix = fontMatrix || [
+            0.001,
+            0,
+            0,
+            0.001,
+            0,
+            0
+          ];
+          CompiledFont.call(this, fontMatrix);
+          this.glyphs = cffInfo.glyphs;
+          this.gsubrs = cffInfo.gsubrs || [];
+          this.subrs = cffInfo.subrs || [];
+          this.cmap = cmap;
+          this.glyphNameMap = glyphNameMap || getGlyphsUnicode();
+          this.gsubrsBias = this.gsubrs.length < 1240 ? 107 : this.gsubrs.length < 33900 ? 1131 : 32768;
+          this.subrsBias = this.subrs.length < 1240 ? 107 : this.subrs.length < 33900 ? 1131 : 32768;
+        }
+        Util.inherit(Type2Compiled, CompiledFont, {
+          compileGlyphImpl: function (code, cmds) {
+            compileCharString(code, cmds, this);
+          }
+        });
+        return {
+          create: function FontRendererFactory_create(font, seacAnalysisEnabled) {
+            var data = new Uint8Array(font.data);
+            var cmap, glyf, loca, cff, indexToLocFormat, unitsPerEm;
+            var numTables = getUshort(data, 4);
+            for (var i = 0, p = 12; i < numTables; i++, p += 16) {
+              var tag = bytesToString(data.subarray(p, p + 4));
+              var offset = getLong(data, p + 8);
+              var length = getLong(data, p + 12);
+              switch (tag) {
+              case 'cmap':
+                cmap = parseCmap(data, offset, offset + length);
+                break;
+              case 'glyf':
+                glyf = data.subarray(offset, offset + length);
+                break;
+              case 'loca':
+                loca = data.subarray(offset, offset + length);
+                break;
+              case 'head':
+                unitsPerEm = getUshort(data, offset + 18);
+                indexToLocFormat = getUshort(data, offset + 50);
+                break;
+              case 'CFF ':
+                cff = parseCff(data, offset, offset + length, seacAnalysisEnabled);
+                break;
+              }
+            }
+            if (glyf) {
+              var fontMatrix = !unitsPerEm ? font.fontMatrix : [
+                1 / unitsPerEm,
+                0,
+                0,
+                1 / unitsPerEm,
+                0,
+                0
+              ];
+              return new TrueTypeCompiled(parseGlyfTable(glyf, loca, indexToLocFormat), cmap, fontMatrix);
+            } else {
+              return new Type2Compiled(cff, cmap, font.fontMatrix, font.glyphNameMap);
+            }
+          }
+        };
+      }();
+      exports.FontRendererFactory = FontRendererFactory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreParser = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream) {
+      var MissingDataException = sharedUtil.MissingDataException;
+      var StreamType = sharedUtil.StreamType;
+      var assert = sharedUtil.assert;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isInt = sharedUtil.isInt;
+      var isNum = sharedUtil.isNum;
+      var isString = sharedUtil.isString;
+      var warn = sharedUtil.warn;
+      var Cmd = corePrimitives.Cmd;
+      var Dict = corePrimitives.Dict;
+      var Name = corePrimitives.Name;
+      var Ref = corePrimitives.Ref;
+      var isCmd = corePrimitives.isCmd;
+      var isDict = corePrimitives.isDict;
+      var isName = corePrimitives.isName;
+      var Ascii85Stream = coreStream.Ascii85Stream;
+      var AsciiHexStream = coreStream.AsciiHexStream;
+      var CCITTFaxStream = coreStream.CCITTFaxStream;
+      var FlateStream = coreStream.FlateStream;
+      var Jbig2Stream = coreStream.Jbig2Stream;
+      var JpegStream = coreStream.JpegStream;
+      var JpxStream = coreStream.JpxStream;
+      var LZWStream = coreStream.LZWStream;
+      var NullStream = coreStream.NullStream;
+      var PredictorStream = coreStream.PredictorStream;
+      var RunLengthStream = coreStream.RunLengthStream;
+      var EOF = {};
+      function isEOF(v) {
+        return v === EOF;
+      }
+      var MAX_LENGTH_TO_CACHE = 1000;
+      var Parser = function ParserClosure() {
+        function Parser(lexer, allowStreams, xref, recoveryMode) {
+          this.lexer = lexer;
+          this.allowStreams = allowStreams;
+          this.xref = xref;
+          this.recoveryMode = recoveryMode || false;
+          this.imageCache = Object.create(null);
+          this.refill();
+        }
+        Parser.prototype = {
+          refill: function Parser_refill() {
+            this.buf1 = this.lexer.getObj();
+            this.buf2 = this.lexer.getObj();
+          },
+          shift: function Parser_shift() {
+            if (isCmd(this.buf2, 'ID')) {
+              this.buf1 = this.buf2;
+              this.buf2 = null;
+            } else {
+              this.buf1 = this.buf2;
+              this.buf2 = this.lexer.getObj();
+            }
+          },
+          tryShift: function Parser_tryShift() {
+            try {
+              this.shift();
+              return true;
+            } catch (e) {
+              if (e instanceof MissingDataException) {
+                throw e;
+              }
+              // Upon failure, the caller should reset this.lexer.pos to a known good
+              // state and call this.shift() twice to reset the buffers.
+              return false;
+            }
+          },
+          getObj: function Parser_getObj(cipherTransform) {
+            var buf1 = this.buf1;
+            this.shift();
+            if (buf1 instanceof Cmd) {
+              switch (buf1.cmd) {
+              case 'BI':
+                // inline image
+                return this.makeInlineImage(cipherTransform);
+              case '[':
+                // array
+                var array = [];
+                while (!isCmd(this.buf1, ']') && !isEOF(this.buf1)) {
+                  array.push(this.getObj(cipherTransform));
+                }
+                if (isEOF(this.buf1)) {
+                  if (!this.recoveryMode) {
+                    error('End of file inside array');
+                  }
+                  return array;
+                }
+                this.shift();
+                return array;
+              case '<<':
+                // dictionary or stream
+                var dict = new Dict(this.xref);
+                while (!isCmd(this.buf1, '>>') && !isEOF(this.buf1)) {
+                  if (!isName(this.buf1)) {
+                    info('Malformed dictionary: key must be a name object');
+                    this.shift();
+                    continue;
+                  }
+                  var key = this.buf1.name;
+                  this.shift();
+                  if (isEOF(this.buf1)) {
+                    break;
+                  }
+                  dict.set(key, this.getObj(cipherTransform));
+                }
+                if (isEOF(this.buf1)) {
+                  if (!this.recoveryMode) {
+                    error('End of file inside dictionary');
+                  }
+                  return dict;
+                }
+                // Stream objects are not allowed inside content streams or
+                // object streams.
+                if (isCmd(this.buf2, 'stream')) {
+                  return this.allowStreams ? this.makeStream(dict, cipherTransform) : dict;
+                }
+                this.shift();
+                return dict;
+              default:
+                // simple object
+                return buf1;
+              }
+            }
+            if (isInt(buf1)) {
+              // indirect reference or integer
+              var num = buf1;
+              if (isInt(this.buf1) && isCmd(this.buf2, 'R')) {
+                var ref = new Ref(num, this.buf1);
+                this.shift();
+                this.shift();
+                return ref;
+              }
+              return num;
+            }
+            if (isString(buf1)) {
+              // string
+              var str = buf1;
+              if (cipherTransform) {
+                str = cipherTransform.decryptString(str);
+              }
+              return str;
+            }
+            // simple object
+            return buf1;
+          },
+          /**
+           * Find the end of the stream by searching for the /EI\s/.
+           * @returns {number} The inline stream length.
+           */
+          findDefaultInlineStreamEnd: function Parser_findDefaultInlineStreamEnd(stream) {
+            var E = 0x45, I = 0x49, SPACE = 0x20, LF = 0xA, CR = 0xD;
+            var startPos = stream.pos, state = 0, ch, i, n, followingBytes;
+            while ((ch = stream.getByte()) !== -1) {
+              if (state === 0) {
+                state = ch === E ? 1 : 0;
+              } else if (state === 1) {
+                state = ch === I ? 2 : 0;
+              } else {
+                assert(state === 2);
+                if (ch === SPACE || ch === LF || ch === CR) {
+                  // Let's check the next five bytes are ASCII... just be sure.
+                  n = 5;
+                  followingBytes = stream.peekBytes(n);
+                  for (i = 0; i < n; i++) {
+                    ch = followingBytes[i];
+                    if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7F)) {
+                      // Not a LF, CR, SPACE or any visible ASCII character, i.e.
+                      // it's binary stuff. Resetting the state.
+                      state = 0;
+                      break;
+                    }
+                  }
+                  if (state === 2) {
+                    break;
+                  }
+                } else
+                  // Finished!
+                  {
+                    state = 0;
+                  }
+              }
+            }
+            return stream.pos - 4 - startPos;
+          },
+          /**
+           * Find the EOI (end-of-image) marker 0xFFD9 of the stream.
+           * @returns {number} The inline stream length.
+           */
+          findDCTDecodeInlineStreamEnd: function Parser_findDCTDecodeInlineStreamEnd(stream) {
+            var startPos = stream.pos, foundEOI = false, b, markerLength, length;
+            while ((b = stream.getByte()) !== -1) {
+              if (b !== 0xFF) {
+                // Not a valid marker.
+                continue;
+              }
+              switch (stream.getByte()) {
+              case 0x00:
+                // Byte stuffing.
+                // 0xFF00 appears to be a very common byte sequence in JPEG images.
+                break;
+              case 0xFF:
+                // Fill byte.
+                // Avoid skipping a valid marker, resetting the stream position.
+                stream.skip(-1);
+                break;
+              case 0xD9:
+                // EOI
+                foundEOI = true;
+                break;
+              case 0xC0:
+              // SOF0
+              case 0xC1:
+              // SOF1
+              case 0xC2:
+              // SOF2
+              case 0xC3:
+              // SOF3
+              case 0xC5:
+              // SOF5
+              case 0xC6:
+              // SOF6
+              case 0xC7:
+              // SOF7
+              case 0xC9:
+              // SOF9
+              case 0xCA:
+              // SOF10
+              case 0xCB:
+              // SOF11
+              case 0xCD:
+              // SOF13
+              case 0xCE:
+              // SOF14
+              case 0xCF:
+              // SOF15
+              case 0xC4:
+              // DHT
+              case 0xCC:
+              // DAC
+              case 0xDA:
+              // SOS
+              case 0xDB:
+              // DQT
+              case 0xDC:
+              // DNL
+              case 0xDD:
+              // DRI
+              case 0xDE:
+              // DHP
+              case 0xDF:
+              // EXP
+              case 0xE0:
+              // APP0
+              case 0xE1:
+              // APP1
+              case 0xE2:
+              // APP2
+              case 0xE3:
+              // APP3
+              case 0xE4:
+              // APP4
+              case 0xE5:
+              // APP5
+              case 0xE6:
+              // APP6
+              case 0xE7:
+              // APP7
+              case 0xE8:
+              // APP8
+              case 0xE9:
+              // APP9
+              case 0xEA:
+              // APP10
+              case 0xEB:
+              // APP11
+              case 0xEC:
+              // APP12
+              case 0xED:
+              // APP13
+              case 0xEE:
+              // APP14
+              case 0xEF:
+              // APP15
+              case 0xFE:
+                // COM
+                // The marker should be followed by the length of the segment.
+                markerLength = stream.getUint16();
+                if (markerLength > 2) {
+                  // |markerLength| contains the byte length of the marker segment,
+                  // including its own length (2 bytes) and excluding the marker.
+                  stream.skip(markerLength - 2);
+                } else
+                  // Jump to the next marker.
+                  {
+                    // The marker length is invalid, resetting the stream position.
+                    stream.skip(-2);
+                  }
+                break;
+              }
+              if (foundEOI) {
+                break;
+              }
+            }
+            length = stream.pos - startPos;
+            if (b === -1) {
+              warn('Inline DCTDecode image stream: ' + 'EOI marker not found, searching for /EI/ instead.');
+              stream.skip(-length);
+              // Reset the stream position.
+              return this.findDefaultInlineStreamEnd(stream);
+            }
+            this.inlineStreamSkipEI(stream);
+            return length;
+          },
+          /**
+           * Find the EOD (end-of-data) marker '~>' (i.e. TILDE + GT) of the stream.
+           * @returns {number} The inline stream length.
+           */
+          findASCII85DecodeInlineStreamEnd: function Parser_findASCII85DecodeInlineStreamEnd(stream) {
+            var TILDE = 0x7E, GT = 0x3E;
+            var startPos = stream.pos, ch, length;
+            while ((ch = stream.getByte()) !== -1) {
+              if (ch === TILDE && stream.peekByte() === GT) {
+                stream.skip();
+                break;
+              }
+            }
+            length = stream.pos - startPos;
+            if (ch === -1) {
+              warn('Inline ASCII85Decode image stream: ' + 'EOD marker not found, searching for /EI/ instead.');
+              stream.skip(-length);
+              // Reset the stream position.
+              return this.findDefaultInlineStreamEnd(stream);
+            }
+            this.inlineStreamSkipEI(stream);
+            return length;
+          },
+          /**
+           * Find the EOD (end-of-data) marker '>' (i.e. GT) of the stream.
+           * @returns {number} The inline stream length.
+           */
+          findASCIIHexDecodeInlineStreamEnd: function Parser_findASCIIHexDecodeInlineStreamEnd(stream) {
+            var GT = 0x3E;
+            var startPos = stream.pos, ch, length;
+            while ((ch = stream.getByte()) !== -1) {
+              if (ch === GT) {
+                break;
+              }
+            }
+            length = stream.pos - startPos;
+            if (ch === -1) {
+              warn('Inline ASCIIHexDecode image stream: ' + 'EOD marker not found, searching for /EI/ instead.');
+              stream.skip(-length);
+              // Reset the stream position.
+              return this.findDefaultInlineStreamEnd(stream);
+            }
+            this.inlineStreamSkipEI(stream);
+            return length;
+          },
+          /**
+           * Skip over the /EI/ for streams where we search for an EOD marker.
+           */
+          inlineStreamSkipEI: function Parser_inlineStreamSkipEI(stream) {
+            var E = 0x45, I = 0x49;
+            var state = 0, ch;
+            while ((ch = stream.getByte()) !== -1) {
+              if (state === 0) {
+                state = ch === E ? 1 : 0;
+              } else if (state === 1) {
+                state = ch === I ? 2 : 0;
+              } else if (state === 2) {
+                break;
+              }
+            }
+          },
+          makeInlineImage: function Parser_makeInlineImage(cipherTransform) {
+            var lexer = this.lexer;
+            var stream = lexer.stream;
+            // Parse dictionary.
+            var dict = new Dict(this.xref);
+            while (!isCmd(this.buf1, 'ID') && !isEOF(this.buf1)) {
+              if (!isName(this.buf1)) {
+                error('Dictionary key must be a name object');
+              }
+              var key = this.buf1.name;
+              this.shift();
+              if (isEOF(this.buf1)) {
+                break;
+              }
+              dict.set(key, this.getObj(cipherTransform));
+            }
+            // Extract the name of the first (i.e. the current) image filter.
+            var filter = dict.get('Filter', 'F'), filterName;
+            if (isName(filter)) {
+              filterName = filter.name;
+            } else if (isArray(filter) && isName(filter[0])) {
+              filterName = filter[0].name;
+            }
+            // Parse image stream.
+            var startPos = stream.pos, length, i, ii;
+            if (filterName === 'DCTDecode' || filterName === 'DCT') {
+              length = this.findDCTDecodeInlineStreamEnd(stream);
+            } else if (filterName === 'ASCII85Decide' || filterName === 'A85') {
+              length = this.findASCII85DecodeInlineStreamEnd(stream);
+            } else if (filterName === 'ASCIIHexDecode' || filterName === 'AHx') {
+              length = this.findASCIIHexDecodeInlineStreamEnd(stream);
+            } else {
+              length = this.findDefaultInlineStreamEnd(stream);
+            }
+            var imageStream = stream.makeSubStream(startPos, length, dict);
+            // Cache all images below the MAX_LENGTH_TO_CACHE threshold by their
+            // adler32 checksum.
+            var adler32;
+            if (length < MAX_LENGTH_TO_CACHE) {
+              var imageBytes = imageStream.getBytes();
+              imageStream.reset();
+              var a = 1;
+              var b = 0;
+              for (i = 0, ii = imageBytes.length; i < ii; ++i) {
+                // No modulo required in the loop if imageBytes.length < 5552.
+                a += imageBytes[i] & 0xff;
+                b += a;
+              }
+              adler32 = b % 65521 << 16 | a % 65521;
+              if (this.imageCache.adler32 === adler32) {
+                this.buf2 = Cmd.get('EI');
+                this.shift();
+                this.imageCache[adler32].reset();
+                return this.imageCache[adler32];
+              }
+            }
+            if (cipherTransform) {
+              imageStream = cipherTransform.createStream(imageStream, length);
+            }
+            imageStream = this.filter(imageStream, dict, length);
+            imageStream.dict = dict;
+            if (adler32 !== undefined) {
+              imageStream.cacheKey = 'inline_' + length + '_' + adler32;
+              this.imageCache[adler32] = imageStream;
+            }
+            this.buf2 = Cmd.get('EI');
+            this.shift();
+            return imageStream;
+          },
+          makeStream: function Parser_makeStream(dict, cipherTransform) {
+            var lexer = this.lexer;
+            var stream = lexer.stream;
+            // get stream start position
+            lexer.skipToNextLine();
+            var pos = stream.pos - 1;
+            // get length
+            var length = dict.get('Length');
+            if (!isInt(length)) {
+              info('Bad ' + length + ' attribute in stream');
+              length = 0;
+            }
+            // skip over the stream data
+            stream.pos = pos + length;
+            lexer.nextChar();
+            // Shift '>>' and check whether the new object marks the end of the stream
+            if (this.tryShift() && isCmd(this.buf2, 'endstream')) {
+              this.shift();
+            } else
+              // 'stream'
+              {
+                // bad stream length, scanning for endstream
+                stream.pos = pos;
+                var SCAN_BLOCK_SIZE = 2048;
+                var ENDSTREAM_SIGNATURE_LENGTH = 9;
+                var ENDSTREAM_SIGNATURE = [
+                  0x65,
+                  0x6E,
+                  0x64,
+                  0x73,
+                  0x74,
+                  0x72,
+                  0x65,
+                  0x61,
+                  0x6D
+                ];
+                var skipped = 0, found = false, i, j;
+                while (stream.pos < stream.end) {
+                  var scanBytes = stream.peekBytes(SCAN_BLOCK_SIZE);
+                  var scanLength = scanBytes.length - ENDSTREAM_SIGNATURE_LENGTH;
+                  if (scanLength <= 0) {
+                    break;
+                  }
+                  found = false;
+                  i = 0;
+                  while (i < scanLength) {
+                    j = 0;
+                    while (j < ENDSTREAM_SIGNATURE_LENGTH && scanBytes[i + j] === ENDSTREAM_SIGNATURE[j]) {
+                      j++;
+                    }
+                    if (j >= ENDSTREAM_SIGNATURE_LENGTH) {
+                      found = true;
+                      break;
+                    }
+                    i++;
+                  }
+                  if (found) {
+                    skipped += i;
+                    stream.pos += i;
+                    break;
+                  }
+                  skipped += scanLength;
+                  stream.pos += scanLength;
+                }
+                if (!found) {
+                  error('Missing endstream');
+                }
+                length = skipped;
+                lexer.nextChar();
+                this.shift();
+                this.shift();
+              }
+            this.shift();
+            // 'endstream'
+            stream = stream.makeSubStream(pos, length, dict);
+            if (cipherTransform) {
+              stream = cipherTransform.createStream(stream, length);
+            }
+            stream = this.filter(stream, dict, length);
+            stream.dict = dict;
+            return stream;
+          },
+          filter: function Parser_filter(stream, dict, length) {
+            var filter = dict.get('Filter', 'F');
+            var params = dict.get('DecodeParms', 'DP');
+            if (isName(filter)) {
+              if (isArray(params)) {
+                params = params[0];
+              }
+              return this.makeFilter(stream, filter.name, length, params);
+            }
+            var maybeLength = length;
+            if (isArray(filter)) {
+              var filterArray = filter;
+              var paramsArray = params;
+              for (var i = 0, ii = filterArray.length; i < ii; ++i) {
+                filter = filterArray[i];
+                if (!isName(filter)) {
+                  error('Bad filter name: ' + filter);
+                }
+                params = null;
+                if (isArray(paramsArray) && i in paramsArray) {
+                  params = paramsArray[i];
+                }
+                stream = this.makeFilter(stream, filter.name, maybeLength, params);
+                // after the first stream the length variable is invalid
+                maybeLength = null;
+              }
+            }
+            return stream;
+          },
+          makeFilter: function Parser_makeFilter(stream, name, maybeLength, params) {
+            // Since the 'Length' entry in the stream dictionary can be completely
+            // wrong, e.g. zero for non-empty streams, only skip parsing the stream
+            // when we can be absolutely certain that it actually is empty.
+            if (maybeLength === 0) {
+              warn('Empty "' + name + '" stream.');
+              return new NullStream(stream);
+            }
+            try {
+              if (params && this.xref) {
+                params = this.xref.fetchIfRef(params);
+              }
+              var xrefStreamStats = this.xref.stats.streamTypes;
+              if (name === 'FlateDecode' || name === 'Fl') {
+                xrefStreamStats[StreamType.FLATE] = true;
+                if (params) {
+                  return new PredictorStream(new FlateStream(stream, maybeLength), maybeLength, params);
+                }
+                return new FlateStream(stream, maybeLength);
+              }
+              if (name === 'LZWDecode' || name === 'LZW') {
+                xrefStreamStats[StreamType.LZW] = true;
+                var earlyChange = 1;
+                if (params) {
+                  if (params.has('EarlyChange')) {
+                    earlyChange = params.get('EarlyChange');
+                  }
+                  return new PredictorStream(new LZWStream(stream, maybeLength, earlyChange), maybeLength, params);
+                }
+                return new LZWStream(stream, maybeLength, earlyChange);
+              }
+              if (name === 'DCTDecode' || name === 'DCT') {
+                xrefStreamStats[StreamType.DCT] = true;
+                return new JpegStream(stream, maybeLength, stream.dict, params);
+              }
+              if (name === 'JPXDecode' || name === 'JPX') {
+                xrefStreamStats[StreamType.JPX] = true;
+                return new JpxStream(stream, maybeLength, stream.dict, params);
+              }
+              if (name === 'ASCII85Decode' || name === 'A85') {
+                xrefStreamStats[StreamType.A85] = true;
+                return new Ascii85Stream(stream, maybeLength);
+              }
+              if (name === 'ASCIIHexDecode' || name === 'AHx') {
+                xrefStreamStats[StreamType.AHX] = true;
+                return new AsciiHexStream(stream, maybeLength);
+              }
+              if (name === 'CCITTFaxDecode' || name === 'CCF') {
+                xrefStreamStats[StreamType.CCF] = true;
+                return new CCITTFaxStream(stream, maybeLength, params);
+              }
+              if (name === 'RunLengthDecode' || name === 'RL') {
+                xrefStreamStats[StreamType.RL] = true;
+                return new RunLengthStream(stream, maybeLength);
+              }
+              if (name === 'JBIG2Decode') {
+                xrefStreamStats[StreamType.JBIG] = true;
+                return new Jbig2Stream(stream, maybeLength, stream.dict, params);
+              }
+              warn('filter "' + name + '" not supported yet');
+              return stream;
+            } catch (ex) {
+              if (ex instanceof MissingDataException) {
+                throw ex;
+              }
+              warn('Invalid stream: \"' + ex + '\"');
+              return new NullStream(stream);
+            }
+          }
+        };
+        return Parser;
+      }();
+      var Lexer = function LexerClosure() {
+        function Lexer(stream, knownCommands) {
+          this.stream = stream;
+          this.nextChar();
+          // While lexing, we build up many strings one char at a time. Using += for
+          // this can result in lots of garbage strings. It's better to build an
+          // array of single-char strings and then join() them together at the end.
+          // And reusing a single array (i.e. |this.strBuf|) over and over for this
+          // purpose uses less memory than using a new array for each string.
+          this.strBuf = [];
+          // The PDFs might have "glued" commands with other commands, operands or
+          // literals, e.g. "q1". The knownCommands is a dictionary of the valid
+          // commands and their prefixes. The prefixes are built the following way:
+          // if there a command that is a prefix of the other valid command or
+          // literal (e.g. 'f' and 'false') the following prefixes must be included,
+          // 'fa', 'fal', 'fals'. The prefixes are not needed, if the command has no
+          // other commands or literals as a prefix. The knowCommands is optional.
+          this.knownCommands = knownCommands;
+        }
+        // A '1' in this array means the character is white space. A '1' or
+        // '2' means the character ends a name or command.
+        var specialChars = [
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          1,
+          0,
+          1,
+          1,
+          0,
+          0,
+          // 0x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // 1x
+          1,
+          0,
+          0,
+          0,
+          0,
+          2,
+          0,
+          0,
+          2,
+          2,
+          0,
+          0,
+          0,
+          0,
+          0,
+          2,
+          // 2x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          2,
+          0,
+          2,
+          0,
+          // 3x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // 4x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          2,
+          0,
+          2,
+          0,
+          0,
+          // 5x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // 6x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          2,
+          0,
+          2,
+          0,
+          0,
+          // 7x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // 8x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // 9x
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // ax
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // bx
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // cx
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // dx
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          // ex
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ];
+        // fx
+        function toHexDigit(ch) {
+          if (ch >= 0x30 && ch <= 0x39) {
+            // '0'-'9'
+            return ch & 0x0F;
+          }
+          if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
+            // 'A'-'F', 'a'-'f'
+            return (ch & 0x0F) + 9;
+          }
+          return -1;
+        }
+        Lexer.prototype = {
+          nextChar: function Lexer_nextChar() {
+            return this.currentChar = this.stream.getByte();
+          },
+          peekChar: function Lexer_peekChar() {
+            return this.stream.peekByte();
+          },
+          getNumber: function Lexer_getNumber() {
+            var ch = this.currentChar;
+            var eNotation = false;
+            var divideBy = 0;
+            // different from 0 if it's a floating point value
+            var sign = 1;
+            if (ch === 0x2D) {
+              // '-'
+              sign = -1;
+              ch = this.nextChar();
+              if (ch === 0x2D) {
+                // '-'
+                // Ignore double negative (this is consistent with Adobe Reader).
+                ch = this.nextChar();
+              }
+            } else if (ch === 0x2B) {
+              // '+'
+              ch = this.nextChar();
+            }
+            if (ch === 0x2E) {
+              // '.'
+              divideBy = 10;
+              ch = this.nextChar();
+            }
+            if (ch < 0x30 || ch > 0x39) {
+              // '0' - '9'
+              error('Invalid number: ' + String.fromCharCode(ch));
+              return 0;
+            }
+            var baseValue = ch - 0x30;
+            // '0'
+            var powerValue = 0;
+            var powerValueSign = 1;
+            while ((ch = this.nextChar()) >= 0) {
+              if (0x30 <= ch && ch <= 0x39) {
+                // '0' - '9'
+                var currentDigit = ch - 0x30;
+                // '0'
+                if (eNotation) {
+                  // We are after an 'e' or 'E'
+                  powerValue = powerValue * 10 + currentDigit;
+                } else {
+                  if (divideBy !== 0) {
+                    // We are after a point
+                    divideBy *= 10;
+                  }
+                  baseValue = baseValue * 10 + currentDigit;
+                }
+              } else if (ch === 0x2E) {
+                // '.'
+                if (divideBy === 0) {
+                  divideBy = 1;
+                } else {
+                  // A number can have only one '.'
+                  break;
+                }
+              } else if (ch === 0x2D) {
+                // '-'
+                // ignore minus signs in the middle of numbers to match
+                // Adobe's behavior
+                warn('Badly formatted number');
+              } else if (ch === 0x45 || ch === 0x65) {
+                // 'E', 'e'
+                // 'E' can be either a scientific notation or the beginning of a new
+                // operator
+                ch = this.peekChar();
+                if (ch === 0x2B || ch === 0x2D) {
+                  // '+', '-'
+                  powerValueSign = ch === 0x2D ? -1 : 1;
+                  this.nextChar();
+                } else // Consume the sign character
+                if (ch < 0x30 || ch > 0x39) {
+                  // '0' - '9'
+                  // The 'E' must be the beginning of a new operator
+                  break;
+                }
+                eNotation = true;
+              } else {
+                // the last character doesn't belong to us
+                break;
+              }
+            }
+            if (divideBy !== 0) {
+              baseValue /= divideBy;
+            }
+            if (eNotation) {
+              baseValue *= Math.pow(10, powerValueSign * powerValue);
+            }
+            return sign * baseValue;
+          },
+          getString: function Lexer_getString() {
+            var numParen = 1;
+            var done = false;
+            var strBuf = this.strBuf;
+            strBuf.length = 0;
+            var ch = this.nextChar();
+            while (true) {
+              var charBuffered = false;
+              switch (ch | 0) {
+              case -1:
+                warn('Unterminated string');
+                done = true;
+                break;
+              case 0x28:
+                // '('
+                ++numParen;
+                strBuf.push('(');
+                break;
+              case 0x29:
+                // ')'
+                if (--numParen === 0) {
+                  this.nextChar();
+                  // consume strings ')'
+                  done = true;
+                } else {
+                  strBuf.push(')');
+                }
+                break;
+              case 0x5C:
+                // '\\'
+                ch = this.nextChar();
+                switch (ch) {
+                case -1:
+                  warn('Unterminated string');
+                  done = true;
+                  break;
+                case 0x6E:
+                  // 'n'
+                  strBuf.push('\n');
+                  break;
+                case 0x72:
+                  // 'r'
+                  strBuf.push('\r');
+                  break;
+                case 0x74:
+                  // 't'
+                  strBuf.push('\t');
+                  break;
+                case 0x62:
+                  // 'b'
+                  strBuf.push('\b');
+                  break;
+                case 0x66:
+                  // 'f'
+                  strBuf.push('\f');
+                  break;
+                case 0x5C:
+                // '\'
+                case 0x28:
+                // '('
+                case 0x29:
+                  // ')'
+                  strBuf.push(String.fromCharCode(ch));
+                  break;
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                // '0'-'3'
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                  // '4'-'7'
+                  var x = ch & 0x0F;
+                  ch = this.nextChar();
+                  charBuffered = true;
+                  if (ch >= 0x30 && ch <= 0x37) {
+                    // '0'-'7'
+                    x = (x << 3) + (ch & 0x0F);
+                    ch = this.nextChar();
+                    if (ch >= 0x30 && ch <= 0x37) {
+                      // '0'-'7'
+                      charBuffered = false;
+                      x = (x << 3) + (ch & 0x0F);
+                    }
+                  }
+                  strBuf.push(String.fromCharCode(x));
+                  break;
+                case 0x0D:
+                  // CR
+                  if (this.peekChar() === 0x0A) {
+                    // LF
+                    this.nextChar();
+                  }
+                  break;
+                case 0x0A:
+                  // LF
+                  break;
+                default:
+                  strBuf.push(String.fromCharCode(ch));
+                  break;
+                }
+                break;
+              default:
+                strBuf.push(String.fromCharCode(ch));
+                break;
+              }
+              if (done) {
+                break;
+              }
+              if (!charBuffered) {
+                ch = this.nextChar();
+              }
+            }
+            return strBuf.join('');
+          },
+          getName: function Lexer_getName() {
+            var ch, previousCh;
+            var strBuf = this.strBuf;
+            strBuf.length = 0;
+            while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
+              if (ch === 0x23) {
+                // '#'
+                ch = this.nextChar();
+                if (specialChars[ch]) {
+                  warn('Lexer_getName: ' + 'NUMBER SIGN (#) should be followed by a hexadecimal number.');
+                  strBuf.push('#');
+                  break;
+                }
+                var x = toHexDigit(ch);
+                if (x !== -1) {
+                  previousCh = ch;
+                  ch = this.nextChar();
+                  var x2 = toHexDigit(ch);
+                  if (x2 === -1) {
+                    warn('Lexer_getName: Illegal digit (' + String.fromCharCode(ch) + ') in hexadecimal number.');
+                    strBuf.push('#', String.fromCharCode(previousCh));
+                    if (specialChars[ch]) {
+                      break;
+                    }
+                    strBuf.push(String.fromCharCode(ch));
+                    continue;
+                  }
+                  strBuf.push(String.fromCharCode(x << 4 | x2));
+                } else {
+                  strBuf.push('#', String.fromCharCode(ch));
+                }
+              } else {
+                strBuf.push(String.fromCharCode(ch));
+              }
+            }
+            if (strBuf.length > 127) {
+              warn('name token is longer than allowed by the spec: ' + strBuf.length);
+            }
+            return Name.get(strBuf.join(''));
+          },
+          getHexString: function Lexer_getHexString() {
+            var strBuf = this.strBuf;
+            strBuf.length = 0;
+            var ch = this.currentChar;
+            var isFirstHex = true;
+            var firstDigit;
+            var secondDigit;
+            while (true) {
+              if (ch < 0) {
+                warn('Unterminated hex string');
+                break;
+              } else if (ch === 0x3E) {
+                // '>'
+                this.nextChar();
+                break;
+              } else if (specialChars[ch] === 1) {
+                ch = this.nextChar();
+                continue;
+              } else {
+                if (isFirstHex) {
+                  firstDigit = toHexDigit(ch);
+                  if (firstDigit === -1) {
+                    warn('Ignoring invalid character "' + ch + '" in hex string');
+                    ch = this.nextChar();
+                    continue;
+                  }
+                } else {
+                  secondDigit = toHexDigit(ch);
+                  if (secondDigit === -1) {
+                    warn('Ignoring invalid character "' + ch + '" in hex string');
+                    ch = this.nextChar();
+                    continue;
+                  }
+                  strBuf.push(String.fromCharCode(firstDigit << 4 | secondDigit));
+                }
+                isFirstHex = !isFirstHex;
+                ch = this.nextChar();
+              }
+            }
+            return strBuf.join('');
+          },
+          getObj: function Lexer_getObj() {
+            // skip whitespace and comments
+            var comment = false;
+            var ch = this.currentChar;
+            while (true) {
+              if (ch < 0) {
+                return EOF;
+              }
+              if (comment) {
+                if (ch === 0x0A || ch === 0x0D) {
+                  // LF, CR
+                  comment = false;
+                }
+              } else if (ch === 0x25) {
+                // '%'
+                comment = true;
+              } else if (specialChars[ch] !== 1) {
+                break;
+              }
+              ch = this.nextChar();
+            }
+            // start reading token
+            switch (ch | 0) {
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            // '0'-'4'
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            // '5'-'9'
+            case 0x2B:
+            case 0x2D:
+            case 0x2E:
+              // '+', '-', '.'
+              return this.getNumber();
+            case 0x28:
+              // '('
+              return this.getString();
+            case 0x2F:
+              // '/'
+              return this.getName();
+            // array punctuation
+            case 0x5B:
+              // '['
+              this.nextChar();
+              return Cmd.get('[');
+            case 0x5D:
+              // ']'
+              this.nextChar();
+              return Cmd.get(']');
+            // hex string or dict punctuation
+            case 0x3C:
+              // '<'
+              ch = this.nextChar();
+              if (ch === 0x3C) {
+                // dict punctuation
+                this.nextChar();
+                return Cmd.get('<<');
+              }
+              return this.getHexString();
+            // dict punctuation
+            case 0x3E:
+              // '>'
+              ch = this.nextChar();
+              if (ch === 0x3E) {
+                this.nextChar();
+                return Cmd.get('>>');
+              }
+              return Cmd.get('>');
+            case 0x7B:
+              // '{'
+              this.nextChar();
+              return Cmd.get('{');
+            case 0x7D:
+              // '}'
+              this.nextChar();
+              return Cmd.get('}');
+            case 0x29:
+              // ')'
+              error('Illegal character: ' + ch);
+              break;
+            }
+            // command
+            var str = String.fromCharCode(ch);
+            var knownCommands = this.knownCommands;
+            var knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+            while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
+              // stop if known command is found and next character does not make
+              // the str a command
+              var possibleCommand = str + String.fromCharCode(ch);
+              if (knownCommandFound && knownCommands[possibleCommand] === undefined) {
+                break;
+              }
+              if (str.length === 128) {
+                error('Command token too long: ' + str.length);
+              }
+              str = possibleCommand;
+              knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+            }
+            if (str === 'true') {
+              return true;
+            }
+            if (str === 'false') {
+              return false;
+            }
+            if (str === 'null') {
+              return null;
+            }
+            return Cmd.get(str);
+          },
+          skipToNextLine: function Lexer_skipToNextLine() {
+            var ch = this.currentChar;
+            while (ch >= 0) {
+              if (ch === 0x0D) {
+                // CR
+                ch = this.nextChar();
+                if (ch === 0x0A) {
+                  // LF
+                  this.nextChar();
+                }
+                break;
+              } else if (ch === 0x0A) {
+                // LF
+                this.nextChar();
+                break;
+              }
+              ch = this.nextChar();
+            }
+          }
+        };
+        return Lexer;
+      }();
+      var Linearization = {
+        create: function LinearizationCreate(stream) {
+          function getInt(name, allowZeroValue) {
+            var obj = linDict.get(name);
+            if (isInt(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) {
+              return obj;
+            }
+            throw new Error('The "' + name + '" parameter in the linearization ' + 'dictionary is invalid.');
+          }
+          function getHints() {
+            var hints = linDict.get('H'), hintsLength, item;
+            if (isArray(hints) && ((hintsLength = hints.length) === 2 || hintsLength === 4)) {
+              for (var index = 0; index < hintsLength; index++) {
+                if (!(isInt(item = hints[index]) && item > 0)) {
+                  throw new Error('Hint (' + index + ') in the linearization dictionary is invalid.');
+                }
+              }
+              return hints;
+            }
+            throw new Error('Hint array in the linearization dictionary is invalid.');
+          }
+          var parser = new Parser(new Lexer(stream), false, null);
+          var obj1 = parser.getObj();
+          var obj2 = parser.getObj();
+          var obj3 = parser.getObj();
+          var linDict = parser.getObj();
+          var obj, length;
+          if (!(isInt(obj1) && isInt(obj2) && isCmd(obj3, 'obj') && isDict(linDict) && isNum(obj = linDict.get('Linearized')) && obj > 0)) {
+            return null;
+          } else // No valid linearization dictionary found.
+          if ((length = getInt('L')) !== stream.length) {
+            throw new Error('The "L" parameter in the linearization dictionary ' + 'does not equal the stream length.');
+          }
+          return {
+            length: length,
+            hints: getHints(),
+            objectNumberFirst: getInt('O'),
+            endFirst: getInt('E'),
+            numPages: getInt('N'),
+            mainXRefEntriesOffset: getInt('T'),
+            pageFirst: linDict.has('P') ? getInt('P', true) : 0
+          };
+        }
+      };
+      exports.EOF = EOF;
+      exports.Lexer = Lexer;
+      exports.Linearization = Linearization;
+      exports.Parser = Parser;
+      exports.isEOF = isEOF;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreType1Parser = {}, root.pdfjsSharedUtil, root.pdfjsCoreStream, root.pdfjsCoreEncodings);
+    }(this, function (exports, sharedUtil, coreStream, coreEncodings) {
+      var warn = sharedUtil.warn;
+      var isSpace = sharedUtil.isSpace;
+      var Stream = coreStream.Stream;
+      var getEncoding = coreEncodings.getEncoding;
+      // Hinting is currently disabled due to unknown problems on windows
+      // in tracemonkey and various other pdfs with type1 fonts.
+      var HINTING_ENABLED = false;
+      /*
+       * CharStrings are encoded following the the CharString Encoding sequence
+       * describe in Chapter 6 of the "Adobe Type1 Font Format" specification.
+       * The value in a byte indicates a command, a number, or subsequent bytes
+       * that are to be interpreted in a special way.
+       *
+       * CharString Number Encoding:
+       *  A CharString byte containing the values from 32 through 255 inclusive
+       *  indicate an integer. These values are decoded in four ranges.
+       *
+       * 1. A CharString byte containing a value, v, between 32 and 246 inclusive,
+       * indicate the integer v - 139. Thus, the integer values from -107 through
+       * 107 inclusive may be encoded in single byte.
+       *
+       * 2. A CharString byte containing a value, v, between 247 and 250 inclusive,
+       * indicates an integer involving the next byte, w, according to the formula:
+       * [(v - 247) x 256] + w + 108
+       *
+       * 3. A CharString byte containing a value, v, between 251 and 254 inclusive,
+       * indicates an integer involving the next byte, w, according to the formula:
+       * -[(v - 251) * 256] - w - 108
+       *
+       * 4. A CharString containing the value 255 indicates that the next 4 bytes
+       * are a two complement signed integer. The first of these bytes contains the
+       * highest order bits, the second byte contains the next higher order bits
+       * and the fourth byte contain the lowest order bits.
+       *
+       *
+       * CharString Command Encoding:
+       *  CharStrings commands are encoded in 1 or 2 bytes.
+       *
+       *  Single byte commands are encoded in 1 byte that contains a value between
+       *  0 and 31 inclusive.
+       *  If a command byte contains the value 12, then the value in the next byte
+       *  indicates a command. This "escape" mechanism allows many extra commands
+       * to be encoded and this encoding technique helps to minimize the length of
+       * the charStrings.
+       */
+      var Type1CharString = function Type1CharStringClosure() {
+        var COMMAND_MAP = {
+          'hstem': [1],
+          'vstem': [3],
+          'vmoveto': [4],
+          'rlineto': [5],
+          'hlineto': [6],
+          'vlineto': [7],
+          'rrcurveto': [8],
+          'callsubr': [10],
+          'flex': [
+            12,
+            35
+          ],
+          'drop': [
+            12,
+            18
+          ],
+          'endchar': [14],
+          'rmoveto': [21],
+          'hmoveto': [22],
+          'vhcurveto': [30],
+          'hvcurveto': [31]
+        };
+        function Type1CharString() {
+          this.width = 0;
+          this.lsb = 0;
+          this.flexing = false;
+          this.output = [];
+          this.stack = [];
+        }
+        Type1CharString.prototype = {
+          convert: function Type1CharString_convert(encoded, subrs, seacAnalysisEnabled) {
+            var count = encoded.length;
+            var error = false;
+            var wx, sbx, subrNumber;
+            for (var i = 0; i < count; i++) {
+              var value = encoded[i];
+              if (value < 32) {
+                if (value === 12) {
+                  value = (value << 8) + encoded[++i];
+                }
+                switch (value) {
+                case 1:
+                  // hstem
+                  if (!HINTING_ENABLED) {
+                    this.stack = [];
+                    break;
+                  }
+                  error = this.executeCommand(2, COMMAND_MAP.hstem);
+                  break;
+                case 3:
+                  // vstem
+                  if (!HINTING_ENABLED) {
+                    this.stack = [];
+                    break;
+                  }
+                  error = this.executeCommand(2, COMMAND_MAP.vstem);
+                  break;
+                case 4:
+                  // vmoveto
+                  if (this.flexing) {
+                    if (this.stack.length < 1) {
+                      error = true;
+                      break;
+                    }
+                    // Add the dx for flex and but also swap the values so they are
+                    // the right order.
+                    var dy = this.stack.pop();
+                    this.stack.push(0, dy);
+                    break;
+                  }
+                  error = this.executeCommand(1, COMMAND_MAP.vmoveto);
+                  break;
+                case 5:
+                  // rlineto
+                  error = this.executeCommand(2, COMMAND_MAP.rlineto);
+                  break;
+                case 6:
+                  // hlineto
+                  error = this.executeCommand(1, COMMAND_MAP.hlineto);
+                  break;
+                case 7:
+                  // vlineto
+                  error = this.executeCommand(1, COMMAND_MAP.vlineto);
+                  break;
+                case 8:
+                  // rrcurveto
+                  error = this.executeCommand(6, COMMAND_MAP.rrcurveto);
+                  break;
+                case 9:
+                  // closepath
+                  // closepath is a Type1 command that does not take argument and is
+                  // useless in Type2 and it can simply be ignored.
+                  this.stack = [];
+                  break;
+                case 10:
+                  // callsubr
+                  if (this.stack.length < 1) {
+                    error = true;
+                    break;
+                  }
+                  subrNumber = this.stack.pop();
+                  error = this.convert(subrs[subrNumber], subrs, seacAnalysisEnabled);
+                  break;
+                case 11:
+                  // return
+                  return error;
+                case 13:
+                  // hsbw
+                  if (this.stack.length < 2) {
+                    error = true;
+                    break;
+                  }
+                  // To convert to type2 we have to move the width value to the
+                  // first part of the charstring and then use hmoveto with lsb.
+                  wx = this.stack.pop();
+                  sbx = this.stack.pop();
+                  this.lsb = sbx;
+                  this.width = wx;
+                  this.stack.push(wx, sbx);
+                  error = this.executeCommand(2, COMMAND_MAP.hmoveto);
+                  break;
+                case 14:
+                  // endchar
+                  this.output.push(COMMAND_MAP.endchar[0]);
+                  break;
+                case 21:
+                  // rmoveto
+                  if (this.flexing) {
+                    break;
+                  }
+                  error = this.executeCommand(2, COMMAND_MAP.rmoveto);
+                  break;
+                case 22:
+                  // hmoveto
+                  if (this.flexing) {
+                    // Add the dy for flex.
+                    this.stack.push(0);
+                    break;
+                  }
+                  error = this.executeCommand(1, COMMAND_MAP.hmoveto);
+                  break;
+                case 30:
+                  // vhcurveto
+                  error = this.executeCommand(4, COMMAND_MAP.vhcurveto);
+                  break;
+                case 31:
+                  // hvcurveto
+                  error = this.executeCommand(4, COMMAND_MAP.hvcurveto);
+                  break;
+                case (12 << 8) + 0:
+                  // dotsection
+                  // dotsection is a Type1 command to specify some hinting feature
+                  // for dots that do not take a parameter and it can safely be
+                  // ignored for Type2.
+                  this.stack = [];
+                  break;
+                case (12 << 8) + 1:
+                  // vstem3
+                  if (!HINTING_ENABLED) {
+                    this.stack = [];
+                    break;
+                  }
+                  // [vh]stem3 are Type1 only and Type2 supports [vh]stem with
+                  // multiple parameters, so instead of returning [vh]stem3 take a
+                  // shortcut and return [vhstem] instead.
+                  error = this.executeCommand(2, COMMAND_MAP.vstem);
+                  break;
+                case (12 << 8) + 2:
+                  // hstem3
+                  if (!HINTING_ENABLED) {
+                    this.stack = [];
+                    break;
+                  }
+                  // See vstem3.
+                  error = this.executeCommand(2, COMMAND_MAP.hstem);
+                  break;
+                case (12 << 8) + 6:
+                  // seac
+                  // seac is like type 2's special endchar but it doesn't use the
+                  // first argument asb, so remove it.
+                  if (seacAnalysisEnabled) {
+                    this.seac = this.stack.splice(-4, 4);
+                    error = this.executeCommand(0, COMMAND_MAP.endchar);
+                  } else {
+                    error = this.executeCommand(4, COMMAND_MAP.endchar);
+                  }
+                  break;
+                case (12 << 8) + 7:
+                  // sbw
+                  if (this.stack.length < 4) {
+                    error = true;
+                    break;
+                  }
+                  // To convert to type2 we have to move the width value to the
+                  // first part of the charstring and then use rmoveto with
+                  // (dx, dy). The height argument will not be used for vmtx and
+                  // vhea tables reconstruction -- ignoring it.
+                  var wy = this.stack.pop();
+                  wx = this.stack.pop();
+                  var sby = this.stack.pop();
+                  sbx = this.stack.pop();
+                  this.lsb = sbx;
+                  this.width = wx;
+                  this.stack.push(wx, sbx, sby);
+                  error = this.executeCommand(3, COMMAND_MAP.rmoveto);
+                  break;
+                case (12 << 8) + 12:
+                  // div
+                  if (this.stack.length < 2) {
+                    error = true;
+                    break;
+                  }
+                  var num2 = this.stack.pop();
+                  var num1 = this.stack.pop();
+                  this.stack.push(num1 / num2);
+                  break;
+                case (12 << 8) + 16:
+                  // callothersubr
+                  if (this.stack.length < 2) {
+                    error = true;
+                    break;
+                  }
+                  subrNumber = this.stack.pop();
+                  var numArgs = this.stack.pop();
+                  if (subrNumber === 0 && numArgs === 3) {
+                    var flexArgs = this.stack.splice(this.stack.length - 17, 17);
+                    this.stack.push(flexArgs[2] + flexArgs[0], // bcp1x + rpx
+                    flexArgs[3] + flexArgs[1], // bcp1y + rpy
+                    flexArgs[4], // bcp2x
+                    flexArgs[5], // bcp2y
+                    flexArgs[6], // p2x
+                    flexArgs[7], // p2y
+                    flexArgs[8], // bcp3x
+                    flexArgs[9], // bcp3y
+                    flexArgs[10], // bcp4x
+                    flexArgs[11], // bcp4y
+                    flexArgs[12], // p3x
+                    flexArgs[13], // p3y
+                    flexArgs[14]);
+                    // flexDepth
+                    // 15 = finalx unused by flex
+                    // 16 = finaly unused by flex
+                    error = this.executeCommand(13, COMMAND_MAP.flex, true);
+                    this.flexing = false;
+                    this.stack.push(flexArgs[15], flexArgs[16]);
+                  } else if (subrNumber === 1 && numArgs === 0) {
+                    this.flexing = true;
+                  }
+                  break;
+                case (12 << 8) + 17:
+                  // pop
+                  // Ignore this since it is only used with othersubr.
+                  break;
+                case (12 << 8) + 33:
+                  // setcurrentpoint
+                  // Ignore for now.
+                  this.stack = [];
+                  break;
+                default:
+                  warn('Unknown type 1 charstring command of "' + value + '"');
+                  break;
+                }
+                if (error) {
+                  break;
+                }
+                continue;
+              } else if (value <= 246) {
+                value = value - 139;
+              } else if (value <= 250) {
+                value = (value - 247) * 256 + encoded[++i] + 108;
+              } else if (value <= 254) {
+                value = -((value - 251) * 256) - encoded[++i] - 108;
+              } else {
+                value = (encoded[++i] & 0xff) << 24 | (encoded[++i] & 0xff) << 16 | (encoded[++i] & 0xff) << 8 | (encoded[++i] & 0xff) << 0;
+              }
+              this.stack.push(value);
+            }
+            return error;
+          },
+          executeCommand: function (howManyArgs, command, keepStack) {
+            var stackLength = this.stack.length;
+            if (howManyArgs > stackLength) {
+              return true;
+            }
+            var start = stackLength - howManyArgs;
+            for (var i = start; i < stackLength; i++) {
+              var value = this.stack[i];
+              if (value === (value | 0)) {
+                // int
+                this.output.push(28, value >> 8 & 0xff, value & 0xff);
+              } else {
+                // fixed point
+                value = 65536 * value | 0;
+                this.output.push(255, value >> 24 & 0xFF, value >> 16 & 0xFF, value >> 8 & 0xFF, value & 0xFF);
+              }
+            }
+            this.output.push.apply(this.output, command);
+            if (keepStack) {
+              this.stack.splice(start, howManyArgs);
+            } else {
+              this.stack.length = 0;
+            }
+            return false;
+          }
+        };
+        return Type1CharString;
+      }();
+      /*
+       * Type1Parser encapsulate the needed code for parsing a Type1 font
+       * program. Some of its logic depends on the Type2 charstrings
+       * structure.
+       * Note: this doesn't really parse the font since that would require evaluation
+       * of PostScript, but it is possible in most cases to extract what we need
+       * without a full parse.
+       */
+      var Type1Parser = function Type1ParserClosure() {
+        /*
+         * Decrypt a Sequence of Ciphertext Bytes to Produce the Original Sequence
+         * of Plaintext Bytes. The function took a key as a parameter which can be
+         * for decrypting the eexec block of for decoding charStrings.
+         */
+        var EEXEC_ENCRYPT_KEY = 55665;
+        var CHAR_STRS_ENCRYPT_KEY = 4330;
+        function isHexDigit(code) {
+          return code >= 48 && code <= 57 || // '0'-'9'
+          code >= 65 && code <= 70 || // 'A'-'F'
+          code >= 97 && code <= 102;
+        }
+        // 'a'-'f'
+        function decrypt(data, key, discardNumber) {
+          if (discardNumber >= data.length) {
+            return new Uint8Array(0);
+          }
+          var r = key | 0, c1 = 52845, c2 = 22719, i, j;
+          for (i = 0; i < discardNumber; i++) {
+            r = (data[i] + r) * c1 + c2 & (1 << 16) - 1;
+          }
+          var count = data.length - discardNumber;
+          var decrypted = new Uint8Array(count);
+          for (i = discardNumber, j = 0; j < count; i++, j++) {
+            var value = data[i];
+            decrypted[j] = value ^ r >> 8;
+            r = (value + r) * c1 + c2 & (1 << 16) - 1;
+          }
+          return decrypted;
+        }
+        function decryptAscii(data, key, discardNumber) {
+          var r = key | 0, c1 = 52845, c2 = 22719;
+          var count = data.length, maybeLength = count >>> 1;
+          var decrypted = new Uint8Array(maybeLength);
+          var i, j;
+          for (i = 0, j = 0; i < count; i++) {
+            var digit1 = data[i];
+            if (!isHexDigit(digit1)) {
+              continue;
+            }
+            i++;
+            var digit2;
+            while (i < count && !isHexDigit(digit2 = data[i])) {
+              i++;
+            }
+            if (i < count) {
+              var value = parseInt(String.fromCharCode(digit1, digit2), 16);
+              decrypted[j++] = value ^ r >> 8;
+              r = (value + r) * c1 + c2 & (1 << 16) - 1;
+            }
+          }
+          return Array.prototype.slice.call(decrypted, discardNumber, j);
+        }
+        function isSpecial(c) {
+          return c === 0x2F || // '/'
+          c === 0x5B || c === 0x5D || // '[', ']'
+          c === 0x7B || c === 0x7D || // '{', '}'
+          c === 0x28 || c === 0x29;
+        }
+        // '(', ')'
+        function Type1Parser(stream, encrypted, seacAnalysisEnabled) {
+          if (encrypted) {
+            var data = stream.getBytes();
+            var isBinary = !(isHexDigit(data[0]) && isHexDigit(data[1]) && isHexDigit(data[2]) && isHexDigit(data[3]));
+            stream = new Stream(isBinary ? decrypt(data, EEXEC_ENCRYPT_KEY, 4) : decryptAscii(data, EEXEC_ENCRYPT_KEY, 4));
+          }
+          this.seacAnalysisEnabled = !!seacAnalysisEnabled;
+          this.stream = stream;
+          this.nextChar();
+        }
+        Type1Parser.prototype = {
+          readNumberArray: function Type1Parser_readNumberArray() {
+            this.getToken();
+            // read '[' or '{' (arrays can start with either)
+            var array = [];
+            while (true) {
+              var token = this.getToken();
+              if (token === null || token === ']' || token === '}') {
+                break;
+              }
+              array.push(parseFloat(token || 0));
+            }
+            return array;
+          },
+          readNumber: function Type1Parser_readNumber() {
+            var token = this.getToken();
+            return parseFloat(token || 0);
+          },
+          readInt: function Type1Parser_readInt() {
+            // Use '| 0' to prevent setting a double into length such as the double
+            // does not flow into the loop variable.
+            var token = this.getToken();
+            return parseInt(token || 0, 10) | 0;
+          },
+          readBoolean: function Type1Parser_readBoolean() {
+            var token = this.getToken();
+            // Use 1 and 0 since that's what type2 charstrings use.
+            return token === 'true' ? 1 : 0;
+          },
+          nextChar: function Type1_nextChar() {
+            return this.currentChar = this.stream.getByte();
+          },
+          getToken: function Type1Parser_getToken() {
+            // Eat whitespace and comments.
+            var comment = false;
+            var ch = this.currentChar;
+            while (true) {
+              if (ch === -1) {
+                return null;
+              }
+              if (comment) {
+                if (ch === 0x0A || ch === 0x0D) {
+                  comment = false;
+                }
+              } else if (ch === 0x25) {
+                // '%'
+                comment = true;
+              } else if (!isSpace(ch)) {
+                break;
+              }
+              ch = this.nextChar();
+            }
+            if (isSpecial(ch)) {
+              this.nextChar();
+              return String.fromCharCode(ch);
+            }
+            var token = '';
+            do {
+              token += String.fromCharCode(ch);
+              ch = this.nextChar();
+            } while (ch >= 0 && !isSpace(ch) && !isSpecial(ch));
+            return token;
+          },
+          /*
+           * Returns an object containing a Subrs array and a CharStrings
+           * array extracted from and eexec encrypted block of data
+           */
+          extractFontProgram: function Type1Parser_extractFontProgram() {
+            var stream = this.stream;
+            var subrs = [], charstrings = [];
+            var privateData = Object.create(null);
+            privateData['lenIV'] = 4;
+            var program = {
+              subrs: [],
+              charstrings: [],
+              properties: { 'privateData': privateData }
+            };
+            var token, length, data, lenIV, encoded;
+            while ((token = this.getToken()) !== null) {
+              if (token !== '/') {
+                continue;
+              }
+              token = this.getToken();
+              switch (token) {
+              case 'CharStrings':
+                // The number immediately following CharStrings must be greater or
+                // equal to the number of CharStrings.
+                this.getToken();
+                this.getToken();
+                // read in 'dict'
+                this.getToken();
+                // read in 'dup'
+                this.getToken();
+                // read in 'begin'
+                while (true) {
+                  token = this.getToken();
+                  if (token === null || token === 'end') {
+                    break;
+                  }
+                  if (token !== '/') {
+                    continue;
+                  }
+                  var glyph = this.getToken();
+                  length = this.readInt();
+                  this.getToken();
+                  // read in 'RD' or '-|'
+                  data = stream.makeSubStream(stream.pos, length);
+                  lenIV = program.properties.privateData['lenIV'];
+                  encoded = decrypt(data.getBytes(), CHAR_STRS_ENCRYPT_KEY, lenIV);
+                  // Skip past the required space and binary data.
+                  stream.skip(length);
+                  this.nextChar();
+                  token = this.getToken();
+                  // read in 'ND' or '|-'
+                  if (token === 'noaccess') {
+                    this.getToken();
+                  }
+                  // read in 'def'
+                  charstrings.push({
+                    glyph: glyph,
+                    encoded: encoded
+                  });
+                }
+                break;
+              case 'Subrs':
+                var num = this.readInt();
+                this.getToken();
+                // read in 'array'
+                while ((token = this.getToken()) === 'dup') {
+                  var index = this.readInt();
+                  length = this.readInt();
+                  this.getToken();
+                  // read in 'RD' or '-|'
+                  data = stream.makeSubStream(stream.pos, length);
+                  lenIV = program.properties.privateData['lenIV'];
+                  encoded = decrypt(data.getBytes(), CHAR_STRS_ENCRYPT_KEY, lenIV);
+                  // Skip past the required space and binary data.
+                  stream.skip(length);
+                  this.nextChar();
+                  token = this.getToken();
+                  // read in 'NP' or '|'
+                  if (token === 'noaccess') {
+                    this.getToken();
+                  }
+                  // read in 'put'
+                  subrs[index] = encoded;
+                }
+                break;
+              case 'BlueValues':
+              case 'OtherBlues':
+              case 'FamilyBlues':
+              case 'FamilyOtherBlues':
+                var blueArray = this.readNumberArray();
+                // *Blue* values may contain invalid data: disables reading of
+                // those values when hinting is disabled.
+                if (blueArray.length > 0 && blueArray.length % 2 === 0 && HINTING_ENABLED) {
+                  program.properties.privateData[token] = blueArray;
+                }
+                break;
+              case 'StemSnapH':
+              case 'StemSnapV':
+                program.properties.privateData[token] = this.readNumberArray();
+                break;
+              case 'StdHW':
+              case 'StdVW':
+                program.properties.privateData[token] = this.readNumberArray()[0];
+                break;
+              case 'BlueShift':
+              case 'lenIV':
+              case 'BlueFuzz':
+              case 'BlueScale':
+              case 'LanguageGroup':
+              case 'ExpansionFactor':
+                program.properties.privateData[token] = this.readNumber();
+                break;
+              case 'ForceBold':
+                program.properties.privateData[token] = this.readBoolean();
+                break;
+              }
+            }
+            for (var i = 0; i < charstrings.length; i++) {
+              glyph = charstrings[i].glyph;
+              encoded = charstrings[i].encoded;
+              var charString = new Type1CharString();
+              var error = charString.convert(encoded, subrs, this.seacAnalysisEnabled);
+              var output = charString.output;
+              if (error) {
+                // It seems when FreeType encounters an error while evaluating a glyph
+                // that it completely ignores the glyph so we'll mimic that behaviour
+                // here and put an endchar to make the validator happy.
+                output = [14];
+              }
+              program.charstrings.push({
+                glyphName: glyph,
+                charstring: output,
+                width: charString.width,
+                lsb: charString.lsb,
+                seac: charString.seac
+              });
+            }
+            return program;
+          },
+          extractFontHeader: function Type1Parser_extractFontHeader(properties) {
+            var token;
+            while ((token = this.getToken()) !== null) {
+              if (token !== '/') {
+                continue;
+              }
+              token = this.getToken();
+              switch (token) {
+              case 'FontMatrix':
+                var matrix = this.readNumberArray();
+                properties.fontMatrix = matrix;
+                break;
+              case 'Encoding':
+                var encodingArg = this.getToken();
+                var encoding;
+                if (!/^\d+$/.test(encodingArg)) {
+                  // encoding name is specified
+                  encoding = getEncoding(encodingArg);
+                } else {
+                  encoding = [];
+                  var size = parseInt(encodingArg, 10) | 0;
+                  this.getToken();
+                  // read in 'array'
+                  for (var j = 0; j < size; j++) {
+                    token = this.getToken();
+                    // skipping till first dup or def (e.g. ignoring for statement)
+                    while (token !== 'dup' && token !== 'def') {
+                      token = this.getToken();
+                      if (token === null) {
+                        return;
+                      }
+                    }
+                    // invalid header
+                    if (token === 'def') {
+                      break;
+                    }
+                    // read all array data
+                    var index = this.readInt();
+                    this.getToken();
+                    // read in '/'
+                    var glyph = this.getToken();
+                    encoding[index] = glyph;
+                    this.getToken();
+                  }
+                }
+                // read the in 'put'
+                properties.builtInEncoding = encoding;
+                break;
+              case 'FontBBox':
+                var fontBBox = this.readNumberArray();
+                // adjusting ascent/descent
+                properties.ascent = fontBBox[3];
+                properties.descent = fontBBox[1];
+                properties.ascentScaled = true;
+                break;
+              }
+            }
+          }
+        };
+        return Type1Parser;
+      }();
+      exports.Type1Parser = Type1Parser;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreCMap = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreParser);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream, coreParser) {
+      var Util = sharedUtil.Util;
+      var assert = sharedUtil.assert;
+      var warn = sharedUtil.warn;
+      var error = sharedUtil.error;
+      var isInt = sharedUtil.isInt;
+      var isString = sharedUtil.isString;
+      var MissingDataException = sharedUtil.MissingDataException;
+      var isName = corePrimitives.isName;
+      var isCmd = corePrimitives.isCmd;
+      var isStream = corePrimitives.isStream;
+      var StringStream = coreStream.StringStream;
+      var Lexer = coreParser.Lexer;
+      var isEOF = coreParser.isEOF;
+      var BUILT_IN_CMAPS = [
+        // << Start unicode maps.
+        'Adobe-GB1-UCS2',
+        'Adobe-CNS1-UCS2',
+        'Adobe-Japan1-UCS2',
+        'Adobe-Korea1-UCS2',
+        // >> End unicode maps.
+        '78-EUC-H',
+        '78-EUC-V',
+        '78-H',
+        '78-RKSJ-H',
+        '78-RKSJ-V',
+        '78-V',
+        '78ms-RKSJ-H',
+        '78ms-RKSJ-V',
+        '83pv-RKSJ-H',
+        '90ms-RKSJ-H',
+        '90ms-RKSJ-V',
+        '90msp-RKSJ-H',
+        '90msp-RKSJ-V',
+        '90pv-RKSJ-H',
+        '90pv-RKSJ-V',
+        'Add-H',
+        'Add-RKSJ-H',
+        'Add-RKSJ-V',
+        'Add-V',
+        'Adobe-CNS1-0',
+        'Adobe-CNS1-1',
+        'Adobe-CNS1-2',
+        'Adobe-CNS1-3',
+        'Adobe-CNS1-4',
+        'Adobe-CNS1-5',
+        'Adobe-CNS1-6',
+        'Adobe-GB1-0',
+        'Adobe-GB1-1',
+        'Adobe-GB1-2',
+        'Adobe-GB1-3',
+        'Adobe-GB1-4',
+        'Adobe-GB1-5',
+        'Adobe-Japan1-0',
+        'Adobe-Japan1-1',
+        'Adobe-Japan1-2',
+        'Adobe-Japan1-3',
+        'Adobe-Japan1-4',
+        'Adobe-Japan1-5',
+        'Adobe-Japan1-6',
+        'Adobe-Korea1-0',
+        'Adobe-Korea1-1',
+        'Adobe-Korea1-2',
+        'B5-H',
+        'B5-V',
+        'B5pc-H',
+        'B5pc-V',
+        'CNS-EUC-H',
+        'CNS-EUC-V',
+        'CNS1-H',
+        'CNS1-V',
+        'CNS2-H',
+        'CNS2-V',
+        'ETHK-B5-H',
+        'ETHK-B5-V',
+        'ETen-B5-H',
+        'ETen-B5-V',
+        'ETenms-B5-H',
+        'ETenms-B5-V',
+        'EUC-H',
+        'EUC-V',
+        'Ext-H',
+        'Ext-RKSJ-H',
+        'Ext-RKSJ-V',
+        'Ext-V',
+        'GB-EUC-H',
+        'GB-EUC-V',
+        'GB-H',
+        'GB-V',
+        'GBK-EUC-H',
+        'GBK-EUC-V',
+        'GBK2K-H',
+        'GBK2K-V',
+        'GBKp-EUC-H',
+        'GBKp-EUC-V',
+        'GBT-EUC-H',
+        'GBT-EUC-V',
+        'GBT-H',
+        'GBT-V',
+        'GBTpc-EUC-H',
+        'GBTpc-EUC-V',
+        'GBpc-EUC-H',
+        'GBpc-EUC-V',
+        'H',
+        'HKdla-B5-H',
+        'HKdla-B5-V',
+        'HKdlb-B5-H',
+        'HKdlb-B5-V',
+        'HKgccs-B5-H',
+        'HKgccs-B5-V',
+        'HKm314-B5-H',
+        'HKm314-B5-V',
+        'HKm471-B5-H',
+        'HKm471-B5-V',
+        'HKscs-B5-H',
+        'HKscs-B5-V',
+        'Hankaku',
+        'Hiragana',
+        'KSC-EUC-H',
+        'KSC-EUC-V',
+        'KSC-H',
+        'KSC-Johab-H',
+        'KSC-Johab-V',
+        'KSC-V',
+        'KSCms-UHC-H',
+        'KSCms-UHC-HW-H',
+        'KSCms-UHC-HW-V',
+        'KSCms-UHC-V',
+        'KSCpc-EUC-H',
+        'KSCpc-EUC-V',
+        'Katakana',
+        'NWP-H',
+        'NWP-V',
+        'RKSJ-H',
+        'RKSJ-V',
+        'Roman',
+        'UniCNS-UCS2-H',
+        'UniCNS-UCS2-V',
+        'UniCNS-UTF16-H',
+        'UniCNS-UTF16-V',
+        'UniCNS-UTF32-H',
+        'UniCNS-UTF32-V',
+        'UniCNS-UTF8-H',
+        'UniCNS-UTF8-V',
+        'UniGB-UCS2-H',
+        'UniGB-UCS2-V',
+        'UniGB-UTF16-H',
+        'UniGB-UTF16-V',
+        'UniGB-UTF32-H',
+        'UniGB-UTF32-V',
+        'UniGB-UTF8-H',
+        'UniGB-UTF8-V',
+        'UniJIS-UCS2-H',
+        'UniJIS-UCS2-HW-H',
+        'UniJIS-UCS2-HW-V',
+        'UniJIS-UCS2-V',
+        'UniJIS-UTF16-H',
+        'UniJIS-UTF16-V',
+        'UniJIS-UTF32-H',
+        'UniJIS-UTF32-V',
+        'UniJIS-UTF8-H',
+        'UniJIS-UTF8-V',
+        'UniJIS2004-UTF16-H',
+        'UniJIS2004-UTF16-V',
+        'UniJIS2004-UTF32-H',
+        'UniJIS2004-UTF32-V',
+        'UniJIS2004-UTF8-H',
+        'UniJIS2004-UTF8-V',
+        'UniJISPro-UCS2-HW-V',
+        'UniJISPro-UCS2-V',
+        'UniJISPro-UTF8-V',
+        'UniJISX0213-UTF32-H',
+        'UniJISX0213-UTF32-V',
+        'UniJISX02132004-UTF32-H',
+        'UniJISX02132004-UTF32-V',
+        'UniKS-UCS2-H',
+        'UniKS-UCS2-V',
+        'UniKS-UTF16-H',
+        'UniKS-UTF16-V',
+        'UniKS-UTF32-H',
+        'UniKS-UTF32-V',
+        'UniKS-UTF8-H',
+        'UniKS-UTF8-V',
+        'V',
+        'WP-Symbol'
+      ];
+      // CMap, not to be confused with TrueType's cmap.
+      var CMap = function CMapClosure() {
+        function CMap(builtInCMap) {
+          // Codespace ranges are stored as follows:
+          // [[1BytePairs], [2BytePairs], [3BytePairs], [4BytePairs]]
+          // where nBytePairs are ranges e.g. [low1, high1, low2, high2, ...]
+          this.codespaceRanges = [
+            [],
+            [],
+            [],
+            []
+          ];
+          this.numCodespaceRanges = 0;
+          // Map entries have one of two forms.
+          // - cid chars are 16-bit unsigned integers, stored as integers.
+          // - bf chars are variable-length byte sequences, stored as strings, with
+          //   one byte per character.
+          this._map = [];
+          this.name = '';
+          this.vertical = false;
+          this.useCMap = null;
+          this.builtInCMap = builtInCMap;
+        }
+        CMap.prototype = {
+          addCodespaceRange: function (n, low, high) {
+            this.codespaceRanges[n - 1].push(low, high);
+            this.numCodespaceRanges++;
+          },
+          mapCidRange: function (low, high, dstLow) {
+            while (low <= high) {
+              this._map[low++] = dstLow++;
+            }
+          },
+          mapBfRange: function (low, high, dstLow) {
+            var lastByte = dstLow.length - 1;
+            while (low <= high) {
+              this._map[low++] = dstLow;
+              // Only the last byte has to be incremented.
+              dstLow = dstLow.substr(0, lastByte) + String.fromCharCode(dstLow.charCodeAt(lastByte) + 1);
+            }
+          },
+          mapBfRangeToArray: function (low, high, array) {
+            var i = 0, ii = array.length;
+            while (low <= high && i < ii) {
+              this._map[low] = array[i++];
+              ++low;
+            }
+          },
+          // This is used for both bf and cid chars.
+          mapOne: function (src, dst) {
+            this._map[src] = dst;
+          },
+          lookup: function (code) {
+            return this._map[code];
+          },
+          contains: function (code) {
+            return this._map[code] !== undefined;
+          },
+          forEach: function (callback) {
+            // Most maps have fewer than 65536 entries, and for those we use normal
+            // array iteration. But really sparse tables are possible -- e.g. with
+            // indices in the *billions*. For such tables we use for..in, which isn't
+            // ideal because it stringifies the indices for all present elements, but
+            // it does avoid iterating over every undefined entry.
+            var map = this._map;
+            var length = map.length;
+            var i;
+            if (length <= 0x10000) {
+              for (i = 0; i < length; i++) {
+                if (map[i] !== undefined) {
+                  callback(i, map[i]);
+                }
+              }
+            } else {
+              for (i in this._map) {
+                callback(i, map[i]);
+              }
+            }
+          },
+          charCodeOf: function (value) {
+            return this._map.indexOf(value);
+          },
+          getMap: function () {
+            return this._map;
+          },
+          readCharCode: function (str, offset, out) {
+            var c = 0;
+            var codespaceRanges = this.codespaceRanges;
+            var codespaceRangesLen = this.codespaceRanges.length;
+            // 9.7.6.2 CMap Mapping
+            // The code length is at most 4.
+            for (var n = 0; n < codespaceRangesLen; n++) {
+              c = (c << 8 | str.charCodeAt(offset + n)) >>> 0;
+              // Check each codespace range to see if it falls within.
+              var codespaceRange = codespaceRanges[n];
+              for (var k = 0, kk = codespaceRange.length; k < kk;) {
+                var low = codespaceRange[k++];
+                var high = codespaceRange[k++];
+                if (c >= low && c <= high) {
+                  out.charcode = c;
+                  out.length = n + 1;
+                  return;
+                }
+              }
+            }
+            out.charcode = 0;
+            out.length = 1;
+          },
+          get length() {
+            return this._map.length;
+          },
+          get isIdentityCMap() {
+            if (!(this.name === 'Identity-H' || this.name === 'Identity-V')) {
+              return false;
+            }
+            if (this._map.length !== 0x10000) {
+              return false;
+            }
+            for (var i = 0; i < 0x10000; i++) {
+              if (this._map[i] !== i) {
+                return false;
+              }
+            }
+            return true;
+          }
+        };
+        return CMap;
+      }();
+      // A special case of CMap, where the _map array implicitly has a length of
+      // 65536 and each element is equal to its index.
+      var IdentityCMap = function IdentityCMapClosure() {
+        function IdentityCMap(vertical, n) {
+          CMap.call(this);
+          this.vertical = vertical;
+          this.addCodespaceRange(n, 0, 0xffff);
+        }
+        Util.inherit(IdentityCMap, CMap, {});
+        IdentityCMap.prototype = {
+          addCodespaceRange: CMap.prototype.addCodespaceRange,
+          mapCidRange: function (low, high, dstLow) {
+            error('should not call mapCidRange');
+          },
+          mapBfRange: function (low, high, dstLow) {
+            error('should not call mapBfRange');
+          },
+          mapBfRangeToArray: function (low, high, array) {
+            error('should not call mapBfRangeToArray');
+          },
+          mapOne: function (src, dst) {
+            error('should not call mapCidOne');
+          },
+          lookup: function (code) {
+            return isInt(code) && code <= 0xffff ? code : undefined;
+          },
+          contains: function (code) {
+            return isInt(code) && code <= 0xffff;
+          },
+          forEach: function (callback) {
+            for (var i = 0; i <= 0xffff; i++) {
+              callback(i, i);
+            }
+          },
+          charCodeOf: function (value) {
+            return isInt(value) && value <= 0xffff ? value : -1;
+          },
+          getMap: function () {
+            // Sometimes identity maps must be instantiated, but it's rare.
+            var map = new Array(0x10000);
+            for (var i = 0; i <= 0xffff; i++) {
+              map[i] = i;
+            }
+            return map;
+          },
+          readCharCode: CMap.prototype.readCharCode,
+          get length() {
+            return 0x10000;
+          },
+          get isIdentityCMap() {
+            error('should not access .isIdentityCMap');
+          }
+        };
+        return IdentityCMap;
+      }();
+      var BinaryCMapReader = function BinaryCMapReaderClosure() {
+        function fetchBinaryData(url) {
+          return new Promise(function (resolve, reject) {
+            var request = new XMLHttpRequest();
+            request.open('GET', url, true);
+            request.responseType = 'arraybuffer';
+            request.onreadystatechange = function () {
+              if (request.readyState === XMLHttpRequest.DONE) {
+                if (!request.response || request.status !== 200 && request.status !== 0) {
+                  reject(new Error('Unable to get binary cMap at: ' + url));
+                } else {
+                  resolve(new Uint8Array(request.response));
+                }
+              }
+            };
+            request.send(null);
+          });
+        }
+        function hexToInt(a, size) {
+          var n = 0;
+          for (var i = 0; i <= size; i++) {
+            n = n << 8 | a[i];
+          }
+          return n >>> 0;
+        }
+        function hexToStr(a, size) {
+          // This code is hot. Special-case some common values to avoid creating an
+          // object with subarray().
+          if (size === 1) {
+            return String.fromCharCode(a[0], a[1]);
+          }
+          if (size === 3) {
+            return String.fromCharCode(a[0], a[1], a[2], a[3]);
+          }
+          return String.fromCharCode.apply(null, a.subarray(0, size + 1));
+        }
+        function addHex(a, b, size) {
+          var c = 0;
+          for (var i = size; i >= 0; i--) {
+            c += a[i] + b[i];
+            a[i] = c & 255;
+            c >>= 8;
+          }
+        }
+        function incHex(a, size) {
+          var c = 1;
+          for (var i = size; i >= 0 && c > 0; i--) {
+            c += a[i];
+            a[i] = c & 255;
+            c >>= 8;
+          }
+        }
+        var MAX_NUM_SIZE = 16;
+        var MAX_ENCODED_NUM_SIZE = 19;
+        // ceil(MAX_NUM_SIZE * 7 / 8)
+        function BinaryCMapStream(data) {
+          this.buffer = data;
+          this.pos = 0;
+          this.end = data.length;
+          this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);
+        }
+        BinaryCMapStream.prototype = {
+          readByte: function () {
+            if (this.pos >= this.end) {
+              return -1;
+            }
+            return this.buffer[this.pos++];
+          },
+          readNumber: function () {
+            var n = 0;
+            var last;
+            do {
+              var b = this.readByte();
+              if (b < 0) {
+                error('unexpected EOF in bcmap');
+              }
+              last = !(b & 0x80);
+              n = n << 7 | b & 0x7F;
+            } while (!last);
+            return n;
+          },
+          readSigned: function () {
+            var n = this.readNumber();
+            return n & 1 ? ~(n >>> 1) : n >>> 1;
+          },
+          readHex: function (num, size) {
+            num.set(this.buffer.subarray(this.pos, this.pos + size + 1));
+            this.pos += size + 1;
+          },
+          readHexNumber: function (num, size) {
+            var last;
+            var stack = this.tmpBuf, sp = 0;
+            do {
+              var b = this.readByte();
+              if (b < 0) {
+                error('unexpected EOF in bcmap');
+              }
+              last = !(b & 0x80);
+              stack[sp++] = b & 0x7F;
+            } while (!last);
+            var i = size, buffer = 0, bufferSize = 0;
+            while (i >= 0) {
+              while (bufferSize < 8 && stack.length > 0) {
+                buffer = stack[--sp] << bufferSize | buffer;
+                bufferSize += 7;
+              }
+              num[i] = buffer & 255;
+              i--;
+              buffer >>= 8;
+              bufferSize -= 8;
+            }
+          },
+          readHexSigned: function (num, size) {
+            this.readHexNumber(num, size);
+            var sign = num[size] & 1 ? 255 : 0;
+            var c = 0;
+            for (var i = 0; i <= size; i++) {
+              c = (c & 1) << 8 | num[i];
+              num[i] = c >> 1 ^ sign;
+            }
+          },
+          readString: function () {
+            var len = this.readNumber();
+            var s = '';
+            for (var i = 0; i < len; i++) {
+              s += String.fromCharCode(this.readNumber());
+            }
+            return s;
+          }
+        };
+        function processBinaryCMap(url, cMap, extend) {
+          return fetchBinaryData(url).then(function (data) {
+            var stream = new BinaryCMapStream(data);
+            var header = stream.readByte();
+            cMap.vertical = !!(header & 1);
+            var useCMap = null;
+            var start = new Uint8Array(MAX_NUM_SIZE);
+            var end = new Uint8Array(MAX_NUM_SIZE);
+            var char = new Uint8Array(MAX_NUM_SIZE);
+            var charCode = new Uint8Array(MAX_NUM_SIZE);
+            var tmp = new Uint8Array(MAX_NUM_SIZE);
+            var code;
+            var b;
+            while ((b = stream.readByte()) >= 0) {
+              var type = b >> 5;
+              if (type === 7) {
+                // metadata, e.g. comment or usecmap
+                switch (b & 0x1F) {
+                case 0:
+                  stream.readString();
+                  // skipping comment
+                  break;
+                case 1:
+                  useCMap = stream.readString();
+                  break;
+                }
+                continue;
+              }
+              var sequence = !!(b & 0x10);
+              var dataSize = b & 15;
+              assert(dataSize + 1 <= MAX_NUM_SIZE);
+              var ucs2DataSize = 1;
+              var subitemsCount = stream.readNumber();
+              var i;
+              switch (type) {
+              case 0:
+                // codespacerange
+                stream.readHex(start, dataSize);
+                stream.readHexNumber(end, dataSize);
+                addHex(end, start, dataSize);
+                cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
+                for (i = 1; i < subitemsCount; i++) {
+                  incHex(end, dataSize);
+                  stream.readHexNumber(start, dataSize);
+                  addHex(start, end, dataSize);
+                  stream.readHexNumber(end, dataSize);
+                  addHex(end, start, dataSize);
+                  cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
+                }
+                break;
+              case 1:
+                // notdefrange
+                stream.readHex(start, dataSize);
+                stream.readHexNumber(end, dataSize);
+                addHex(end, start, dataSize);
+                code = stream.readNumber();
+                // undefined range, skipping
+                for (i = 1; i < subitemsCount; i++) {
+                  incHex(end, dataSize);
+                  stream.readHexNumber(start, dataSize);
+                  addHex(start, end, dataSize);
+                  stream.readHexNumber(end, dataSize);
+                  addHex(end, start, dataSize);
+                  code = stream.readNumber();
+                }
+                // nop
+                break;
+              case 2:
+                // cidchar
+                stream.readHex(char, dataSize);
+                code = stream.readNumber();
+                cMap.mapOne(hexToInt(char, dataSize), code);
+                for (i = 1; i < subitemsCount; i++) {
+                  incHex(char, dataSize);
+                  if (!sequence) {
+                    stream.readHexNumber(tmp, dataSize);
+                    addHex(char, tmp, dataSize);
+                  }
+                  code = stream.readSigned() + (code + 1);
+                  cMap.mapOne(hexToInt(char, dataSize), code);
+                }
+                break;
+              case 3:
+                // cidrange
+                stream.readHex(start, dataSize);
+                stream.readHexNumber(end, dataSize);
+                addHex(end, start, dataSize);
+                code = stream.readNumber();
+                cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
+                for (i = 1; i < subitemsCount; i++) {
+                  incHex(end, dataSize);
+                  if (!sequence) {
+                    stream.readHexNumber(start, dataSize);
+                    addHex(start, end, dataSize);
+                  } else {
+                    start.set(end);
+                  }
+                  stream.readHexNumber(end, dataSize);
+                  addHex(end, start, dataSize);
+                  code = stream.readNumber();
+                  cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
+                }
+                break;
+              case 4:
+                // bfchar
+                stream.readHex(char, ucs2DataSize);
+                stream.readHex(charCode, dataSize);
+                cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
+                for (i = 1; i < subitemsCount; i++) {
+                  incHex(char, ucs2DataSize);
+                  if (!sequence) {
+                    stream.readHexNumber(tmp, ucs2DataSize);
+                    addHex(char, tmp, ucs2DataSize);
+                  }
+                  incHex(charCode, dataSize);
+                  stream.readHexSigned(tmp, dataSize);
+                  addHex(charCode, tmp, dataSize);
+                  cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
+                }
+                break;
+              case 5:
+                // bfrange
+                stream.readHex(start, ucs2DataSize);
+                stream.readHexNumber(end, ucs2DataSize);
+                addHex(end, start, ucs2DataSize);
+                stream.readHex(charCode, dataSize);
+                cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
+                for (i = 1; i < subitemsCount; i++) {
+                  incHex(end, ucs2DataSize);
+                  if (!sequence) {
+                    stream.readHexNumber(start, ucs2DataSize);
+                    addHex(start, end, ucs2DataSize);
+                  } else {
+                    start.set(end);
+                  }
+                  stream.readHexNumber(end, ucs2DataSize);
+                  addHex(end, start, ucs2DataSize);
+                  stream.readHex(charCode, dataSize);
+                  cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
+                }
+                break;
+              default:
+                error('Unknown type: ' + type);
+                break;
+              }
+            }
+            if (useCMap) {
+              return extend(useCMap);
+            }
+            return cMap;
+          });
+        }
+        function BinaryCMapReader() {
+        }
+        BinaryCMapReader.prototype = { read: processBinaryCMap };
+        return BinaryCMapReader;
+      }();
+      var CMapFactory = function CMapFactoryClosure() {
+        function strToInt(str) {
+          var a = 0;
+          for (var i = 0; i < str.length; i++) {
+            a = a << 8 | str.charCodeAt(i);
+          }
+          return a >>> 0;
+        }
+        function expectString(obj) {
+          if (!isString(obj)) {
+            error('Malformed CMap: expected string.');
+          }
+        }
+        function expectInt(obj) {
+          if (!isInt(obj)) {
+            error('Malformed CMap: expected int.');
+          }
+        }
+        function parseBfChar(cMap, lexer) {
+          while (true) {
+            var obj = lexer.getObj();
+            if (isEOF(obj)) {
+              break;
+            }
+            if (isCmd(obj, 'endbfchar')) {
+              return;
+            }
+            expectString(obj);
+            var src = strToInt(obj);
+            obj = lexer.getObj();
+            // TODO are /dstName used?
+            expectString(obj);
+            var dst = obj;
+            cMap.mapOne(src, dst);
+          }
+        }
+        function parseBfRange(cMap, lexer) {
+          while (true) {
+            var obj = lexer.getObj();
+            if (isEOF(obj)) {
+              break;
+            }
+            if (isCmd(obj, 'endbfrange')) {
+              return;
+            }
+            expectString(obj);
+            var low = strToInt(obj);
+            obj = lexer.getObj();
+            expectString(obj);
+            var high = strToInt(obj);
+            obj = lexer.getObj();
+            if (isInt(obj) || isString(obj)) {
+              var dstLow = isInt(obj) ? String.fromCharCode(obj) : obj;
+              cMap.mapBfRange(low, high, dstLow);
+            } else if (isCmd(obj, '[')) {
+              obj = lexer.getObj();
+              var array = [];
+              while (!isCmd(obj, ']') && !isEOF(obj)) {
+                array.push(obj);
+                obj = lexer.getObj();
+              }
+              cMap.mapBfRangeToArray(low, high, array);
+            } else {
+              break;
+            }
+          }
+          error('Invalid bf range.');
+        }
+        function parseCidChar(cMap, lexer) {
+          while (true) {
+            var obj = lexer.getObj();
+            if (isEOF(obj)) {
+              break;
+            }
+            if (isCmd(obj, 'endcidchar')) {
+              return;
+            }
+            expectString(obj);
+            var src = strToInt(obj);
+            obj = lexer.getObj();
+            expectInt(obj);
+            var dst = obj;
+            cMap.mapOne(src, dst);
+          }
+        }
+        function parseCidRange(cMap, lexer) {
+          while (true) {
+            var obj = lexer.getObj();
+            if (isEOF(obj)) {
+              break;
+            }
+            if (isCmd(obj, 'endcidrange')) {
+              return;
+            }
+            expectString(obj);
+            var low = strToInt(obj);
+            obj = lexer.getObj();
+            expectString(obj);
+            var high = strToInt(obj);
+            obj = lexer.getObj();
+            expectInt(obj);
+            var dstLow = obj;
+            cMap.mapCidRange(low, high, dstLow);
+          }
+        }
+        function parseCodespaceRange(cMap, lexer) {
+          while (true) {
+            var obj = lexer.getObj();
+            if (isEOF(obj)) {
+              break;
+            }
+            if (isCmd(obj, 'endcodespacerange')) {
+              return;
+            }
+            if (!isString(obj)) {
+              break;
+            }
+            var low = strToInt(obj);
+            obj = lexer.getObj();
+            if (!isString(obj)) {
+              break;
+            }
+            var high = strToInt(obj);
+            cMap.addCodespaceRange(obj.length, low, high);
+          }
+          error('Invalid codespace range.');
+        }
+        function parseWMode(cMap, lexer) {
+          var obj = lexer.getObj();
+          if (isInt(obj)) {
+            cMap.vertical = !!obj;
+          }
+        }
+        function parseCMapName(cMap, lexer) {
+          var obj = lexer.getObj();
+          if (isName(obj) && isString(obj.name)) {
+            cMap.name = obj.name;
+          }
+        }
+        function parseCMap(cMap, lexer, builtInCMapParams, useCMap) {
+          var previous;
+          var embededUseCMap;
+          objLoop:
+            while (true) {
+              try {
+                var obj = lexer.getObj();
+                if (isEOF(obj)) {
+                  break;
+                } else if (isName(obj)) {
+                  if (obj.name === 'WMode') {
+                    parseWMode(cMap, lexer);
+                  } else if (obj.name === 'CMapName') {
+                    parseCMapName(cMap, lexer);
+                  }
+                  previous = obj;
+                } else if (isCmd(obj)) {
+                  switch (obj.cmd) {
+                  case 'endcmap':
+                    break objLoop;
+                  case 'usecmap':
+                    if (isName(previous)) {
+                      embededUseCMap = previous.name;
+                    }
+                    break;
+                  case 'begincodespacerange':
+                    parseCodespaceRange(cMap, lexer);
+                    break;
+                  case 'beginbfchar':
+                    parseBfChar(cMap, lexer);
+                    break;
+                  case 'begincidchar':
+                    parseCidChar(cMap, lexer);
+                    break;
+                  case 'beginbfrange':
+                    parseBfRange(cMap, lexer);
+                    break;
+                  case 'begincidrange':
+                    parseCidRange(cMap, lexer);
+                    break;
+                  }
+                }
+              } catch (ex) {
+                if (ex instanceof MissingDataException) {
+                  throw ex;
+                }
+                warn('Invalid cMap data: ' + ex);
+                continue;
+              }
+            }
+          if (!useCMap && embededUseCMap) {
+            // Load the usecmap definition from the file only if there wasn't one
+            // specified.
+            useCMap = embededUseCMap;
+          }
+          if (useCMap) {
+            return extendCMap(cMap, builtInCMapParams, useCMap);
+          }
+          return Promise.resolve(cMap);
+        }
+        function extendCMap(cMap, builtInCMapParams, useCMap) {
+          return createBuiltInCMap(useCMap, builtInCMapParams).then(function (newCMap) {
+            cMap.useCMap = newCMap;
+            // If there aren't any code space ranges defined clone all the parent ones
+            // into this cMap.
+            if (cMap.numCodespaceRanges === 0) {
+              var useCodespaceRanges = cMap.useCMap.codespaceRanges;
+              for (var i = 0; i < useCodespaceRanges.length; i++) {
+                cMap.codespaceRanges[i] = useCodespaceRanges[i].slice();
+              }
+              cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges;
+            }
+            // Merge the map into the current one, making sure not to override
+            // any previously defined entries.
+            cMap.useCMap.forEach(function (key, value) {
+              if (!cMap.contains(key)) {
+                cMap.mapOne(key, cMap.useCMap.lookup(key));
+              }
+            });
+            return cMap;
+          });
+        }
+        function parseBinaryCMap(name, builtInCMapParams) {
+          var url = builtInCMapParams.url + name + '.bcmap';
+          var cMap = new CMap(true);
+          return new BinaryCMapReader().read(url, cMap, function (useCMap) {
+            return extendCMap(cMap, builtInCMapParams, useCMap);
+          });
+        }
+        function createBuiltInCMap(name, builtInCMapParams) {
+          if (name === 'Identity-H') {
+            return Promise.resolve(new IdentityCMap(false, 2));
+          } else if (name === 'Identity-V') {
+            return Promise.resolve(new IdentityCMap(true, 2));
+          }
+          if (BUILT_IN_CMAPS.indexOf(name) === -1) {
+            return Promise.reject(new Error('Unknown cMap name: ' + name));
+          }
+          assert(builtInCMapParams, 'built-in cMap parameters are not provided');
+          if (builtInCMapParams.packed) {
+            return parseBinaryCMap(name, builtInCMapParams);
+          }
+          return new Promise(function (resolve, reject) {
+            var url = builtInCMapParams.url + name;
+            var request = new XMLHttpRequest();
+            request.onreadystatechange = function () {
+              if (request.readyState === XMLHttpRequest.DONE) {
+                if (request.status === 200 || request.status === 0) {
+                  var cMap = new CMap(true);
+                  var lexer = new Lexer(new StringStream(request.responseText));
+                  parseCMap(cMap, lexer, builtInCMapParams, null).then(function (parsedCMap) {
+                    resolve(parsedCMap);
+                  });
+                } else {
+                  reject(new Error('Unable to get cMap at: ' + url));
+                }
+              }
+            };
+            request.open('GET', url, true);
+            request.send(null);
+          });
+        }
+        return {
+          create: function (encoding, builtInCMapParams, useCMap) {
+            if (isName(encoding)) {
+              return createBuiltInCMap(encoding.name, builtInCMapParams);
+            } else if (isStream(encoding)) {
+              var cMap = new CMap();
+              var lexer = new Lexer(encoding);
+              return parseCMap(cMap, lexer, builtInCMapParams, useCMap).then(function (parsedCMap) {
+                if (parsedCMap.isIdentityCMap) {
+                  return createBuiltInCMap(parsedCMap.name, builtInCMapParams);
+                }
+                return parsedCMap;
+              });
+            }
+            return Promise.reject(new Error('Encoding required.'));
+          }
+        };
+      }();
+      exports.CMap = CMap;
+      exports.CMapFactory = CMapFactory;
+      exports.IdentityCMap = IdentityCMap;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreFonts = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreGlyphList, root.pdfjsCoreFontRenderer, root.pdfjsCoreEncodings, root.pdfjsCoreStandardFonts, root.pdfjsCoreUnicode, root.pdfjsCoreType1Parser, root.pdfjsCoreCFFParser);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream, coreGlyphList, coreFontRenderer, coreEncodings, coreStandardFonts, coreUnicode, coreType1Parser, coreCFFParser) {
+      var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX;
+      var FontType = sharedUtil.FontType;
+      var assert = sharedUtil.assert;
+      var bytesToString = sharedUtil.bytesToString;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isInt = sharedUtil.isInt;
+      var isNum = sharedUtil.isNum;
+      var readUint32 = sharedUtil.readUint32;
+      var shadow = sharedUtil.shadow;
+      var string32 = sharedUtil.string32;
+      var warn = sharedUtil.warn;
+      var MissingDataException = sharedUtil.MissingDataException;
+      var isSpace = sharedUtil.isSpace;
+      var Stream = coreStream.Stream;
+      var getGlyphsUnicode = coreGlyphList.getGlyphsUnicode;
+      var getDingbatsGlyphsUnicode = coreGlyphList.getDingbatsGlyphsUnicode;
+      var FontRendererFactory = coreFontRenderer.FontRendererFactory;
+      var StandardEncoding = coreEncodings.StandardEncoding;
+      var MacRomanEncoding = coreEncodings.MacRomanEncoding;
+      var SymbolSetEncoding = coreEncodings.SymbolSetEncoding;
+      var ZapfDingbatsEncoding = coreEncodings.ZapfDingbatsEncoding;
+      var getEncoding = coreEncodings.getEncoding;
+      var getStdFontMap = coreStandardFonts.getStdFontMap;
+      var getNonStdFontMap = coreStandardFonts.getNonStdFontMap;
+      var getGlyphMapForStandardFonts = coreStandardFonts.getGlyphMapForStandardFonts;
+      var getSupplementalGlyphMapForArialBlack = coreStandardFonts.getSupplementalGlyphMapForArialBlack;
+      var getUnicodeRangeFor = coreUnicode.getUnicodeRangeFor;
+      var mapSpecialUnicodeValues = coreUnicode.mapSpecialUnicodeValues;
+      var getUnicodeForGlyph = coreUnicode.getUnicodeForGlyph;
+      var Type1Parser = coreType1Parser.Type1Parser;
+      var CFFStandardStrings = coreCFFParser.CFFStandardStrings;
+      var CFFParser = coreCFFParser.CFFParser;
+      var CFFCompiler = coreCFFParser.CFFCompiler;
+      var CFF = coreCFFParser.CFF;
+      var CFFHeader = coreCFFParser.CFFHeader;
+      var CFFTopDict = coreCFFParser.CFFTopDict;
+      var CFFPrivateDict = coreCFFParser.CFFPrivateDict;
+      var CFFStrings = coreCFFParser.CFFStrings;
+      var CFFIndex = coreCFFParser.CFFIndex;
+      var CFFCharset = coreCFFParser.CFFCharset;
+      // Unicode Private Use Area
+      var PRIVATE_USE_OFFSET_START = 0xE000;
+      var PRIVATE_USE_OFFSET_END = 0xF8FF;
+      var SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = false;
+      // PDF Glyph Space Units are one Thousandth of a TextSpace Unit
+      // except for Type 3 fonts
+      var PDF_GLYPH_SPACE_UNITS = 1000;
+      // Accented charactars are not displayed properly on Windows, using this flag
+      // to control analysis of seac charstrings.
+      var SEAC_ANALYSIS_ENABLED = false;
+      var FontFlags = {
+        FixedPitch: 1,
+        Serif: 2,
+        Symbolic: 4,
+        Script: 8,
+        Nonsymbolic: 32,
+        Italic: 64,
+        AllCap: 65536,
+        SmallCap: 131072,
+        ForceBold: 262144
+      };
+      var MacStandardGlyphOrdering = [
+        '.notdef',
+        '.null',
+        'nonmarkingreturn',
+        'space',
+        'exclam',
+        'quotedbl',
+        'numbersign',
+        'dollar',
+        'percent',
+        'ampersand',
+        'quotesingle',
+        'parenleft',
+        'parenright',
+        'asterisk',
+        'plus',
+        'comma',
+        'hyphen',
+        'period',
+        'slash',
+        'zero',
+        'one',
+        'two',
+        'three',
+        'four',
+        'five',
+        'six',
+        'seven',
+        'eight',
+        'nine',
+        'colon',
+        'semicolon',
+        'less',
+        'equal',
+        'greater',
+        'question',
+        'at',
+        'A',
+        'B',
+        'C',
+        'D',
+        'E',
+        'F',
+        'G',
+        'H',
+        'I',
+        'J',
+        'K',
+        'L',
+        'M',
+        'N',
+        'O',
+        'P',
+        'Q',
+        'R',
+        'S',
+        'T',
+        'U',
+        'V',
+        'W',
+        'X',
+        'Y',
+        'Z',
+        'bracketleft',
+        'backslash',
+        'bracketright',
+        'asciicircum',
+        'underscore',
+        'grave',
+        'a',
+        'b',
+        'c',
+        'd',
+        'e',
+        'f',
+        'g',
+        'h',
+        'i',
+        'j',
+        'k',
+        'l',
+        'm',
+        'n',
+        'o',
+        'p',
+        'q',
+        'r',
+        's',
+        't',
+        'u',
+        'v',
+        'w',
+        'x',
+        'y',
+        'z',
+        'braceleft',
+        'bar',
+        'braceright',
+        'asciitilde',
+        'Adieresis',
+        'Aring',
+        'Ccedilla',
+        'Eacute',
+        'Ntilde',
+        'Odieresis',
+        'Udieresis',
+        'aacute',
+        'agrave',
+        'acircumflex',
+        'adieresis',
+        'atilde',
+        'aring',
+        'ccedilla',
+        'eacute',
+        'egrave',
+        'ecircumflex',
+        'edieresis',
+        'iacute',
+        'igrave',
+        'icircumflex',
+        'idieresis',
+        'ntilde',
+        'oacute',
+        'ograve',
+        'ocircumflex',
+        'odieresis',
+        'otilde',
+        'uacute',
+        'ugrave',
+        'ucircumflex',
+        'udieresis',
+        'dagger',
+        'degree',
+        'cent',
+        'sterling',
+        'section',
+        'bullet',
+        'paragraph',
+        'germandbls',
+        'registered',
+        'copyright',
+        'trademark',
+        'acute',
+        'dieresis',
+        'notequal',
+        'AE',
+        'Oslash',
+        'infinity',
+        'plusminus',
+        'lessequal',
+        'greaterequal',
+        'yen',
+        'mu',
+        'partialdiff',
+        'summation',
+        'product',
+        'pi',
+        'integral',
+        'ordfeminine',
+        'ordmasculine',
+        'Omega',
+        'ae',
+        'oslash',
+        'questiondown',
+        'exclamdown',
+        'logicalnot',
+        'radical',
+        'florin',
+        'approxequal',
+        'Delta',
+        'guillemotleft',
+        'guillemotright',
+        'ellipsis',
+        'nonbreakingspace',
+        'Agrave',
+        'Atilde',
+        'Otilde',
+        'OE',
+        'oe',
+        'endash',
+        'emdash',
+        'quotedblleft',
+        'quotedblright',
+        'quoteleft',
+        'quoteright',
+        'divide',
+        'lozenge',
+        'ydieresis',
+        'Ydieresis',
+        'fraction',
+        'currency',
+        'guilsinglleft',
+        'guilsinglright',
+        'fi',
+        'fl',
+        'daggerdbl',
+        'periodcentered',
+        'quotesinglbase',
+        'quotedblbase',
+        'perthousand',
+        'Acircumflex',
+        'Ecircumflex',
+        'Aacute',
+        'Edieresis',
+        'Egrave',
+        'Iacute',
+        'Icircumflex',
+        'Idieresis',
+        'Igrave',
+        'Oacute',
+        'Ocircumflex',
+        'apple',
+        'Ograve',
+        'Uacute',
+        'Ucircumflex',
+        'Ugrave',
+        'dotlessi',
+        'circumflex',
+        'tilde',
+        'macron',
+        'breve',
+        'dotaccent',
+        'ring',
+        'cedilla',
+        'hungarumlaut',
+        'ogonek',
+        'caron',
+        'Lslash',
+        'lslash',
+        'Scaron',
+        'scaron',
+        'Zcaron',
+        'zcaron',
+        'brokenbar',
+        'Eth',
+        'eth',
+        'Yacute',
+        'yacute',
+        'Thorn',
+        'thorn',
+        'minus',
+        'multiply',
+        'onesuperior',
+        'twosuperior',
+        'threesuperior',
+        'onehalf',
+        'onequarter',
+        'threequarters',
+        'franc',
+        'Gbreve',
+        'gbreve',
+        'Idotaccent',
+        'Scedilla',
+        'scedilla',
+        'Cacute',
+        'cacute',
+        'Ccaron',
+        'ccaron',
+        'dcroat'
+      ];
+      function adjustWidths(properties) {
+        if (!properties.fontMatrix) {
+          return;
+        }
+        if (properties.fontMatrix[0] === FONT_IDENTITY_MATRIX[0]) {
+          return;
+        }
+        // adjusting width to fontMatrix scale
+        var scale = 0.001 / properties.fontMatrix[0];
+        var glyphsWidths = properties.widths;
+        for (var glyph in glyphsWidths) {
+          glyphsWidths[glyph] *= scale;
+        }
+        properties.defaultWidth *= scale;
+      }
+      function adjustToUnicode(properties, builtInEncoding) {
+        if (properties.hasIncludedToUnicodeMap) {
+          return;
+        }
+        // The font dictionary has a `ToUnicode` entry.
+        if (properties.hasEncoding) {
+          return;
+        }
+        // The font dictionary has an `Encoding` entry.
+        if (builtInEncoding === properties.defaultEncoding) {
+          return;
+        }
+        // No point in trying to adjust `toUnicode` if the encodings match.
+        if (properties.toUnicode instanceof IdentityToUnicodeMap) {
+          return;
+        }
+        var toUnicode = [], glyphsUnicodeMap = getGlyphsUnicode();
+        for (var charCode in builtInEncoding) {
+          var glyphName = builtInEncoding[charCode];
+          var unicode = getUnicodeForGlyph(glyphName, glyphsUnicodeMap);
+          if (unicode !== -1) {
+            toUnicode[charCode] = String.fromCharCode(unicode);
+          }
+        }
+        properties.toUnicode.amend(toUnicode);
+      }
+      function getFontType(type, subtype) {
+        switch (type) {
+        case 'Type1':
+          return subtype === 'Type1C' ? FontType.TYPE1C : FontType.TYPE1;
+        case 'CIDFontType0':
+          return subtype === 'CIDFontType0C' ? FontType.CIDFONTTYPE0C : FontType.CIDFONTTYPE0;
+        case 'OpenType':
+          return FontType.OPENTYPE;
+        case 'TrueType':
+          return FontType.TRUETYPE;
+        case 'CIDFontType2':
+          return FontType.CIDFONTTYPE2;
+        case 'MMType1':
+          return FontType.MMTYPE1;
+        case 'Type0':
+          return FontType.TYPE0;
+        default:
+          return FontType.UNKNOWN;
+        }
+      }
+      // Some bad PDF generators, e.g. Scribus PDF, include glyph names
+      // in a 'uniXXXX' format -- attempting to recover proper ones.
+      function recoverGlyphName(name, glyphsUnicodeMap) {
+        if (glyphsUnicodeMap[name] !== undefined) {
+          return name;
+        }
+        // The glyph name is non-standard, trying to recover.
+        var unicode = getUnicodeForGlyph(name, glyphsUnicodeMap);
+        if (unicode !== -1) {
+          for (var key in glyphsUnicodeMap) {
+            if (glyphsUnicodeMap[key] === unicode) {
+              return key;
+            }
+          }
+        }
+        info('Unable to recover a standard glyph name for: ' + name);
+        return name;
+      }
+      var Glyph = function GlyphClosure() {
+        function Glyph(fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont) {
+          this.fontChar = fontChar;
+          this.unicode = unicode;
+          this.accent = accent;
+          this.width = width;
+          this.vmetric = vmetric;
+          this.operatorListId = operatorListId;
+          this.isSpace = isSpace;
+          this.isInFont = isInFont;
+        }
+        Glyph.prototype.matchesForCache = function (fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont) {
+          return this.fontChar === fontChar && this.unicode === unicode && this.accent === accent && this.width === width && this.vmetric === vmetric && this.operatorListId === operatorListId && this.isSpace === isSpace && this.isInFont === isInFont;
+        };
+        return Glyph;
+      }();
+      var ToUnicodeMap = function ToUnicodeMapClosure() {
+        function ToUnicodeMap(cmap) {
+          // The elements of this._map can be integers or strings, depending on how
+          // |cmap| was created.
+          this._map = cmap;
+        }
+        ToUnicodeMap.prototype = {
+          get length() {
+            return this._map.length;
+          },
+          forEach: function (callback) {
+            for (var charCode in this._map) {
+              callback(charCode, this._map[charCode].charCodeAt(0));
+            }
+          },
+          has: function (i) {
+            return this._map[i] !== undefined;
+          },
+          get: function (i) {
+            return this._map[i];
+          },
+          charCodeOf: function (v) {
+            return this._map.indexOf(v);
+          },
+          amend: function (map) {
+            for (var charCode in map) {
+              this._map[charCode] = map[charCode];
+            }
+          }
+        };
+        return ToUnicodeMap;
+      }();
+      var IdentityToUnicodeMap = function IdentityToUnicodeMapClosure() {
+        function IdentityToUnicodeMap(firstChar, lastChar) {
+          this.firstChar = firstChar;
+          this.lastChar = lastChar;
+        }
+        IdentityToUnicodeMap.prototype = {
+          get length() {
+            return this.lastChar + 1 - this.firstChar;
+          },
+          forEach: function (callback) {
+            for (var i = this.firstChar, ii = this.lastChar; i <= ii; i++) {
+              callback(i, i);
+            }
+          },
+          has: function (i) {
+            return this.firstChar <= i && i <= this.lastChar;
+          },
+          get: function (i) {
+            if (this.firstChar <= i && i <= this.lastChar) {
+              return String.fromCharCode(i);
+            }
+            return undefined;
+          },
+          charCodeOf: function (v) {
+            return isInt(v) && v >= this.firstChar && v <= this.lastChar ? v : -1;
+          },
+          amend: function (map) {
+            error('Should not call amend()');
+          }
+        };
+        return IdentityToUnicodeMap;
+      }();
+      var OpenTypeFileBuilder = function OpenTypeFileBuilderClosure() {
+        function writeInt16(dest, offset, num) {
+          dest[offset] = num >> 8 & 0xFF;
+          dest[offset + 1] = num & 0xFF;
+        }
+        function writeInt32(dest, offset, num) {
+          dest[offset] = num >> 24 & 0xFF;
+          dest[offset + 1] = num >> 16 & 0xFF;
+          dest[offset + 2] = num >> 8 & 0xFF;
+          dest[offset + 3] = num & 0xFF;
+        }
+        function writeData(dest, offset, data) {
+          var i, ii;
+          if (data instanceof Uint8Array) {
+            dest.set(data, offset);
+          } else if (typeof data === 'string') {
+            for (i = 0, ii = data.length; i < ii; i++) {
+              dest[offset++] = data.charCodeAt(i) & 0xFF;
+            }
+          } else {
+            // treating everything else as array
+            for (i = 0, ii = data.length; i < ii; i++) {
+              dest[offset++] = data[i] & 0xFF;
+            }
+          }
+        }
+        function OpenTypeFileBuilder(sfnt) {
+          this.sfnt = sfnt;
+          this.tables = Object.create(null);
+        }
+        OpenTypeFileBuilder.getSearchParams = function OpenTypeFileBuilder_getSearchParams(entriesCount, entrySize) {
+          var maxPower2 = 1, log2 = 0;
+          while ((maxPower2 ^ entriesCount) > maxPower2) {
+            maxPower2 <<= 1;
+            log2++;
+          }
+          var searchRange = maxPower2 * entrySize;
+          return {
+            range: searchRange,
+            entry: log2,
+            rangeShift: entrySize * entriesCount - searchRange
+          };
+        };
+        var OTF_HEADER_SIZE = 12;
+        var OTF_TABLE_ENTRY_SIZE = 16;
+        OpenTypeFileBuilder.prototype = {
+          toArray: function OpenTypeFileBuilder_toArray() {
+            var sfnt = this.sfnt;
+            // Tables needs to be written by ascendant alphabetic order
+            var tables = this.tables;
+            var tablesNames = Object.keys(tables);
+            tablesNames.sort();
+            var numTables = tablesNames.length;
+            var i, j, jj, table, tableName;
+            // layout the tables data
+            var offset = OTF_HEADER_SIZE + numTables * OTF_TABLE_ENTRY_SIZE;
+            var tableOffsets = [offset];
+            for (i = 0; i < numTables; i++) {
+              table = tables[tablesNames[i]];
+              var paddedLength = (table.length + 3 & ~3) >>> 0;
+              offset += paddedLength;
+              tableOffsets.push(offset);
+            }
+            var file = new Uint8Array(offset);
+            // write the table data first (mostly for checksum)
+            for (i = 0; i < numTables; i++) {
+              table = tables[tablesNames[i]];
+              writeData(file, tableOffsets[i], table);
+            }
+            // sfnt version (4 bytes)
+            if (sfnt === 'true') {
+              // Windows hates the Mac TrueType sfnt version number
+              sfnt = string32(0x00010000);
+            }
+            file[0] = sfnt.charCodeAt(0) & 0xFF;
+            file[1] = sfnt.charCodeAt(1) & 0xFF;
+            file[2] = sfnt.charCodeAt(2) & 0xFF;
+            file[3] = sfnt.charCodeAt(3) & 0xFF;
+            // numTables (2 bytes)
+            writeInt16(file, 4, numTables);
+            var searchParams = OpenTypeFileBuilder.getSearchParams(numTables, 16);
+            // searchRange (2 bytes)
+            writeInt16(file, 6, searchParams.range);
+            // entrySelector (2 bytes)
+            writeInt16(file, 8, searchParams.entry);
+            // rangeShift (2 bytes)
+            writeInt16(file, 10, searchParams.rangeShift);
+            offset = OTF_HEADER_SIZE;
+            // writing table entries
+            for (i = 0; i < numTables; i++) {
+              tableName = tablesNames[i];
+              file[offset] = tableName.charCodeAt(0) & 0xFF;
+              file[offset + 1] = tableName.charCodeAt(1) & 0xFF;
+              file[offset + 2] = tableName.charCodeAt(2) & 0xFF;
+              file[offset + 3] = tableName.charCodeAt(3) & 0xFF;
+              // checksum
+              var checksum = 0;
+              for (j = tableOffsets[i], jj = tableOffsets[i + 1]; j < jj; j += 4) {
+                var quad = readUint32(file, j);
+                checksum = checksum + quad >>> 0;
+              }
+              writeInt32(file, offset + 4, checksum);
+              // offset
+              writeInt32(file, offset + 8, tableOffsets[i]);
+              // length
+              writeInt32(file, offset + 12, tables[tableName].length);
+              offset += OTF_TABLE_ENTRY_SIZE;
+            }
+            return file;
+          },
+          addTable: function OpenTypeFileBuilder_addTable(tag, data) {
+            if (tag in this.tables) {
+              throw new Error('Table ' + tag + ' already exists');
+            }
+            this.tables[tag] = data;
+          }
+        };
+        return OpenTypeFileBuilder;
+      }();
+      // Problematic Unicode characters in the fonts that needs to be moved to avoid
+      // issues when they are painted on the canvas, e.g. complex-script shaping or
+      // control/whitespace characters. The ranges are listed in pairs: the first item
+      // is a code of the first problematic code, the second one is the next
+      // non-problematic code. The ranges must be in sorted order.
+      var ProblematicCharRanges = new Int32Array([
+        // Control characters.
+        0x0000,
+        0x0020,
+        0x007F,
+        0x00A1,
+        0x00AD,
+        0x00AE,
+        // Chars that is used in complex-script shaping.
+        0x0600,
+        0x0780,
+        0x08A0,
+        0x10A0,
+        0x1780,
+        0x1800,
+        0x1C00,
+        0x1C50,
+        // General punctuation chars.
+        0x2000,
+        0x2010,
+        0x2011,
+        0x2012,
+        0x2028,
+        0x2030,
+        0x205F,
+        0x2070,
+        0x25CC,
+        0x25CD,
+        0x3000,
+        0x3001,
+        // Chars that is used in complex-script shaping.
+        0xAA60,
+        0xAA80,
+        // Specials Unicode block.
+        0xFFF0,
+        0x10000
+      ]);
+      /**
+       * 'Font' is the class the outside world should use, it encapsulate all the font
+       * decoding logics whatever type it is (assuming the font type is supported).
+       *
+       * For example to read a Type1 font and to attach it to the document:
+       *   var type1Font = new Font("MyFontName", binaryFile, propertiesObject);
+       *   type1Font.bind();
+       */
+      var Font = function FontClosure() {
+        function Font(name, file, properties) {
+          var charCode, glyphName, unicode;
+          this.name = name;
+          this.loadedName = properties.loadedName;
+          this.isType3Font = properties.isType3Font;
+          this.sizes = [];
+          this.missingFile = false;
+          this.glyphCache = Object.create(null);
+          var names = name.split('+');
+          names = names.length > 1 ? names[1] : names[0];
+          names = names.split(/[-,_]/g)[0];
+          this.isSerifFont = !!(properties.flags & FontFlags.Serif);
+          this.isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);
+          this.isMonospace = !!(properties.flags & FontFlags.FixedPitch);
+          var type = properties.type;
+          var subtype = properties.subtype;
+          this.type = type;
+          this.fallbackName = this.isMonospace ? 'monospace' : this.isSerifFont ? 'serif' : 'sans-serif';
+          this.differences = properties.differences;
+          this.widths = properties.widths;
+          this.defaultWidth = properties.defaultWidth;
+          this.composite = properties.composite;
+          this.wideChars = properties.wideChars;
+          this.cMap = properties.cMap;
+          this.ascent = properties.ascent / PDF_GLYPH_SPACE_UNITS;
+          this.descent = properties.descent / PDF_GLYPH_SPACE_UNITS;
+          this.fontMatrix = properties.fontMatrix;
+          this.bbox = properties.bbox;
+          this.toUnicode = properties.toUnicode;
+          this.toFontChar = [];
+          if (properties.type === 'Type3') {
+            for (charCode = 0; charCode < 256; charCode++) {
+              this.toFontChar[charCode] = this.differences[charCode] || properties.defaultEncoding[charCode];
+            }
+            this.fontType = FontType.TYPE3;
+            return;
+          }
+          this.cidEncoding = properties.cidEncoding;
+          this.vertical = properties.vertical;
+          if (this.vertical) {
+            this.vmetrics = properties.vmetrics;
+            this.defaultVMetrics = properties.defaultVMetrics;
+          }
+          var glyphsUnicodeMap;
+          if (!file || file.isEmpty) {
+            if (file) {
+              // Some bad PDF generators will include empty font files,
+              // attempting to recover by assuming that no file exists.
+              warn('Font file is empty in "' + name + '" (' + this.loadedName + ')');
+            }
+            this.missingFile = true;
+            // The file data is not specified. Trying to fix the font name
+            // to be used with the canvas.font.
+            var fontName = name.replace(/[,_]/g, '-');
+            var stdFontMap = getStdFontMap(), nonStdFontMap = getNonStdFontMap();
+            var isStandardFont = !!stdFontMap[fontName] || !!(nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]);
+            fontName = stdFontMap[fontName] || nonStdFontMap[fontName] || fontName;
+            this.bold = fontName.search(/bold/gi) !== -1;
+            this.italic = fontName.search(/oblique/gi) !== -1 || fontName.search(/italic/gi) !== -1;
+            // Use 'name' instead of 'fontName' here because the original
+            // name ArialBlack for example will be replaced by Helvetica.
+            this.black = name.search(/Black/g) !== -1;
+            // if at least one width is present, remeasure all chars when exists
+            this.remeasure = Object.keys(this.widths).length > 0;
+            if (isStandardFont && type === 'CIDFontType2' && properties.cidEncoding.indexOf('Identity-') === 0) {
+              var GlyphMapForStandardFonts = getGlyphMapForStandardFonts();
+              // Standard fonts might be embedded as CID font without glyph mapping.
+              // Building one based on GlyphMapForStandardFonts.
+              var map = [];
+              for (charCode in GlyphMapForStandardFonts) {
+                map[+charCode] = GlyphMapForStandardFonts[charCode];
+              }
+              if (/ArialBlack/i.test(name)) {
+                var SupplementalGlyphMapForArialBlack = getSupplementalGlyphMapForArialBlack();
+                for (charCode in SupplementalGlyphMapForArialBlack) {
+                  map[+charCode] = SupplementalGlyphMapForArialBlack[charCode];
+                }
+              }
+              var isIdentityUnicode = this.toUnicode instanceof IdentityToUnicodeMap;
+              if (!isIdentityUnicode) {
+                this.toUnicode.forEach(function (charCode, unicodeCharCode) {
+                  map[+charCode] = unicodeCharCode;
+                });
+              }
+              this.toFontChar = map;
+              this.toUnicode = new ToUnicodeMap(map);
+            } else if (/Symbol/i.test(fontName)) {
+              this.toFontChar = buildToFontChar(SymbolSetEncoding, getGlyphsUnicode(), properties.differences);
+            } else if (/Dingbats/i.test(fontName)) {
+              if (/Wingdings/i.test(name)) {
+                warn('Non-embedded Wingdings font, falling back to ZapfDingbats.');
+              }
+              this.toFontChar = buildToFontChar(ZapfDingbatsEncoding, getDingbatsGlyphsUnicode(), properties.differences);
+            } else if (isStandardFont) {
+              this.toFontChar = buildToFontChar(properties.defaultEncoding, getGlyphsUnicode(), properties.differences);
+            } else {
+              glyphsUnicodeMap = getGlyphsUnicode();
+              this.toUnicode.forEach(function (charCode, unicodeCharCode) {
+                if (!this.composite) {
+                  glyphName = properties.differences[charCode] || properties.defaultEncoding[charCode];
+                  unicode = getUnicodeForGlyph(glyphName, glyphsUnicodeMap);
+                  if (unicode !== -1) {
+                    unicodeCharCode = unicode;
+                  }
+                }
+                this.toFontChar[charCode] = unicodeCharCode;
+              }.bind(this));
+            }
+            this.loadedName = fontName.split('-')[0];
+            this.loading = false;
+            this.fontType = getFontType(type, subtype);
+            return;
+          }
+          // Some fonts might use wrong font types for Type1C or CIDFontType0C
+          if (subtype === 'Type1C') {
+            if (type !== 'Type1' && type !== 'MMType1') {
+              // Some TrueType fonts by mistake claim Type1C
+              if (isTrueTypeFile(file)) {
+                subtype = 'TrueType';
+              } else {
+                type = 'Type1';
+              }
+            } else if (isOpenTypeFile(file)) {
+              // Sometimes the type/subtype can be a complete lie (see issue7598.pdf).
+              type = subtype = 'OpenType';
+            }
+          }
+          if (subtype === 'CIDFontType0C' && type !== 'CIDFontType0') {
+            type = 'CIDFontType0';
+          }
+          if (subtype === 'OpenType') {
+            type = 'OpenType';
+          }
+          // Some CIDFontType0C fonts by mistake claim CIDFontType0.
+          if (type === 'CIDFontType0') {
+            if (isType1File(file)) {
+              subtype = 'CIDFontType0';
+            } else if (isOpenTypeFile(file)) {
+              // Sometimes the type/subtype can be a complete lie (see issue6782.pdf).
+              type = subtype = 'OpenType';
+            } else {
+              subtype = 'CIDFontType0C';
+            }
+          }
+          var data;
+          switch (type) {
+          case 'MMType1':
+            info('MMType1 font (' + name + '), falling back to Type1.');
+          case 'Type1':
+          case 'CIDFontType0':
+            this.mimetype = 'font/opentype';
+            var cff = subtype === 'Type1C' || subtype === 'CIDFontType0C' ? new CFFFont(file, properties) : new Type1Font(name, file, properties);
+            adjustWidths(properties);
+            // Wrap the CFF data inside an OTF font file
+            data = this.convert(name, cff, properties);
+            break;
+          case 'OpenType':
+          case 'TrueType':
+          case 'CIDFontType2':
+            this.mimetype = 'font/opentype';
+            // Repair the TrueType file. It is can be damaged in the point of
+            // view of the sanitizer
+            data = this.checkAndRepair(name, file, properties);
+            if (this.isOpenType) {
+              adjustWidths(properties);
+              type = 'OpenType';
+            }
+            break;
+          default:
+            error('Font ' + type + ' is not supported');
+            break;
+          }
+          this.data = data;
+          this.fontType = getFontType(type, subtype);
+          // Transfer some properties again that could change during font conversion
+          this.fontMatrix = properties.fontMatrix;
+          this.widths = properties.widths;
+          this.defaultWidth = properties.defaultWidth;
+          this.toUnicode = properties.toUnicode;
+          this.encoding = properties.baseEncoding;
+          this.seacMap = properties.seacMap;
+          this.loading = true;
+        }
+        Font.getFontID = function () {
+          var ID = 1;
+          return function Font_getFontID() {
+            return String(ID++);
+          };
+        }();
+        function int16(b0, b1) {
+          return (b0 << 8) + b1;
+        }
+        function signedInt16(b0, b1) {
+          var value = (b0 << 8) + b1;
+          return value & 1 << 15 ? value - 0x10000 : value;
+        }
+        function int32(b0, b1, b2, b3) {
+          return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+        }
+        function string16(value) {
+          return String.fromCharCode(value >> 8 & 0xff, value & 0xff);
+        }
+        function safeString16(value) {
+          // clamp value to the 16-bit int range
+          value = value > 0x7FFF ? 0x7FFF : value < -0x8000 ? -0x8000 : value;
+          return String.fromCharCode(value >> 8 & 0xff, value & 0xff);
+        }
+        function isTrueTypeFile(file) {
+          var header = file.peekBytes(4);
+          return readUint32(header, 0) === 0x00010000;
+        }
+        function isOpenTypeFile(file) {
+          var header = file.peekBytes(4);
+          return bytesToString(header) === 'OTTO';
+        }
+        function isType1File(file) {
+          var header = file.peekBytes(2);
+          // All Type1 font programs must begin with the comment '%!' (0x25 + 0x21).
+          if (header[0] === 0x25 && header[1] === 0x21) {
+            return true;
+          }
+          // ... obviously some fonts violate that part of the specification,
+          // please refer to the comment in |Type1Font| below.
+          if (header[0] === 0x80 && header[1] === 0x01) {
+            // pfb file header.
+            return true;
+          }
+          return false;
+        }
+        function buildToFontChar(encoding, glyphsUnicodeMap, differences) {
+          var toFontChar = [], unicode;
+          for (var i = 0, ii = encoding.length; i < ii; i++) {
+            unicode = getUnicodeForGlyph(encoding[i], glyphsUnicodeMap);
+            if (unicode !== -1) {
+              toFontChar[i] = unicode;
+            }
+          }
+          for (var charCode in differences) {
+            unicode = getUnicodeForGlyph(differences[charCode], glyphsUnicodeMap);
+            if (unicode !== -1) {
+              toFontChar[+charCode] = unicode;
+            }
+          }
+          return toFontChar;
+        }
+        /**
+         * Helper function for |adjustMapping|.
+         * @return {boolean}
+         */
+        function isProblematicUnicodeLocation(code) {
+          // Using binary search to find a range start.
+          var i = 0, j = ProblematicCharRanges.length - 1;
+          while (i < j) {
+            var c = i + j + 1 >> 1;
+            if (code < ProblematicCharRanges[c]) {
+              j = c - 1;
+            } else {
+              i = c;
+            }
+          }
+          // Even index means code in problematic range.
+          return !(i & 1);
+        }
+        /**
+         * Rebuilds the char code to glyph ID map by trying to replace the char codes
+         * with their unicode value. It also moves char codes that are in known
+         * problematic locations.
+         * @return {Object} Two properties:
+         * 'toFontChar' - maps original char codes(the value that will be read
+         * from commands such as show text) to the char codes that will be used in the
+         * font that we build
+         * 'charCodeToGlyphId' - maps the new font char codes to glyph ids
+         */
+        function adjustMapping(charCodeToGlyphId, properties) {
+          var toUnicode = properties.toUnicode;
+          var isSymbolic = !!(properties.flags & FontFlags.Symbolic);
+          var isIdentityUnicode = properties.toUnicode instanceof IdentityToUnicodeMap;
+          var newMap = Object.create(null);
+          var toFontChar = [];
+          var usedFontCharCodes = [];
+          var nextAvailableFontCharCode = PRIVATE_USE_OFFSET_START;
+          for (var originalCharCode in charCodeToGlyphId) {
+            originalCharCode |= 0;
+            var glyphId = charCodeToGlyphId[originalCharCode];
+            var fontCharCode = originalCharCode;
+            // First try to map the value to a unicode position if a non identity map
+            // was created.
+            if (!isIdentityUnicode && toUnicode.has(originalCharCode)) {
+              var unicode = toUnicode.get(fontCharCode);
+              // TODO: Try to map ligatures to the correct spot.
+              if (unicode.length === 1) {
+                fontCharCode = unicode.charCodeAt(0);
+              }
+            }
+            // Try to move control characters, special characters and already mapped
+            // characters to the private use area since they will not be drawn by
+            // canvas if left in their current position. Also, move characters if the
+            // font was symbolic and there is only an identity unicode map since the
+            // characters probably aren't in the correct position (fixes an issue
+            // with firefox and thuluthfont).
+            if ((usedFontCharCodes[fontCharCode] !== undefined || isProblematicUnicodeLocation(fontCharCode) || isSymbolic && isIdentityUnicode) && nextAvailableFontCharCode <= PRIVATE_USE_OFFSET_END) {
+              // Room left.
+              // Loop to try and find a free spot in the private use area.
+              do {
+                fontCharCode = nextAvailableFontCharCode++;
+                if (SKIP_PRIVATE_USE_RANGE_F000_TO_F01F && fontCharCode === 0xF000) {
+                  fontCharCode = 0xF020;
+                  nextAvailableFontCharCode = fontCharCode + 1;
+                }
+              } while (usedFontCharCodes[fontCharCode] !== undefined && nextAvailableFontCharCode <= PRIVATE_USE_OFFSET_END);
+            }
+            newMap[fontCharCode] = glyphId;
+            toFontChar[originalCharCode] = fontCharCode;
+            usedFontCharCodes[fontCharCode] = true;
+          }
+          return {
+            toFontChar: toFontChar,
+            charCodeToGlyphId: newMap,
+            nextAvailableFontCharCode: nextAvailableFontCharCode
+          };
+        }
+        function getRanges(glyphs, numGlyphs) {
+          // Array.sort() sorts by characters, not numerically, so convert to an
+          // array of characters.
+          var codes = [];
+          for (var charCode in glyphs) {
+            // Remove an invalid glyph ID mappings to make OTS happy.
+            if (glyphs[charCode] >= numGlyphs) {
+              continue;
+            }
+            codes.push({
+              fontCharCode: charCode | 0,
+              glyphId: glyphs[charCode]
+            });
+          }
+          codes.sort(function fontGetRangesSort(a, b) {
+            return a.fontCharCode - b.fontCharCode;
+          });
+          // Split the sorted codes into ranges.
+          var ranges = [];
+          var length = codes.length;
+          for (var n = 0; n < length;) {
+            var start = codes[n].fontCharCode;
+            var codeIndices = [codes[n].glyphId];
+            ++n;
+            var end = start;
+            while (n < length && end + 1 === codes[n].fontCharCode) {
+              codeIndices.push(codes[n].glyphId);
+              ++end;
+              ++n;
+              if (end === 0xFFFF) {
+                break;
+              }
+            }
+            ranges.push([
+              start,
+              end,
+              codeIndices
+            ]);
+          }
+          return ranges;
+        }
+        function createCmapTable(glyphs, numGlyphs) {
+          var ranges = getRanges(glyphs, numGlyphs);
+          var numTables = ranges[ranges.length - 1][1] > 0xFFFF ? 2 : 1;
+          var cmap = '\x00\x00' + // version
+          string16(numTables) + // numTables
+          '\x00\x03' + // platformID
+          '\x00\x01' + // encodingID
+          string32(4 + numTables * 8);
+          // start of the table record
+          var i, ii, j, jj;
+          for (i = ranges.length - 1; i >= 0; --i) {
+            if (ranges[i][0] <= 0xFFFF) {
+              break;
+            }
+          }
+          var bmpLength = i + 1;
+          if (ranges[i][0] < 0xFFFF && ranges[i][1] === 0xFFFF) {
+            ranges[i][1] = 0xFFFE;
+          }
+          var trailingRangesCount = ranges[i][1] < 0xFFFF ? 1 : 0;
+          var segCount = bmpLength + trailingRangesCount;
+          var searchParams = OpenTypeFileBuilder.getSearchParams(segCount, 2);
+          // Fill up the 4 parallel arrays describing the segments.
+          var startCount = '';
+          var endCount = '';
+          var idDeltas = '';
+          var idRangeOffsets = '';
+          var glyphsIds = '';
+          var bias = 0;
+          var range, start, end, codes;
+          for (i = 0, ii = bmpLength; i < ii; i++) {
+            range = ranges[i];
+            start = range[0];
+            end = range[1];
+            startCount += string16(start);
+            endCount += string16(end);
+            codes = range[2];
+            var contiguous = true;
+            for (j = 1, jj = codes.length; j < jj; ++j) {
+              if (codes[j] !== codes[j - 1] + 1) {
+                contiguous = false;
+                break;
+              }
+            }
+            if (!contiguous) {
+              var offset = (segCount - i) * 2 + bias * 2;
+              bias += end - start + 1;
+              idDeltas += string16(0);
+              idRangeOffsets += string16(offset);
+              for (j = 0, jj = codes.length; j < jj; ++j) {
+                glyphsIds += string16(codes[j]);
+              }
+            } else {
+              var startCode = codes[0];
+              idDeltas += string16(startCode - start & 0xFFFF);
+              idRangeOffsets += string16(0);
+            }
+          }
+          if (trailingRangesCount > 0) {
+            endCount += '\xFF\xFF';
+            startCount += '\xFF\xFF';
+            idDeltas += '\x00\x01';
+            idRangeOffsets += '\x00\x00';
+          }
+          var format314 = '\x00\x00' + // language
+          string16(2 * segCount) + string16(searchParams.range) + string16(searchParams.entry) + string16(searchParams.rangeShift) + endCount + '\x00\x00' + startCount + idDeltas + idRangeOffsets + glyphsIds;
+          var format31012 = '';
+          var header31012 = '';
+          if (numTables > 1) {
+            cmap += '\x00\x03' + // platformID
+            '\x00\x0A' + // encodingID
+            string32(4 + numTables * 8 + 4 + format314.length);
+            // start of the table record
+            format31012 = '';
+            for (i = 0, ii = ranges.length; i < ii; i++) {
+              range = ranges[i];
+              start = range[0];
+              codes = range[2];
+              var code = codes[0];
+              for (j = 1, jj = codes.length; j < jj; ++j) {
+                if (codes[j] !== codes[j - 1] + 1) {
+                  end = range[0] + j - 1;
+                  format31012 += string32(start) + // startCharCode
+                  string32(end) + // endCharCode
+                  string32(code);
+                  // startGlyphID
+                  start = end + 1;
+                  code = codes[j];
+                }
+              }
+              format31012 += string32(start) + // startCharCode
+              string32(range[1]) + // endCharCode
+              string32(code);
+            }
+            // startGlyphID
+            header31012 = '\x00\x0C' + // format
+            '\x00\x00' + // reserved
+            string32(format31012.length + 16) + // length
+            '\x00\x00\x00\x00' + // language
+            string32(format31012.length / 12);
+          }
+          // nGroups
+          return cmap + '\x00\x04' + // format
+          string16(format314.length + 4) + // length
+          format314 + header31012 + format31012;
+        }
+        function validateOS2Table(os2) {
+          var stream = new Stream(os2.data);
+          var version = stream.getUint16();
+          // TODO verify all OS/2 tables fields, but currently we validate only those
+          // that give us issues
+          stream.getBytes(60);
+          // skipping type, misc sizes, panose, unicode ranges
+          var selection = stream.getUint16();
+          if (version < 4 && selection & 0x0300) {
+            return false;
+          }
+          var firstChar = stream.getUint16();
+          var lastChar = stream.getUint16();
+          if (firstChar > lastChar) {
+            return false;
+          }
+          stream.getBytes(6);
+          // skipping sTypoAscender/Descender/LineGap
+          var usWinAscent = stream.getUint16();
+          if (usWinAscent === 0) {
+            // makes font unreadable by windows
+            return false;
+          }
+          // OS/2 appears to be valid, resetting some fields
+          os2.data[8] = os2.data[9] = 0;
+          // IE rejects fonts if fsType != 0
+          return true;
+        }
+        function createOS2Table(properties, charstrings, override) {
+          override = override || {
+            unitsPerEm: 0,
+            yMax: 0,
+            yMin: 0,
+            ascent: 0,
+            descent: 0
+          };
+          var ulUnicodeRange1 = 0;
+          var ulUnicodeRange2 = 0;
+          var ulUnicodeRange3 = 0;
+          var ulUnicodeRange4 = 0;
+          var firstCharIndex = null;
+          var lastCharIndex = 0;
+          if (charstrings) {
+            for (var code in charstrings) {
+              code |= 0;
+              if (firstCharIndex > code || !firstCharIndex) {
+                firstCharIndex = code;
+              }
+              if (lastCharIndex < code) {
+                lastCharIndex = code;
+              }
+              var position = getUnicodeRangeFor(code);
+              if (position < 32) {
+                ulUnicodeRange1 |= 1 << position;
+              } else if (position < 64) {
+                ulUnicodeRange2 |= 1 << position - 32;
+              } else if (position < 96) {
+                ulUnicodeRange3 |= 1 << position - 64;
+              } else if (position < 123) {
+                ulUnicodeRange4 |= 1 << position - 96;
+              } else {
+                error('Unicode ranges Bits > 123 are reserved for internal usage');
+              }
+            }
+          } else {
+            // TODO
+            firstCharIndex = 0;
+            lastCharIndex = 255;
+          }
+          var bbox = properties.bbox || [
+            0,
+            0,
+            0,
+            0
+          ];
+          var unitsPerEm = override.unitsPerEm || 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0];
+          // if the font units differ to the PDF glyph space units
+          // then scale up the values
+          var scale = properties.ascentScaled ? 1.0 : unitsPerEm / PDF_GLYPH_SPACE_UNITS;
+          var typoAscent = override.ascent || Math.round(scale * (properties.ascent || bbox[3]));
+          var typoDescent = override.descent || Math.round(scale * (properties.descent || bbox[1]));
+          if (typoDescent > 0 && properties.descent > 0 && bbox[1] < 0) {
+            typoDescent = -typoDescent;
+          }
+          // fixing incorrect descent
+          var winAscent = override.yMax || typoAscent;
+          var winDescent = -override.yMin || -typoDescent;
+          return '\x00\x03' + // version
+          '\x02\x24' + // xAvgCharWidth
+          '\x01\xF4' + // usWeightClass
+          '\x00\x05' + // usWidthClass
+          '\x00\x00' + // fstype (0 to let the font loads via font-face on IE)
+          '\x02\x8A' + // ySubscriptXSize
+          '\x02\xBB' + // ySubscriptYSize
+          '\x00\x00' + // ySubscriptXOffset
+          '\x00\x8C' + // ySubscriptYOffset
+          '\x02\x8A' + // ySuperScriptXSize
+          '\x02\xBB' + // ySuperScriptYSize
+          '\x00\x00' + // ySuperScriptXOffset
+          '\x01\xDF' + // ySuperScriptYOffset
+          '\x00\x31' + // yStrikeOutSize
+          '\x01\x02' + // yStrikeOutPosition
+          '\x00\x00' + // sFamilyClass
+          '\x00\x00\x06' + String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) + '\x00\x00\x00\x00\x00\x00' + // Panose
+          string32(ulUnicodeRange1) + // ulUnicodeRange1 (Bits 0-31)
+          string32(ulUnicodeRange2) + // ulUnicodeRange2 (Bits 32-63)
+          string32(ulUnicodeRange3) + // ulUnicodeRange3 (Bits 64-95)
+          string32(ulUnicodeRange4) + // ulUnicodeRange4 (Bits 96-127)
+          '\x2A\x32\x31\x2A' + // achVendID
+          string16(properties.italicAngle ? 1 : 0) + // fsSelection
+          string16(firstCharIndex || properties.firstChar) + // usFirstCharIndex
+          string16(lastCharIndex || properties.lastChar) + // usLastCharIndex
+          string16(typoAscent) + // sTypoAscender
+          string16(typoDescent) + // sTypoDescender
+          '\x00\x64' + // sTypoLineGap (7%-10% of the unitsPerEM value)
+          string16(winAscent) + // usWinAscent
+          string16(winDescent) + // usWinDescent
+          '\x00\x00\x00\x00' + // ulCodePageRange1 (Bits 0-31)
+          '\x00\x00\x00\x00' + // ulCodePageRange2 (Bits 32-63)
+          string16(properties.xHeight) + // sxHeight
+          string16(properties.capHeight) + // sCapHeight
+          string16(0) + // usDefaultChar
+          string16(firstCharIndex || properties.firstChar) + // usBreakChar
+          '\x00\x03';
+        }
+        // usMaxContext
+        function createPostTable(properties) {
+          var angle = Math.floor(properties.italicAngle * Math.pow(2, 16));
+          return '\x00\x03\x00\x00' + // Version number
+          string32(angle) + // italicAngle
+          '\x00\x00' + // underlinePosition
+          '\x00\x00' + // underlineThickness
+          string32(properties.fixedPitch) + // isFixedPitch
+          '\x00\x00\x00\x00' + // minMemType42
+          '\x00\x00\x00\x00' + // maxMemType42
+          '\x00\x00\x00\x00' + // minMemType1
+          '\x00\x00\x00\x00';
+        }
+        // maxMemType1
+        function createNameTable(name, proto) {
+          if (!proto) {
+            proto = [
+              [],
+              []
+            ];
+          }
+          // no strings and unicode strings
+          var strings = [
+            proto[0][0] || 'Original licence',
+            // 0.Copyright
+            proto[0][1] || name,
+            // 1.Font family
+            proto[0][2] || 'Unknown',
+            // 2.Font subfamily (font weight)
+            proto[0][3] || 'uniqueID',
+            // 3.Unique ID
+            proto[0][4] || name,
+            // 4.Full font name
+            proto[0][5] || 'Version 0.11',
+            // 5.Version
+            proto[0][6] || '',
+            // 6.Postscript name
+            proto[0][7] || 'Unknown',
+            // 7.Trademark
+            proto[0][8] || 'Unknown',
+            // 8.Manufacturer
+            proto[0][9] || 'Unknown'
+          ];
+          // 9.Designer
+          // Mac want 1-byte per character strings while Windows want
+          // 2-bytes per character, so duplicate the names table
+          var stringsUnicode = [];
+          var i, ii, j, jj, str;
+          for (i = 0, ii = strings.length; i < ii; i++) {
+            str = proto[1][i] || strings[i];
+            var strBufUnicode = [];
+            for (j = 0, jj = str.length; j < jj; j++) {
+              strBufUnicode.push(string16(str.charCodeAt(j)));
+            }
+            stringsUnicode.push(strBufUnicode.join(''));
+          }
+          var names = [
+            strings,
+            stringsUnicode
+          ];
+          var platforms = [
+            '\x00\x01',
+            '\x00\x03'
+          ];
+          var encodings = [
+            '\x00\x00',
+            '\x00\x01'
+          ];
+          var languages = [
+            '\x00\x00',
+            '\x04\x09'
+          ];
+          var namesRecordCount = strings.length * platforms.length;
+          var nameTable = '\x00\x00' + // format
+          string16(namesRecordCount) + // Number of names Record
+          string16(namesRecordCount * 12 + 6);
+          // Storage
+          // Build the name records field
+          var strOffset = 0;
+          for (i = 0, ii = platforms.length; i < ii; i++) {
+            var strs = names[i];
+            for (j = 0, jj = strs.length; j < jj; j++) {
+              str = strs[j];
+              var nameRecord = platforms[i] + // platform ID
+              encodings[i] + // encoding ID
+              languages[i] + // language ID
+              string16(j) + // name ID
+              string16(str.length) + string16(strOffset);
+              nameTable += nameRecord;
+              strOffset += str.length;
+            }
+          }
+          nameTable += strings.join('') + stringsUnicode.join('');
+          return nameTable;
+        }
+        Font.prototype = {
+          name: null,
+          font: null,
+          mimetype: null,
+          encoding: null,
+          get renderer() {
+            var renderer = FontRendererFactory.create(this, SEAC_ANALYSIS_ENABLED);
+            return shadow(this, 'renderer', renderer);
+          },
+          exportData: function Font_exportData() {
+            // TODO remove enumerating of the properties, e.g. hardcode exact names.
+            var data = {};
+            for (var i in this) {
+              if (this.hasOwnProperty(i)) {
+                data[i] = this[i];
+              }
+            }
+            return data;
+          },
+          checkAndRepair: function Font_checkAndRepair(name, font, properties) {
+            function readTableEntry(file) {
+              var tag = bytesToString(file.getBytes(4));
+              var checksum = file.getInt32() >>> 0;
+              var offset = file.getInt32() >>> 0;
+              var length = file.getInt32() >>> 0;
+              // Read the table associated data
+              var previousPosition = file.pos;
+              file.pos = file.start ? file.start : 0;
+              file.skip(offset);
+              var data = file.getBytes(length);
+              file.pos = previousPosition;
+              if (tag === 'head') {
+                // clearing checksum adjustment
+                data[8] = data[9] = data[10] = data[11] = 0;
+                data[17] |= 0x20;
+              }
+              //Set font optimized for cleartype flag
+              return {
+                tag: tag,
+                checksum: checksum,
+                length: length,
+                offset: offset,
+                data: data
+              };
+            }
+            function readOpenTypeHeader(ttf) {
+              return {
+                version: bytesToString(ttf.getBytes(4)),
+                numTables: ttf.getUint16(),
+                searchRange: ttf.getUint16(),
+                entrySelector: ttf.getUint16(),
+                rangeShift: ttf.getUint16()
+              };
+            }
+            /**
+             * Read the appropriate subtable from the cmap according to 9.6.6.4 from
+             * PDF spec
+             */
+            function readCmapTable(cmap, font, isSymbolicFont, hasEncoding) {
+              if (!cmap) {
+                warn('No cmap table available.');
+                return {
+                  platformId: -1,
+                  encodingId: -1,
+                  mappings: [],
+                  hasShortCmap: false
+                };
+              }
+              var segment;
+              var start = (font.start ? font.start : 0) + cmap.offset;
+              font.pos = start;
+              var version = font.getUint16();
+              var numTables = font.getUint16();
+              var potentialTable;
+              var canBreak = false;
+              // There's an order of preference in terms of which cmap subtable to
+              // use:
+              // - non-symbolic fonts the preference is a 3,1 table then a 1,0 table
+              // - symbolic fonts the preference is a 3,0 table then a 1,0 table
+              // The following takes advantage of the fact that the tables are sorted
+              // to work.
+              for (var i = 0; i < numTables; i++) {
+                var platformId = font.getUint16();
+                var encodingId = font.getUint16();
+                var offset = font.getInt32() >>> 0;
+                var useTable = false;
+                if (platformId === 0 && encodingId === 0) {
+                  useTable = true;
+                } else // Continue the loop since there still may be a higher priority
+                // table.
+                if (platformId === 1 && encodingId === 0) {
+                  useTable = true;
+                } else // Continue the loop since there still may be a higher priority
+                // table.
+                if (platformId === 3 && encodingId === 1 && (!isSymbolicFont && hasEncoding || !potentialTable)) {
+                  useTable = true;
+                  if (!isSymbolicFont) {
+                    canBreak = true;
+                  }
+                } else if (isSymbolicFont && platformId === 3 && encodingId === 0) {
+                  useTable = true;
+                  canBreak = true;
+                }
+                if (useTable) {
+                  potentialTable = {
+                    platformId: platformId,
+                    encodingId: encodingId,
+                    offset: offset
+                  };
+                }
+                if (canBreak) {
+                  break;
+                }
+              }
+              if (potentialTable) {
+                font.pos = start + potentialTable.offset;
+              }
+              if (!potentialTable || font.peekByte() === -1) {
+                warn('Could not find a preferred cmap table.');
+                return {
+                  platformId: -1,
+                  encodingId: -1,
+                  mappings: [],
+                  hasShortCmap: false
+                };
+              }
+              var format = font.getUint16();
+              var length = font.getUint16();
+              var language = font.getUint16();
+              var hasShortCmap = false;
+              var mappings = [];
+              var j, glyphId;
+              // TODO(mack): refactor this cmap subtable reading logic out
+              if (format === 0) {
+                for (j = 0; j < 256; j++) {
+                  var index = font.getByte();
+                  if (!index) {
+                    continue;
+                  }
+                  mappings.push({
+                    charCode: j,
+                    glyphId: index
+                  });
+                }
+                hasShortCmap = true;
+              } else if (format === 4) {
+                // re-creating the table in format 4 since the encoding
+                // might be changed
+                var segCount = font.getUint16() >> 1;
+                font.getBytes(6);
+                // skipping range fields
+                var segIndex, segments = [];
+                for (segIndex = 0; segIndex < segCount; segIndex++) {
+                  segments.push({ end: font.getUint16() });
+                }
+                font.getUint16();
+                for (segIndex = 0; segIndex < segCount; segIndex++) {
+                  segments[segIndex].start = font.getUint16();
+                }
+                for (segIndex = 0; segIndex < segCount; segIndex++) {
+                  segments[segIndex].delta = font.getUint16();
+                }
+                var offsetsCount = 0;
+                for (segIndex = 0; segIndex < segCount; segIndex++) {
+                  segment = segments[segIndex];
+                  var rangeOffset = font.getUint16();
+                  if (!rangeOffset) {
+                    segment.offsetIndex = -1;
+                    continue;
+                  }
+                  var offsetIndex = (rangeOffset >> 1) - (segCount - segIndex);
+                  segment.offsetIndex = offsetIndex;
+                  offsetsCount = Math.max(offsetsCount, offsetIndex + segment.end - segment.start + 1);
+                }
+                var offsets = [];
+                for (j = 0; j < offsetsCount; j++) {
+                  offsets.push(font.getUint16());
+                }
+                for (segIndex = 0; segIndex < segCount; segIndex++) {
+                  segment = segments[segIndex];
+                  start = segment.start;
+                  var end = segment.end;
+                  var delta = segment.delta;
+                  offsetIndex = segment.offsetIndex;
+                  for (j = start; j <= end; j++) {
+                    if (j === 0xFFFF) {
+                      continue;
+                    }
+                    glyphId = offsetIndex < 0 ? j : offsets[offsetIndex + j - start];
+                    glyphId = glyphId + delta & 0xFFFF;
+                    if (glyphId === 0) {
+                      continue;
+                    }
+                    mappings.push({
+                      charCode: j,
+                      glyphId: glyphId
+                    });
+                  }
+                }
+              } else if (format === 6) {
+                // Format 6 is a 2-bytes dense mapping, which means the font data
+                // lives glue together even if they are pretty far in the unicode
+                // table. (This looks weird, so I can have missed something), this
+                // works on Linux but seems to fails on Mac so let's rewrite the
+                // cmap table to a 3-1-4 style
+                var firstCode = font.getUint16();
+                var entryCount = font.getUint16();
+                for (j = 0; j < entryCount; j++) {
+                  glyphId = font.getUint16();
+                  var charCode = firstCode + j;
+                  mappings.push({
+                    charCode: charCode,
+                    glyphId: glyphId
+                  });
+                }
+              } else {
+                warn('cmap table has unsupported format: ' + format);
+                return {
+                  platformId: -1,
+                  encodingId: -1,
+                  mappings: [],
+                  hasShortCmap: false
+                };
+              }
+              // removing duplicate entries
+              mappings.sort(function (a, b) {
+                return a.charCode - b.charCode;
+              });
+              for (i = 1; i < mappings.length; i++) {
+                if (mappings[i - 1].charCode === mappings[i].charCode) {
+                  mappings.splice(i, 1);
+                  i--;
+                }
+              }
+              return {
+                platformId: potentialTable.platformId,
+                encodingId: potentialTable.encodingId,
+                mappings: mappings,
+                hasShortCmap: hasShortCmap
+              };
+            }
+            function sanitizeMetrics(font, header, metrics, numGlyphs) {
+              if (!header) {
+                if (metrics) {
+                  metrics.data = null;
+                }
+                return;
+              }
+              font.pos = (font.start ? font.start : 0) + header.offset;
+              font.pos += header.length - 2;
+              var numOfMetrics = font.getUint16();
+              if (numOfMetrics > numGlyphs) {
+                info('The numOfMetrics (' + numOfMetrics + ') should not be ' + 'greater than the numGlyphs (' + numGlyphs + ')');
+                // Reduce numOfMetrics if it is greater than numGlyphs
+                numOfMetrics = numGlyphs;
+                header.data[34] = (numOfMetrics & 0xff00) >> 8;
+                header.data[35] = numOfMetrics & 0x00ff;
+              }
+              var numOfSidebearings = numGlyphs - numOfMetrics;
+              var numMissing = numOfSidebearings - (metrics.length - numOfMetrics * 4 >> 1);
+              if (numMissing > 0) {
+                // For each missing glyph, we set both the width and lsb to 0 (zero).
+                // Since we need to add two properties for each glyph, this explains
+                // the use of |numMissing * 2| when initializing the typed array.
+                var entries = new Uint8Array(metrics.length + numMissing * 2);
+                entries.set(metrics.data);
+                metrics.data = entries;
+              }
+            }
+            function sanitizeGlyph(source, sourceStart, sourceEnd, dest, destStart, hintsValid) {
+              if (sourceEnd - sourceStart <= 12) {
+                // glyph with data less than 12 is invalid one
+                return 0;
+              }
+              var glyf = source.subarray(sourceStart, sourceEnd);
+              var contoursCount = glyf[0] << 8 | glyf[1];
+              if (contoursCount & 0x8000) {
+                // complex glyph, writing as is
+                dest.set(glyf, destStart);
+                return glyf.length;
+              }
+              var i, j = 10, flagsCount = 0;
+              for (i = 0; i < contoursCount; i++) {
+                var endPoint = glyf[j] << 8 | glyf[j + 1];
+                flagsCount = endPoint + 1;
+                j += 2;
+              }
+              // skipping instructions
+              var instructionsStart = j;
+              var instructionsLength = glyf[j] << 8 | glyf[j + 1];
+              j += 2 + instructionsLength;
+              var instructionsEnd = j;
+              // validating flags
+              var coordinatesLength = 0;
+              for (i = 0; i < flagsCount; i++) {
+                var flag = glyf[j++];
+                if (flag & 0xC0) {
+                  // reserved flags must be zero, cleaning up
+                  glyf[j - 1] = flag & 0x3F;
+                }
+                var xyLength = (flag & 2 ? 1 : flag & 16 ? 0 : 2) + (flag & 4 ? 1 : flag & 32 ? 0 : 2);
+                coordinatesLength += xyLength;
+                if (flag & 8) {
+                  var repeat = glyf[j++];
+                  i += repeat;
+                  coordinatesLength += repeat * xyLength;
+                }
+              }
+              // glyph without coordinates will be rejected
+              if (coordinatesLength === 0) {
+                return 0;
+              }
+              var glyphDataLength = j + coordinatesLength;
+              if (glyphDataLength > glyf.length) {
+                // not enough data for coordinates
+                return 0;
+              }
+              if (!hintsValid && instructionsLength > 0) {
+                dest.set(glyf.subarray(0, instructionsStart), destStart);
+                dest.set([
+                  0,
+                  0
+                ], destStart + instructionsStart);
+                dest.set(glyf.subarray(instructionsEnd, glyphDataLength), destStart + instructionsStart + 2);
+                glyphDataLength -= instructionsLength;
+                if (glyf.length - glyphDataLength > 3) {
+                  glyphDataLength = glyphDataLength + 3 & ~3;
+                }
+                return glyphDataLength;
+              }
+              if (glyf.length - glyphDataLength > 3) {
+                // truncating and aligning to 4 bytes the long glyph data
+                glyphDataLength = glyphDataLength + 3 & ~3;
+                dest.set(glyf.subarray(0, glyphDataLength), destStart);
+                return glyphDataLength;
+              }
+              // glyph data is fine
+              dest.set(glyf, destStart);
+              return glyf.length;
+            }
+            function sanitizeHead(head, numGlyphs, locaLength) {
+              var data = head.data;
+              // Validate version:
+              // Should always be 0x00010000
+              var version = int32(data[0], data[1], data[2], data[3]);
+              if (version >> 16 !== 1) {
+                info('Attempting to fix invalid version in head table: ' + version);
+                data[0] = 0;
+                data[1] = 1;
+                data[2] = 0;
+                data[3] = 0;
+              }
+              var indexToLocFormat = int16(data[50], data[51]);
+              if (indexToLocFormat < 0 || indexToLocFormat > 1) {
+                info('Attempting to fix invalid indexToLocFormat in head table: ' + indexToLocFormat);
+                // The value of indexToLocFormat should be 0 if the loca table
+                // consists of short offsets, and should be 1 if the loca table
+                // consists of long offsets.
+                //
+                // The number of entries in the loca table should be numGlyphs + 1.
+                //
+                // Using this information, we can work backwards to deduce if the
+                // size of each offset in the loca table, and thus figure out the
+                // appropriate value for indexToLocFormat.
+                var numGlyphsPlusOne = numGlyphs + 1;
+                if (locaLength === numGlyphsPlusOne << 1) {
+                  // 0x0000 indicates the loca table consists of short offsets
+                  data[50] = 0;
+                  data[51] = 0;
+                } else if (locaLength === numGlyphsPlusOne << 2) {
+                  // 0x0001 indicates the loca table consists of long offsets
+                  data[50] = 0;
+                  data[51] = 1;
+                } else {
+                  warn('Could not fix indexToLocFormat: ' + indexToLocFormat);
+                }
+              }
+            }
+            function sanitizeGlyphLocations(loca, glyf, numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry) {
+              var itemSize, itemDecode, itemEncode;
+              if (isGlyphLocationsLong) {
+                itemSize = 4;
+                itemDecode = function fontItemDecodeLong(data, offset) {
+                  return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
+                };
+                itemEncode = function fontItemEncodeLong(data, offset, value) {
+                  data[offset] = value >>> 24 & 0xFF;
+                  data[offset + 1] = value >> 16 & 0xFF;
+                  data[offset + 2] = value >> 8 & 0xFF;
+                  data[offset + 3] = value & 0xFF;
+                };
+              } else {
+                itemSize = 2;
+                itemDecode = function fontItemDecode(data, offset) {
+                  return data[offset] << 9 | data[offset + 1] << 1;
+                };
+                itemEncode = function fontItemEncode(data, offset, value) {
+                  data[offset] = value >> 9 & 0xFF;
+                  data[offset + 1] = value >> 1 & 0xFF;
+                };
+              }
+              var locaData = loca.data;
+              var locaDataSize = itemSize * (1 + numGlyphs);
+              // is loca.data too short or long?
+              if (locaData.length !== locaDataSize) {
+                locaData = new Uint8Array(locaDataSize);
+                locaData.set(loca.data.subarray(0, locaDataSize));
+                loca.data = locaData;
+              }
+              // removing the invalid glyphs
+              var oldGlyfData = glyf.data;
+              var oldGlyfDataLength = oldGlyfData.length;
+              var newGlyfData = new Uint8Array(oldGlyfDataLength);
+              var startOffset = itemDecode(locaData, 0);
+              var writeOffset = 0;
+              var missingGlyphData = Object.create(null);
+              itemEncode(locaData, 0, writeOffset);
+              var i, j;
+              for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {
+                var endOffset = itemDecode(locaData, j);
+                if (endOffset > oldGlyfDataLength && (oldGlyfDataLength + 3 & ~3) === endOffset) {
+                  // Aspose breaks fonts by aligning the glyphs to the qword, but not
+                  // the glyf table size, which makes last glyph out of range.
+                  endOffset = oldGlyfDataLength;
+                }
+                if (endOffset > oldGlyfDataLength) {
+                  // glyph end offset points outside glyf data, rejecting the glyph
+                  itemEncode(locaData, j, writeOffset);
+                  startOffset = endOffset;
+                  continue;
+                }
+                if (startOffset === endOffset) {
+                  missingGlyphData[i] = true;
+                }
+                var newLength = sanitizeGlyph(oldGlyfData, startOffset, endOffset, newGlyfData, writeOffset, hintsValid);
+                writeOffset += newLength;
+                itemEncode(locaData, j, writeOffset);
+                startOffset = endOffset;
+              }
+              if (writeOffset === 0) {
+                // glyf table cannot be empty -- redoing the glyf and loca tables
+                // to have single glyph with one point
+                var simpleGlyph = new Uint8Array([
+                  0,
+                  1,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  49,
+                  0
+                ]);
+                for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {
+                  itemEncode(locaData, j, simpleGlyph.length);
+                }
+                glyf.data = simpleGlyph;
+                return missingGlyphData;
+              }
+              if (dupFirstEntry) {
+                var firstEntryLength = itemDecode(locaData, itemSize);
+                if (newGlyfData.length > firstEntryLength + writeOffset) {
+                  glyf.data = newGlyfData.subarray(0, firstEntryLength + writeOffset);
+                } else {
+                  glyf.data = new Uint8Array(firstEntryLength + writeOffset);
+                  glyf.data.set(newGlyfData.subarray(0, writeOffset));
+                }
+                glyf.data.set(newGlyfData.subarray(0, firstEntryLength), writeOffset);
+                itemEncode(loca.data, locaData.length - itemSize, writeOffset + firstEntryLength);
+              } else {
+                glyf.data = newGlyfData.subarray(0, writeOffset);
+              }
+              return missingGlyphData;
+            }
+            function readPostScriptTable(post, properties, maxpNumGlyphs) {
+              var start = (font.start ? font.start : 0) + post.offset;
+              font.pos = start;
+              var length = post.length, end = start + length;
+              var version = font.getInt32();
+              // skip rest to the tables
+              font.getBytes(28);
+              var glyphNames;
+              var valid = true;
+              var i;
+              switch (version) {
+              case 0x00010000:
+                glyphNames = MacStandardGlyphOrdering;
+                break;
+              case 0x00020000:
+                var numGlyphs = font.getUint16();
+                if (numGlyphs !== maxpNumGlyphs) {
+                  valid = false;
+                  break;
+                }
+                var glyphNameIndexes = [];
+                for (i = 0; i < numGlyphs; ++i) {
+                  var index = font.getUint16();
+                  if (index >= 32768) {
+                    valid = false;
+                    break;
+                  }
+                  glyphNameIndexes.push(index);
+                }
+                if (!valid) {
+                  break;
+                }
+                var customNames = [];
+                var strBuf = [];
+                while (font.pos < end) {
+                  var stringLength = font.getByte();
+                  strBuf.length = stringLength;
+                  for (i = 0; i < stringLength; ++i) {
+                    strBuf[i] = String.fromCharCode(font.getByte());
+                  }
+                  customNames.push(strBuf.join(''));
+                }
+                glyphNames = [];
+                for (i = 0; i < numGlyphs; ++i) {
+                  var j = glyphNameIndexes[i];
+                  if (j < 258) {
+                    glyphNames.push(MacStandardGlyphOrdering[j]);
+                    continue;
+                  }
+                  glyphNames.push(customNames[j - 258]);
+                }
+                break;
+              case 0x00030000:
+                break;
+              default:
+                warn('Unknown/unsupported post table version ' + version);
+                valid = false;
+                if (properties.defaultEncoding) {
+                  glyphNames = properties.defaultEncoding;
+                }
+                break;
+              }
+              properties.glyphNames = glyphNames;
+              return valid;
+            }
+            function readNameTable(nameTable) {
+              var start = (font.start ? font.start : 0) + nameTable.offset;
+              font.pos = start;
+              var names = [
+                [],
+                []
+              ];
+              var length = nameTable.length, end = start + length;
+              var format = font.getUint16();
+              var FORMAT_0_HEADER_LENGTH = 6;
+              if (format !== 0 || length < FORMAT_0_HEADER_LENGTH) {
+                // unsupported name table format or table "too" small
+                return names;
+              }
+              var numRecords = font.getUint16();
+              var stringsStart = font.getUint16();
+              var records = [];
+              var NAME_RECORD_LENGTH = 12;
+              var i, ii;
+              for (i = 0; i < numRecords && font.pos + NAME_RECORD_LENGTH <= end; i++) {
+                var r = {
+                  platform: font.getUint16(),
+                  encoding: font.getUint16(),
+                  language: font.getUint16(),
+                  name: font.getUint16(),
+                  length: font.getUint16(),
+                  offset: font.getUint16()
+                };
+                // using only Macintosh and Windows platform/encoding names
+                if (r.platform === 1 && r.encoding === 0 && r.language === 0 || r.platform === 3 && r.encoding === 1 && r.language === 0x409) {
+                  records.push(r);
+                }
+              }
+              for (i = 0, ii = records.length; i < ii; i++) {
+                var record = records[i];
+                if (record.length <= 0) {
+                  continue;
+                }
+                // Nothing to process, ignoring.
+                var pos = start + stringsStart + record.offset;
+                if (pos + record.length > end) {
+                  continue;
+                }
+                // outside of name table, ignoring
+                font.pos = pos;
+                var nameIndex = record.name;
+                if (record.encoding) {
+                  // unicode
+                  var str = '';
+                  for (var j = 0, jj = record.length; j < jj; j += 2) {
+                    str += String.fromCharCode(font.getUint16());
+                  }
+                  names[1][nameIndex] = str;
+                } else {
+                  names[0][nameIndex] = bytesToString(font.getBytes(record.length));
+                }
+              }
+              return names;
+            }
+            var TTOpsStackDeltas = [
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              -2,
+              -2,
+              -2,
+              -2,
+              0,
+              0,
+              -2,
+              -5,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              0,
+              0,
+              -1,
+              0,
+              -1,
+              -1,
+              -1,
+              -1,
+              1,
+              -1,
+              -999,
+              0,
+              1,
+              0,
+              -1,
+              -2,
+              0,
+              -1,
+              -2,
+              -1,
+              -1,
+              0,
+              -1,
+              -1,
+              0,
+              0,
+              -999,
+              -999,
+              -1,
+              -1,
+              -1,
+              -1,
+              -2,
+              -999,
+              -2,
+              -2,
+              -999,
+              0,
+              -2,
+              -2,
+              0,
+              0,
+              -2,
+              0,
+              -2,
+              0,
+              0,
+              0,
+              -2,
+              -1,
+              -1,
+              1,
+              1,
+              0,
+              0,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              0,
+              0,
+              -1,
+              0,
+              -1,
+              -1,
+              0,
+              -999,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              -1,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              0,
+              -2,
+              -999,
+              -999,
+              -999,
+              -999,
+              -999,
+              -1,
+              -1,
+              -2,
+              -2,
+              0,
+              0,
+              0,
+              0,
+              -1,
+              -1,
+              -999,
+              -2,
+              -2,
+              0,
+              0,
+              -1,
+              -2,
+              -2,
+              0,
+              0,
+              0,
+              -1,
+              -1,
+              -1,
+              -2
+            ];
+            // 0xC0-DF == -1 and 0xE0-FF == -2
+            function sanitizeTTProgram(table, ttContext) {
+              var data = table.data;
+              var i = 0, j, n, b, funcId, pc, lastEndf = 0, lastDeff = 0;
+              var stack = [];
+              var callstack = [];
+              var functionsCalled = [];
+              var tooComplexToFollowFunctions = ttContext.tooComplexToFollowFunctions;
+              var inFDEF = false, ifLevel = 0, inELSE = 0;
+              for (var ii = data.length; i < ii;) {
+                var op = data[i++];
+                // The TrueType instruction set docs can be found at
+                // https://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html
+                if (op === 0x40) {
+                  // NPUSHB - pushes n bytes
+                  n = data[i++];
+                  if (inFDEF || inELSE) {
+                    i += n;
+                  } else {
+                    for (j = 0; j < n; j++) {
+                      stack.push(data[i++]);
+                    }
+                  }
+                } else if (op === 0x41) {
+                  // NPUSHW - pushes n words
+                  n = data[i++];
+                  if (inFDEF || inELSE) {
+                    i += n * 2;
+                  } else {
+                    for (j = 0; j < n; j++) {
+                      b = data[i++];
+                      stack.push(b << 8 | data[i++]);
+                    }
+                  }
+                } else if ((op & 0xF8) === 0xB0) {
+                  // PUSHB - pushes bytes
+                  n = op - 0xB0 + 1;
+                  if (inFDEF || inELSE) {
+                    i += n;
+                  } else {
+                    for (j = 0; j < n; j++) {
+                      stack.push(data[i++]);
+                    }
+                  }
+                } else if ((op & 0xF8) === 0xB8) {
+                  // PUSHW - pushes words
+                  n = op - 0xB8 + 1;
+                  if (inFDEF || inELSE) {
+                    i += n * 2;
+                  } else {
+                    for (j = 0; j < n; j++) {
+                      b = data[i++];
+                      stack.push(b << 8 | data[i++]);
+                    }
+                  }
+                } else if (op === 0x2B && !tooComplexToFollowFunctions) {
+                  // CALL
+                  if (!inFDEF && !inELSE) {
+                    // collecting inforamtion about which functions are used
+                    funcId = stack[stack.length - 1];
+                    ttContext.functionsUsed[funcId] = true;
+                    if (funcId in ttContext.functionsStackDeltas) {
+                      stack.length += ttContext.functionsStackDeltas[funcId];
+                    } else if (funcId in ttContext.functionsDefined && functionsCalled.indexOf(funcId) < 0) {
+                      callstack.push({
+                        data: data,
+                        i: i,
+                        stackTop: stack.length - 1
+                      });
+                      functionsCalled.push(funcId);
+                      pc = ttContext.functionsDefined[funcId];
+                      if (!pc) {
+                        warn('TT: CALL non-existent function');
+                        ttContext.hintsValid = false;
+                        return;
+                      }
+                      data = pc.data;
+                      i = pc.i;
+                    }
+                  }
+                } else if (op === 0x2C && !tooComplexToFollowFunctions) {
+                  // FDEF
+                  if (inFDEF || inELSE) {
+                    warn('TT: nested FDEFs not allowed');
+                    tooComplexToFollowFunctions = true;
+                  }
+                  inFDEF = true;
+                  // collecting inforamtion about which functions are defined
+                  lastDeff = i;
+                  funcId = stack.pop();
+                  ttContext.functionsDefined[funcId] = {
+                    data: data,
+                    i: i
+                  };
+                } else if (op === 0x2D) {
+                  // ENDF - end of function
+                  if (inFDEF) {
+                    inFDEF = false;
+                    lastEndf = i;
+                  } else {
+                    pc = callstack.pop();
+                    if (!pc) {
+                      warn('TT: ENDF bad stack');
+                      ttContext.hintsValid = false;
+                      return;
+                    }
+                    funcId = functionsCalled.pop();
+                    data = pc.data;
+                    i = pc.i;
+                    ttContext.functionsStackDeltas[funcId] = stack.length - pc.stackTop;
+                  }
+                } else if (op === 0x89) {
+                  // IDEF - instruction definition
+                  if (inFDEF || inELSE) {
+                    warn('TT: nested IDEFs not allowed');
+                    tooComplexToFollowFunctions = true;
+                  }
+                  inFDEF = true;
+                  // recording it as a function to track ENDF
+                  lastDeff = i;
+                } else if (op === 0x58) {
+                  // IF
+                  ++ifLevel;
+                } else if (op === 0x1B) {
+                  // ELSE
+                  inELSE = ifLevel;
+                } else if (op === 0x59) {
+                  // EIF
+                  if (inELSE === ifLevel) {
+                    inELSE = 0;
+                  }
+                  --ifLevel;
+                } else if (op === 0x1C) {
+                  // JMPR
+                  if (!inFDEF && !inELSE) {
+                    var offset = stack[stack.length - 1];
+                    // only jumping forward to prevent infinite loop
+                    if (offset > 0) {
+                      i += offset - 1;
+                    }
+                  }
+                }
+                // Adjusting stack not extactly, but just enough to get function id
+                if (!inFDEF && !inELSE) {
+                  var stackDelta = op <= 0x8E ? TTOpsStackDeltas[op] : op >= 0xC0 && op <= 0xDF ? -1 : op >= 0xE0 ? -2 : 0;
+                  if (op >= 0x71 && op <= 0x75) {
+                    n = stack.pop();
+                    if (n === n) {
+                      stackDelta = -n * 2;
+                    }
+                  }
+                  while (stackDelta < 0 && stack.length > 0) {
+                    stack.pop();
+                    stackDelta++;
+                  }
+                  while (stackDelta > 0) {
+                    stack.push(NaN);
+                    // pushing any number into stack
+                    stackDelta--;
+                  }
+                }
+              }
+              ttContext.tooComplexToFollowFunctions = tooComplexToFollowFunctions;
+              var content = [data];
+              if (i > data.length) {
+                content.push(new Uint8Array(i - data.length));
+              }
+              if (lastDeff > lastEndf) {
+                warn('TT: complementing a missing function tail');
+                // new function definition started, but not finished
+                // complete function by [CLEAR, ENDF]
+                content.push(new Uint8Array([
+                  0x22,
+                  0x2D
+                ]));
+              }
+              foldTTTable(table, content);
+            }
+            function checkInvalidFunctions(ttContext, maxFunctionDefs) {
+              if (ttContext.tooComplexToFollowFunctions) {
+                return;
+              }
+              if (ttContext.functionsDefined.length > maxFunctionDefs) {
+                warn('TT: more functions defined than expected');
+                ttContext.hintsValid = false;
+                return;
+              }
+              for (var j = 0, jj = ttContext.functionsUsed.length; j < jj; j++) {
+                if (j > maxFunctionDefs) {
+                  warn('TT: invalid function id: ' + j);
+                  ttContext.hintsValid = false;
+                  return;
+                }
+                if (ttContext.functionsUsed[j] && !ttContext.functionsDefined[j]) {
+                  warn('TT: undefined function: ' + j);
+                  ttContext.hintsValid = false;
+                  return;
+                }
+              }
+            }
+            function foldTTTable(table, content) {
+              if (content.length > 1) {
+                // concatenating the content items
+                var newLength = 0;
+                var j, jj;
+                for (j = 0, jj = content.length; j < jj; j++) {
+                  newLength += content[j].length;
+                }
+                newLength = newLength + 3 & ~3;
+                var result = new Uint8Array(newLength);
+                var pos = 0;
+                for (j = 0, jj = content.length; j < jj; j++) {
+                  result.set(content[j], pos);
+                  pos += content[j].length;
+                }
+                table.data = result;
+                table.length = newLength;
+              }
+            }
+            function sanitizeTTPrograms(fpgm, prep, cvt, maxFunctionDefs) {
+              var ttContext = {
+                functionsDefined: [],
+                functionsUsed: [],
+                functionsStackDeltas: [],
+                tooComplexToFollowFunctions: false,
+                hintsValid: true
+              };
+              if (fpgm) {
+                sanitizeTTProgram(fpgm, ttContext);
+              }
+              if (prep) {
+                sanitizeTTProgram(prep, ttContext);
+              }
+              if (fpgm) {
+                checkInvalidFunctions(ttContext, maxFunctionDefs);
+              }
+              if (cvt && cvt.length & 1) {
+                var cvtData = new Uint8Array(cvt.length + 1);
+                cvtData.set(cvt.data);
+                cvt.data = cvtData;
+              }
+              return ttContext.hintsValid;
+            }
+            // The following steps modify the original font data, making copy
+            font = new Stream(new Uint8Array(font.getBytes()));
+            var VALID_TABLES = [
+              'OS/2',
+              'cmap',
+              'head',
+              'hhea',
+              'hmtx',
+              'maxp',
+              'name',
+              'post',
+              'loca',
+              'glyf',
+              'fpgm',
+              'prep',
+              'cvt ',
+              'CFF '
+            ];
+            var header = readOpenTypeHeader(font);
+            var numTables = header.numTables;
+            var cff, cffFile;
+            var tables = Object.create(null);
+            tables['OS/2'] = null;
+            tables['cmap'] = null;
+            tables['head'] = null;
+            tables['hhea'] = null;
+            tables['hmtx'] = null;
+            tables['maxp'] = null;
+            tables['name'] = null;
+            tables['post'] = null;
+            var table;
+            for (var i = 0; i < numTables; i++) {
+              table = readTableEntry(font);
+              if (VALID_TABLES.indexOf(table.tag) < 0) {
+                continue;
+              }
+              // skipping table if it's not a required or optional table
+              if (table.length === 0) {
+                continue;
+              }
+              // skipping empty tables
+              tables[table.tag] = table;
+            }
+            var isTrueType = !tables['CFF '];
+            if (!isTrueType) {
+              // OpenType font
+              if (header.version === 'OTTO' && properties.type !== 'CIDFontType2' || !tables['head'] || !tables['hhea'] || !tables['maxp'] || !tables['post']) {
+                // no major tables: throwing everything at CFFFont
+                cffFile = new Stream(tables['CFF '].data);
+                cff = new CFFFont(cffFile, properties);
+                adjustWidths(properties);
+                return this.convert(name, cff, properties);
+              }
+              delete tables['glyf'];
+              delete tables['loca'];
+              delete tables['fpgm'];
+              delete tables['prep'];
+              delete tables['cvt '];
+              this.isOpenType = true;
+            } else {
+              if (!tables['loca']) {
+                error('Required "loca" table is not found');
+              }
+              if (!tables['glyf']) {
+                warn('Required "glyf" table is not found -- trying to recover.');
+                // Note: We use `sanitizeGlyphLocations` to add dummy glyf data below.
+                tables['glyf'] = {
+                  tag: 'glyf',
+                  data: new Uint8Array(0)
+                };
+              }
+              this.isOpenType = false;
+            }
+            if (!tables['maxp']) {
+              error('Required "maxp" table is not found');
+            }
+            font.pos = (font.start || 0) + tables['maxp'].offset;
+            var version = font.getInt32();
+            var numGlyphs = font.getUint16();
+            var maxFunctionDefs = 0;
+            if (version >= 0x00010000 && tables['maxp'].length >= 22) {
+              // maxZones can be invalid
+              font.pos += 8;
+              var maxZones = font.getUint16();
+              if (maxZones > 2) {
+                // reset to 2 if font has invalid maxZones
+                tables['maxp'].data[14] = 0;
+                tables['maxp'].data[15] = 2;
+              }
+              font.pos += 4;
+              maxFunctionDefs = font.getUint16();
+            }
+            var dupFirstEntry = false;
+            if (properties.type === 'CIDFontType2' && properties.toUnicode && properties.toUnicode.get(0) > '\u0000') {
+              // oracle's defect (see 3427), duplicating first entry
+              dupFirstEntry = true;
+              numGlyphs++;
+              tables['maxp'].data[4] = numGlyphs >> 8;
+              tables['maxp'].data[5] = numGlyphs & 255;
+            }
+            var hintsValid = sanitizeTTPrograms(tables['fpgm'], tables['prep'], tables['cvt '], maxFunctionDefs);
+            if (!hintsValid) {
+              delete tables['fpgm'];
+              delete tables['prep'];
+              delete tables['cvt '];
+            }
+            // Ensure the hmtx table contains the advance width and
+            // sidebearings information for numGlyphs in the maxp table
+            sanitizeMetrics(font, tables['hhea'], tables['hmtx'], numGlyphs);
+            if (!tables['head']) {
+              error('Required "head" table is not found');
+            }
+            sanitizeHead(tables['head'], numGlyphs, isTrueType ? tables['loca'].length : 0);
+            var missingGlyphs = Object.create(null);
+            if (isTrueType) {
+              var isGlyphLocationsLong = int16(tables['head'].data[50], tables['head'].data[51]);
+              missingGlyphs = sanitizeGlyphLocations(tables['loca'], tables['glyf'], numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry);
+            }
+            if (!tables['hhea']) {
+              error('Required "hhea" table is not found');
+            }
+            // Sanitizer reduces the glyph advanceWidth to the maxAdvanceWidth
+            // Sometimes it's 0. That needs to be fixed
+            if (tables['hhea'].data[10] === 0 && tables['hhea'].data[11] === 0) {
+              tables['hhea'].data[10] = 0xFF;
+              tables['hhea'].data[11] = 0xFF;
+            }
+            // Extract some more font properties from the OpenType head and
+            // hhea tables; yMin and descent value are always negative.
+            var metricsOverride = {
+              unitsPerEm: int16(tables['head'].data[18], tables['head'].data[19]),
+              yMax: int16(tables['head'].data[42], tables['head'].data[43]),
+              yMin: signedInt16(tables['head'].data[38], tables['head'].data[39]),
+              ascent: int16(tables['hhea'].data[4], tables['hhea'].data[5]),
+              descent: signedInt16(tables['hhea'].data[6], tables['hhea'].data[7])
+            };
+            // PDF FontDescriptor metrics lie -- using data from actual font.
+            this.ascent = metricsOverride.ascent / metricsOverride.unitsPerEm;
+            this.descent = metricsOverride.descent / metricsOverride.unitsPerEm;
+            // The 'post' table has glyphs names.
+            if (tables['post']) {
+              var valid = readPostScriptTable(tables['post'], properties, numGlyphs);
+              if (!valid) {
+                tables['post'] = null;
+              }
+            }
+            var charCodeToGlyphId = [], charCode;
+            var toUnicode = properties.toUnicode, widths = properties.widths;
+            var skipToUnicode = toUnicode instanceof IdentityToUnicodeMap || toUnicode.length === 0x10000;
+            // Helper function to try to skip mapping of empty glyphs.
+            // Note: In some cases, just relying on the glyph data doesn't work,
+            //       hence we also use a few heuristics to fix various PDF files.
+            function hasGlyph(glyphId, charCode, widthCode) {
+              if (!missingGlyphs[glyphId]) {
+                return true;
+              }
+              if (!skipToUnicode && charCode >= 0 && toUnicode.has(charCode)) {
+                return true;
+              }
+              if (widths && widthCode >= 0 && isNum(widths[widthCode])) {
+                return true;
+              }
+              return false;
+            }
+            if (properties.type === 'CIDFontType2') {
+              var cidToGidMap = properties.cidToGidMap || [];
+              var isCidToGidMapEmpty = cidToGidMap.length === 0;
+              properties.cMap.forEach(function (charCode, cid) {
+                assert(cid <= 0xffff, 'Max size of CID is 65,535');
+                var glyphId = -1;
+                if (isCidToGidMapEmpty) {
+                  glyphId = cid;
+                } else if (cidToGidMap[cid] !== undefined) {
+                  glyphId = cidToGidMap[cid];
+                }
+                if (glyphId >= 0 && glyphId < numGlyphs && hasGlyph(glyphId, charCode, cid)) {
+                  charCodeToGlyphId[charCode] = glyphId;
+                }
+              });
+              if (dupFirstEntry && (isCidToGidMapEmpty || !charCodeToGlyphId[0])) {
+                // We don't duplicate the first entry in the `charCodeToGlyphId` map
+                // if the font has a `CIDToGIDMap` which has already mapped the first
+                // entry to a non-zero `glyphId` (fixes issue7544.pdf).
+                charCodeToGlyphId[0] = numGlyphs - 1;
+              }
+            } else {
+              // Most of the following logic in this code branch is based on the
+              // 9.6.6.4 of the PDF spec.
+              var cmapTable = readCmapTable(tables['cmap'], font, this.isSymbolicFont, properties.hasEncoding);
+              var cmapPlatformId = cmapTable.platformId;
+              var cmapEncodingId = cmapTable.encodingId;
+              var cmapMappings = cmapTable.mappings;
+              var cmapMappingsLength = cmapMappings.length;
+              // The spec seems to imply that if the font is symbolic the encoding
+              // should be ignored, this doesn't appear to work for 'preistabelle.pdf'
+              // where the the font is symbolic and it has an encoding.
+              if (properties.hasEncoding && (cmapPlatformId === 3 && cmapEncodingId === 1 || cmapPlatformId === 1 && cmapEncodingId === 0) || cmapPlatformId === -1 && cmapEncodingId === -1 && // Temporary hack
+                !!getEncoding(properties.baseEncodingName)) {
+                // Temporary hack
+                // When no preferred cmap table was found and |baseEncodingName| is
+                // one of the predefined encodings, we seem to obtain a better
+                // |charCodeToGlyphId| map from the code below (fixes bug 1057544).
+                // TODO: Note that this is a hack which should be removed as soon as
+                //       we have proper support for more exotic cmap tables.
+                var baseEncoding = [];
+                if (properties.baseEncodingName === 'MacRomanEncoding' || properties.baseEncodingName === 'WinAnsiEncoding') {
+                  baseEncoding = getEncoding(properties.baseEncodingName);
+                }
+                var glyphsUnicodeMap = getGlyphsUnicode();
+                for (charCode = 0; charCode < 256; charCode++) {
+                  var glyphName, standardGlyphName;
+                  if (this.differences && charCode in this.differences) {
+                    glyphName = this.differences[charCode];
+                  } else if (charCode in baseEncoding && baseEncoding[charCode] !== '') {
+                    glyphName = baseEncoding[charCode];
+                  } else {
+                    glyphName = StandardEncoding[charCode];
+                  }
+                  if (!glyphName) {
+                    continue;
+                  }
+                  // Ensure that non-standard glyph names are resolved to valid ones.
+                  standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap);
+                  var unicodeOrCharCode, isUnicode = false;
+                  if (cmapPlatformId === 3 && cmapEncodingId === 1) {
+                    unicodeOrCharCode = glyphsUnicodeMap[standardGlyphName];
+                    isUnicode = true;
+                  } else if (cmapPlatformId === 1 && cmapEncodingId === 0) {
+                    // TODO: the encoding needs to be updated with mac os table.
+                    unicodeOrCharCode = MacRomanEncoding.indexOf(standardGlyphName);
+                  }
+                  var found = false;
+                  for (i = 0; i < cmapMappingsLength; ++i) {
+                    if (cmapMappings[i].charCode !== unicodeOrCharCode) {
+                      continue;
+                    }
+                    var code = isUnicode ? charCode : unicodeOrCharCode;
+                    if (hasGlyph(cmapMappings[i].glyphId, code, -1)) {
+                      charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
+                      found = true;
+                      break;
+                    }
+                  }
+                  if (!found && properties.glyphNames) {
+                    // Try to map using the post table.
+                    var glyphId = properties.glyphNames.indexOf(glyphName);
+                    // The post table ought to use the same kind of glyph names as the
+                    // `differences` array, but check the standard ones as a fallback.
+                    if (glyphId === -1 && standardGlyphName !== glyphName) {
+                      glyphId = properties.glyphNames.indexOf(standardGlyphName);
+                    }
+                    if (glyphId > 0 && hasGlyph(glyphId, -1, -1)) {
+                      charCodeToGlyphId[charCode] = glyphId;
+                      found = true;
+                    }
+                  }
+                  if (!found) {
+                    charCodeToGlyphId[charCode] = 0;
+                  }
+                }
+              } else // notdef
+              if (cmapPlatformId === 0 && cmapEncodingId === 0) {
+                // Default Unicode semantics, use the charcodes as is.
+                for (i = 0; i < cmapMappingsLength; ++i) {
+                  charCodeToGlyphId[cmapMappings[i].charCode] = cmapMappings[i].glyphId;
+                }
+              } else {
+                // For (3, 0) cmap tables:
+                // The charcode key being stored in charCodeToGlyphId is the lower
+                // byte of the two-byte charcodes of the cmap table since according to
+                // the spec: 'each byte from the string shall be prepended with the
+                // high byte of the range [of charcodes in the cmap table], to form
+                // a two-byte character, which shall be used to select the
+                // associated glyph description from the subtable'.
+                //
+                // For (1, 0) cmap tables:
+                // 'single bytes from the string shall be used to look up the
+                // associated glyph descriptions from the subtable'. This means
+                // charcodes in the cmap will be single bytes, so no-op since
+                // glyph.charCode & 0xFF === glyph.charCode
+                for (i = 0; i < cmapMappingsLength; ++i) {
+                  charCode = cmapMappings[i].charCode & 0xFF;
+                  charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
+                }
+              }
+            }
+            if (charCodeToGlyphId.length === 0) {
+              // defines at least one glyph
+              charCodeToGlyphId[0] = 0;
+            }
+            // Converting glyphs and ids into font's cmap table
+            var newMapping = adjustMapping(charCodeToGlyphId, properties);
+            this.toFontChar = newMapping.toFontChar;
+            tables['cmap'] = {
+              tag: 'cmap',
+              data: createCmapTable(newMapping.charCodeToGlyphId, numGlyphs)
+            };
+            if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'])) {
+              tables['OS/2'] = {
+                tag: 'OS/2',
+                data: createOS2Table(properties, newMapping.charCodeToGlyphId, metricsOverride)
+              };
+            }
+            // Rewrite the 'post' table if needed
+            if (!tables['post']) {
+              tables['post'] = {
+                tag: 'post',
+                data: createPostTable(properties)
+              };
+            }
+            if (!isTrueType) {
+              try {
+                // Trying to repair CFF file
+                cffFile = new Stream(tables['CFF '].data);
+                var parser = new CFFParser(cffFile, properties, SEAC_ANALYSIS_ENABLED);
+                cff = parser.parse();
+                var compiler = new CFFCompiler(cff);
+                tables['CFF '].data = compiler.compile();
+              } catch (e) {
+                warn('Failed to compile font ' + properties.loadedName);
+              }
+            }
+            // Re-creating 'name' table
+            if (!tables['name']) {
+              tables['name'] = {
+                tag: 'name',
+                data: createNameTable(this.name)
+              };
+            } else {
+              // ... using existing 'name' table as prototype
+              var namePrototype = readNameTable(tables['name']);
+              tables['name'].data = createNameTable(name, namePrototype);
+            }
+            var builder = new OpenTypeFileBuilder(header.version);
+            for (var tableTag in tables) {
+              builder.addTable(tableTag, tables[tableTag].data);
+            }
+            return builder.toArray();
+          },
+          convert: function Font_convert(fontName, font, properties) {
+            // TODO: Check the charstring widths to determine this.
+            properties.fixedPitch = false;
+            if (properties.builtInEncoding) {
+              // For Type1 fonts that do not include either `ToUnicode` or `Encoding`
+              // data, attempt to use the `builtInEncoding` to improve text selection.
+              adjustToUnicode(properties, properties.builtInEncoding);
+            }
+            var mapping = font.getGlyphMapping(properties);
+            var newMapping = adjustMapping(mapping, properties);
+            this.toFontChar = newMapping.toFontChar;
+            var numGlyphs = font.numGlyphs;
+            function getCharCodes(charCodeToGlyphId, glyphId) {
+              var charCodes = null;
+              for (var charCode in charCodeToGlyphId) {
+                if (glyphId === charCodeToGlyphId[charCode]) {
+                  if (!charCodes) {
+                    charCodes = [];
+                  }
+                  charCodes.push(charCode | 0);
+                }
+              }
+              return charCodes;
+            }
+            function createCharCode(charCodeToGlyphId, glyphId) {
+              for (var charCode in charCodeToGlyphId) {
+                if (glyphId === charCodeToGlyphId[charCode]) {
+                  return charCode | 0;
+                }
+              }
+              newMapping.charCodeToGlyphId[newMapping.nextAvailableFontCharCode] = glyphId;
+              return newMapping.nextAvailableFontCharCode++;
+            }
+            var seacs = font.seacs;
+            if (SEAC_ANALYSIS_ENABLED && seacs && seacs.length) {
+              var matrix = properties.fontMatrix || FONT_IDENTITY_MATRIX;
+              var charset = font.getCharset();
+              var seacMap = Object.create(null);
+              for (var glyphId in seacs) {
+                glyphId |= 0;
+                var seac = seacs[glyphId];
+                var baseGlyphName = StandardEncoding[seac[2]];
+                var accentGlyphName = StandardEncoding[seac[3]];
+                var baseGlyphId = charset.indexOf(baseGlyphName);
+                var accentGlyphId = charset.indexOf(accentGlyphName);
+                if (baseGlyphId < 0 || accentGlyphId < 0) {
+                  continue;
+                }
+                var accentOffset = {
+                  x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4],
+                  y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5]
+                };
+                var charCodes = getCharCodes(mapping, glyphId);
+                if (!charCodes) {
+                  // There's no point in mapping it if the char code was never mapped
+                  // to begin with.
+                  continue;
+                }
+                for (var i = 0, ii = charCodes.length; i < ii; i++) {
+                  var charCode = charCodes[i];
+                  // Find a fontCharCode that maps to the base and accent glyphs.
+                  // If one doesn't exists, create it.
+                  var charCodeToGlyphId = newMapping.charCodeToGlyphId;
+                  var baseFontCharCode = createCharCode(charCodeToGlyphId, baseGlyphId);
+                  var accentFontCharCode = createCharCode(charCodeToGlyphId, accentGlyphId);
+                  seacMap[charCode] = {
+                    baseFontCharCode: baseFontCharCode,
+                    accentFontCharCode: accentFontCharCode,
+                    accentOffset: accentOffset
+                  };
+                }
+              }
+              properties.seacMap = seacMap;
+            }
+            var unitsPerEm = 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0];
+            var builder = new OpenTypeFileBuilder('\x4F\x54\x54\x4F');
+            // PostScript Font Program
+            builder.addTable('CFF ', font.data);
+            // OS/2 and Windows Specific metrics
+            builder.addTable('OS/2', createOS2Table(properties, newMapping.charCodeToGlyphId));
+            // Character to glyphs mapping
+            builder.addTable('cmap', createCmapTable(newMapping.charCodeToGlyphId, numGlyphs));
+            // Font header
+            builder.addTable('head', '\x00\x01\x00\x00' + // Version number
+            '\x00\x00\x10\x00' + // fontRevision
+            '\x00\x00\x00\x00' + // checksumAdjustement
+            '\x5F\x0F\x3C\xF5' + // magicNumber
+            '\x00\x00' + // Flags
+            safeString16(unitsPerEm) + // unitsPerEM
+            '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // creation date
+            '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // modifification date
+            '\x00\x00' + // xMin
+            safeString16(properties.descent) + // yMin
+            '\x0F\xFF' + // xMax
+            safeString16(properties.ascent) + // yMax
+            string16(properties.italicAngle ? 2 : 0) + // macStyle
+            '\x00\x11' + // lowestRecPPEM
+            '\x00\x00' + // fontDirectionHint
+            '\x00\x00' + // indexToLocFormat
+            '\x00\x00');
+            // glyphDataFormat
+            // Horizontal header
+            builder.addTable('hhea', '\x00\x01\x00\x00' + // Version number
+            safeString16(properties.ascent) + // Typographic Ascent
+            safeString16(properties.descent) + // Typographic Descent
+            '\x00\x00' + // Line Gap
+            '\xFF\xFF' + // advanceWidthMax
+            '\x00\x00' + // minLeftSidebearing
+            '\x00\x00' + // minRightSidebearing
+            '\x00\x00' + // xMaxExtent
+            safeString16(properties.capHeight) + // caretSlopeRise
+            safeString16(Math.tan(properties.italicAngle) * properties.xHeight) + // caretSlopeRun
+            '\x00\x00' + // caretOffset
+            '\x00\x00' + // -reserved-
+            '\x00\x00' + // -reserved-
+            '\x00\x00' + // -reserved-
+            '\x00\x00' + // -reserved-
+            '\x00\x00' + // metricDataFormat
+            string16(numGlyphs));
+            // Number of HMetrics
+            // Horizontal metrics
+            builder.addTable('hmtx', function fontFieldsHmtx() {
+              var charstrings = font.charstrings;
+              var cffWidths = font.cff ? font.cff.widths : null;
+              var hmtx = '\x00\x00\x00\x00';
+              // Fake .notdef
+              for (var i = 1, ii = numGlyphs; i < ii; i++) {
+                var width = 0;
+                if (charstrings) {
+                  var charstring = charstrings[i - 1];
+                  width = 'width' in charstring ? charstring.width : 0;
+                } else if (cffWidths) {
+                  width = Math.ceil(cffWidths[i] || 0);
+                }
+                hmtx += string16(width) + string16(0);
+              }
+              return hmtx;
+            }());
+            // Maximum profile
+            builder.addTable('maxp', '\x00\x00\x50\x00' + // Version number
+            string16(numGlyphs));
+            // Num of glyphs
+            // Naming tables
+            builder.addTable('name', createNameTable(fontName));
+            // PostScript information
+            builder.addTable('post', createPostTable(properties));
+            return builder.toArray();
+          },
+          get spaceWidth() {
+            if ('_shadowWidth' in this) {
+              return this._shadowWidth;
+            }
+            // trying to estimate space character width
+            var possibleSpaceReplacements = [
+              'space',
+              'minus',
+              'one',
+              'i',
+              'I'
+            ];
+            var width;
+            for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) {
+              var glyphName = possibleSpaceReplacements[i];
+              // if possible, getting width by glyph name
+              if (glyphName in this.widths) {
+                width = this.widths[glyphName];
+                break;
+              }
+              var glyphsUnicodeMap = getGlyphsUnicode();
+              var glyphUnicode = glyphsUnicodeMap[glyphName];
+              // finding the charcode via unicodeToCID map
+              var charcode = 0;
+              if (this.composite) {
+                if (this.cMap.contains(glyphUnicode)) {
+                  charcode = this.cMap.lookup(glyphUnicode);
+                }
+              }
+              // ... via toUnicode map
+              if (!charcode && this.toUnicode) {
+                charcode = this.toUnicode.charCodeOf(glyphUnicode);
+              }
+              // setting it to unicode if negative or undefined
+              if (charcode <= 0) {
+                charcode = glyphUnicode;
+              }
+              // trying to get width via charcode
+              width = this.widths[charcode];
+              if (width) {
+                break;
+              }
+            }
+            // the non-zero width found
+            width = width || this.defaultWidth;
+            // Do not shadow the property here. See discussion:
+            // https://github.com/mozilla/pdf.js/pull/2127#discussion_r1662280
+            this._shadowWidth = width;
+            return width;
+          },
+          charToGlyph: function Font_charToGlyph(charcode, isSpace) {
+            var fontCharCode, width, operatorListId;
+            var widthCode = charcode;
+            if (this.cMap && this.cMap.contains(charcode)) {
+              widthCode = this.cMap.lookup(charcode);
+            }
+            width = this.widths[widthCode];
+            width = isNum(width) ? width : this.defaultWidth;
+            var vmetric = this.vmetrics && this.vmetrics[widthCode];
+            var unicode = this.toUnicode.get(charcode) || charcode;
+            if (typeof unicode === 'number') {
+              unicode = String.fromCharCode(unicode);
+            }
+            var isInFont = charcode in this.toFontChar;
+            // First try the toFontChar map, if it's not there then try falling
+            // back to the char code.
+            fontCharCode = this.toFontChar[charcode] || charcode;
+            if (this.missingFile) {
+              fontCharCode = mapSpecialUnicodeValues(fontCharCode);
+            }
+            if (this.isType3Font) {
+              // Font char code in this case is actually a glyph name.
+              operatorListId = fontCharCode;
+            }
+            var accent = null;
+            if (this.seacMap && this.seacMap[charcode]) {
+              isInFont = true;
+              var seac = this.seacMap[charcode];
+              fontCharCode = seac.baseFontCharCode;
+              accent = {
+                fontChar: String.fromCharCode(seac.accentFontCharCode),
+                offset: seac.accentOffset
+              };
+            }
+            var fontChar = String.fromCharCode(fontCharCode);
+            var glyph = this.glyphCache[charcode];
+            if (!glyph || !glyph.matchesForCache(fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont)) {
+              glyph = new Glyph(fontChar, unicode, accent, width, vmetric, operatorListId, isSpace, isInFont);
+              this.glyphCache[charcode] = glyph;
+            }
+            return glyph;
+          },
+          charsToGlyphs: function Font_charsToGlyphs(chars) {
+            var charsCache = this.charsCache;
+            var glyphs, glyph, charcode;
+            // if we translated this string before, just grab it from the cache
+            if (charsCache) {
+              glyphs = charsCache[chars];
+              if (glyphs) {
+                return glyphs;
+              }
+            }
+            // lazily create the translation cache
+            if (!charsCache) {
+              charsCache = this.charsCache = Object.create(null);
+            }
+            glyphs = [];
+            var charsCacheKey = chars;
+            var i = 0, ii;
+            if (this.cMap) {
+              // composite fonts have multi-byte strings convert the string from
+              // single-byte to multi-byte
+              var c = Object.create(null);
+              while (i < chars.length) {
+                this.cMap.readCharCode(chars, i, c);
+                charcode = c.charcode;
+                var length = c.length;
+                i += length;
+                // Space is char with code 0x20 and length 1 in multiple-byte codes.
+                var isSpace = length === 1 && chars.charCodeAt(i - 1) === 0x20;
+                glyph = this.charToGlyph(charcode, isSpace);
+                glyphs.push(glyph);
+              }
+            } else {
+              for (i = 0, ii = chars.length; i < ii; ++i) {
+                charcode = chars.charCodeAt(i);
+                glyph = this.charToGlyph(charcode, charcode === 0x20);
+                glyphs.push(glyph);
+              }
+            }
+            // Enter the translated string into the cache
+            return charsCache[charsCacheKey] = glyphs;
+          }
+        };
+        return Font;
+      }();
+      var ErrorFont = function ErrorFontClosure() {
+        function ErrorFont(error) {
+          this.error = error;
+          this.loadedName = 'g_font_error';
+          this.loading = false;
+        }
+        ErrorFont.prototype = {
+          charsToGlyphs: function ErrorFont_charsToGlyphs() {
+            return [];
+          },
+          exportData: function ErrorFont_exportData() {
+            return { error: this.error };
+          }
+        };
+        return ErrorFont;
+      }();
+      /**
+       * Shared logic for building a char code to glyph id mapping for Type1 and
+       * simple CFF fonts. See section 9.6.6.2 of the spec.
+       * @param {Object} properties Font properties object.
+       * @param {Object} builtInEncoding The encoding contained within the actual font
+       * data.
+       * @param {Array} glyphNames Array of glyph names where the index is the
+       * glyph ID.
+       * @returns {Object} A char code to glyph ID map.
+       */
+      function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {
+        var charCodeToGlyphId = Object.create(null);
+        var glyphId, charCode, baseEncoding;
+        if (properties.baseEncodingName) {
+          // If a valid base encoding name was used, the mapping is initialized with
+          // that.
+          baseEncoding = getEncoding(properties.baseEncodingName);
+          for (charCode = 0; charCode < baseEncoding.length; charCode++) {
+            glyphId = glyphNames.indexOf(baseEncoding[charCode]);
+            if (glyphId >= 0) {
+              charCodeToGlyphId[charCode] = glyphId;
+            } else {
+              charCodeToGlyphId[charCode] = 0;
+            }
+          }
+        } else // notdef
+        if (!!(properties.flags & FontFlags.Symbolic)) {
+          // For a symbolic font the encoding should be the fonts built-in
+          // encoding.
+          for (charCode in builtInEncoding) {
+            charCodeToGlyphId[charCode] = builtInEncoding[charCode];
+          }
+        } else {
+          // For non-symbolic fonts that don't have a base encoding the standard
+          // encoding should be used.
+          baseEncoding = StandardEncoding;
+          for (charCode = 0; charCode < baseEncoding.length; charCode++) {
+            glyphId = glyphNames.indexOf(baseEncoding[charCode]);
+            if (glyphId >= 0) {
+              charCodeToGlyphId[charCode] = glyphId;
+            } else {
+              charCodeToGlyphId[charCode] = 0;
+            }
+          }
+        }
+        // notdef
+        // Lastly, merge in the differences.
+        var differences = properties.differences, glyphsUnicodeMap;
+        if (differences) {
+          for (charCode in differences) {
+            var glyphName = differences[charCode];
+            glyphId = glyphNames.indexOf(glyphName);
+            if (glyphId === -1) {
+              if (!glyphsUnicodeMap) {
+                glyphsUnicodeMap = getGlyphsUnicode();
+              }
+              var standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap);
+              if (standardGlyphName !== glyphName) {
+                glyphId = glyphNames.indexOf(standardGlyphName);
+              }
+            }
+            if (glyphId >= 0) {
+              charCodeToGlyphId[charCode] = glyphId;
+            } else {
+              charCodeToGlyphId[charCode] = 0;
+            }
+          }
+        }
+        // notdef
+        return charCodeToGlyphId;
+      }
+      // Type1Font is also a CIDFontType0.
+      var Type1Font = function Type1FontClosure() {
+        function findBlock(streamBytes, signature, startIndex) {
+          var streamBytesLength = streamBytes.length;
+          var signatureLength = signature.length;
+          var scanLength = streamBytesLength - signatureLength;
+          var i = startIndex, j, found = false;
+          while (i < scanLength) {
+            j = 0;
+            while (j < signatureLength && streamBytes[i + j] === signature[j]) {
+              j++;
+            }
+            if (j >= signatureLength) {
+              // `signature` found, skip over whitespace.
+              i += j;
+              while (i < streamBytesLength && isSpace(streamBytes[i])) {
+                i++;
+              }
+              found = true;
+              break;
+            }
+            i++;
+          }
+          return {
+            found: found,
+            length: i
+          };
+        }
+        function getHeaderBlock(stream, suggestedLength) {
+          var EEXEC_SIGNATURE = [
+            0x65,
+            0x65,
+            0x78,
+            0x65,
+            0x63
+          ];
+          var streamStartPos = stream.pos;
+          // Save the initial stream position.
+          var headerBytes, headerBytesLength, block;
+          try {
+            headerBytes = stream.getBytes(suggestedLength);
+            headerBytesLength = headerBytes.length;
+          } catch (ex) {
+            if (ex instanceof MissingDataException) {
+              throw ex;
+            }
+          }
+          // Ignore errors if the `suggestedLength` is huge enough that a Uint8Array
+          // cannot hold the result of `getBytes`, and fallback to simply checking
+          // the entire stream (fixes issue3928.pdf).
+          if (headerBytesLength === suggestedLength) {
+            // Most of the time `suggestedLength` is correct, so to speed things up we
+            // initially only check the last few bytes to see if the header was found.
+            // Otherwise we (potentially) check the entire stream to prevent errors in
+            // `Type1Parser` (fixes issue5686.pdf).
+            block = findBlock(headerBytes, EEXEC_SIGNATURE, suggestedLength - 2 * EEXEC_SIGNATURE.length);
+            if (block.found && block.length === suggestedLength) {
+              return {
+                stream: new Stream(headerBytes),
+                length: suggestedLength
+              };
+            }
+          }
+          warn('Invalid "Length1" property in Type1 font -- trying to recover.');
+          stream.pos = streamStartPos;
+          // Reset the stream position.
+          var SCAN_BLOCK_LENGTH = 2048;
+          var actualLength;
+          while (true) {
+            var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
+            block = findBlock(scanBytes, EEXEC_SIGNATURE, 0);
+            if (block.length === 0) {
+              break;
+            }
+            stream.pos += block.length;
+            // Update the stream position.
+            if (block.found) {
+              actualLength = stream.pos - streamStartPos;
+              break;
+            }
+          }
+          stream.pos = streamStartPos;
+          // Reset the stream position.
+          if (actualLength) {
+            return {
+              stream: new Stream(stream.getBytes(actualLength)),
+              length: actualLength
+            };
+          }
+          warn('Unable to recover "Length1" property in Type1 font -- using as is.');
+          return {
+            stream: new Stream(stream.getBytes(suggestedLength)),
+            length: suggestedLength
+          };
+        }
+        function getEexecBlock(stream, suggestedLength) {
+          // We should ideally parse the eexec block to ensure that `suggestedLength`
+          // is correct, so we don't truncate the block data if it's too small.
+          // However, this would also require checking if the fixed-content portion
+          // exists (using the 'Length3' property), and ensuring that it's valid.
+          //
+          // Given that `suggestedLength` almost always is correct, all the validation
+          // would require a great deal of unnecessary parsing for most fonts.
+          // To save time, we always fetch the entire stream instead, which also avoid
+          // issues if `suggestedLength` is huge (see comment in `getHeaderBlock`).
+          //
+          // NOTE: This means that the function can include the fixed-content portion
+          // in the returned eexec block. In practice this does *not* seem to matter,
+          // since `Type1Parser_extractFontProgram` will skip over any non-commands.
+          var eexecBytes = stream.getBytes();
+          return {
+            stream: new Stream(eexecBytes),
+            length: eexecBytes.length
+          };
+        }
+        function Type1Font(name, file, properties) {
+          // Some bad generators embed pfb file as is, we have to strip 6-byte header.
+          // Also, length1 and length2 might be off by 6 bytes as well.
+          // http://www.math.ubc.ca/~cass/piscript/type1.pdf
+          var PFB_HEADER_SIZE = 6;
+          var headerBlockLength = properties.length1;
+          var eexecBlockLength = properties.length2;
+          var pfbHeader = file.peekBytes(PFB_HEADER_SIZE);
+          var pfbHeaderPresent = pfbHeader[0] === 0x80 && pfbHeader[1] === 0x01;
+          if (pfbHeaderPresent) {
+            file.skip(PFB_HEADER_SIZE);
+            headerBlockLength = pfbHeader[5] << 24 | pfbHeader[4] << 16 | pfbHeader[3] << 8 | pfbHeader[2];
+          }
+          // Get the data block containing glyphs and subrs information
+          var headerBlock = getHeaderBlock(file, headerBlockLength);
+          headerBlockLength = headerBlock.length;
+          var headerBlockParser = new Type1Parser(headerBlock.stream, false, SEAC_ANALYSIS_ENABLED);
+          headerBlockParser.extractFontHeader(properties);
+          if (pfbHeaderPresent) {
+            pfbHeader = file.getBytes(PFB_HEADER_SIZE);
+            eexecBlockLength = pfbHeader[5] << 24 | pfbHeader[4] << 16 | pfbHeader[3] << 8 | pfbHeader[2];
+          }
+          // Decrypt the data blocks and retrieve it's content
+          var eexecBlock = getEexecBlock(file, eexecBlockLength);
+          eexecBlockLength = eexecBlock.length;
+          var eexecBlockParser = new Type1Parser(eexecBlock.stream, true, SEAC_ANALYSIS_ENABLED);
+          var data = eexecBlockParser.extractFontProgram();
+          for (var info in data.properties) {
+            properties[info] = data.properties[info];
+          }
+          var charstrings = data.charstrings;
+          var type2Charstrings = this.getType2Charstrings(charstrings);
+          var subrs = this.getType2Subrs(data.subrs);
+          this.charstrings = charstrings;
+          this.data = this.wrap(name, type2Charstrings, this.charstrings, subrs, properties);
+          this.seacs = this.getSeacs(data.charstrings);
+        }
+        Type1Font.prototype = {
+          get numGlyphs() {
+            return this.charstrings.length + 1;
+          },
+          getCharset: function Type1Font_getCharset() {
+            var charset = ['.notdef'];
+            var charstrings = this.charstrings;
+            for (var glyphId = 0; glyphId < charstrings.length; glyphId++) {
+              charset.push(charstrings[glyphId].glyphName);
+            }
+            return charset;
+          },
+          getGlyphMapping: function Type1Font_getGlyphMapping(properties) {
+            var charstrings = this.charstrings;
+            var glyphNames = ['.notdef'], glyphId;
+            for (glyphId = 0; glyphId < charstrings.length; glyphId++) {
+              glyphNames.push(charstrings[glyphId].glyphName);
+            }
+            var encoding = properties.builtInEncoding;
+            if (encoding) {
+              var builtInEncoding = Object.create(null);
+              for (var charCode in encoding) {
+                glyphId = glyphNames.indexOf(encoding[charCode]);
+                if (glyphId >= 0) {
+                  builtInEncoding[charCode] = glyphId;
+                }
+              }
+            }
+            return type1FontGlyphMapping(properties, builtInEncoding, glyphNames);
+          },
+          getSeacs: function Type1Font_getSeacs(charstrings) {
+            var i, ii;
+            var seacMap = [];
+            for (i = 0, ii = charstrings.length; i < ii; i++) {
+              var charstring = charstrings[i];
+              if (charstring.seac) {
+                // Offset by 1 for .notdef
+                seacMap[i + 1] = charstring.seac;
+              }
+            }
+            return seacMap;
+          },
+          getType2Charstrings: function Type1Font_getType2Charstrings(type1Charstrings) {
+            var type2Charstrings = [];
+            for (var i = 0, ii = type1Charstrings.length; i < ii; i++) {
+              type2Charstrings.push(type1Charstrings[i].charstring);
+            }
+            return type2Charstrings;
+          },
+          getType2Subrs: function Type1Font_getType2Subrs(type1Subrs) {
+            var bias = 0;
+            var count = type1Subrs.length;
+            if (count < 1133) {
+              bias = 107;
+            } else if (count < 33769) {
+              bias = 1131;
+            } else {
+              bias = 32768;
+            }
+            // Add a bunch of empty subrs to deal with the Type2 bias
+            var type2Subrs = [];
+            var i;
+            for (i = 0; i < bias; i++) {
+              type2Subrs.push([0x0B]);
+            }
+            for (i = 0; i < count; i++) {
+              type2Subrs.push(type1Subrs[i]);
+            }
+            return type2Subrs;
+          },
+          wrap: function Type1Font_wrap(name, glyphs, charstrings, subrs, properties) {
+            var cff = new CFF();
+            cff.header = new CFFHeader(1, 0, 4, 4);
+            cff.names = [name];
+            var topDict = new CFFTopDict();
+            // CFF strings IDs 0...390 are predefined names, so refering
+            // to entries in our own String INDEX starts at SID 391.
+            topDict.setByName('version', 391);
+            topDict.setByName('Notice', 392);
+            topDict.setByName('FullName', 393);
+            topDict.setByName('FamilyName', 394);
+            topDict.setByName('Weight', 395);
+            topDict.setByName('Encoding', null);
+            // placeholder
+            topDict.setByName('FontMatrix', properties.fontMatrix);
+            topDict.setByName('FontBBox', properties.bbox);
+            topDict.setByName('charset', null);
+            // placeholder
+            topDict.setByName('CharStrings', null);
+            // placeholder
+            topDict.setByName('Private', null);
+            // placeholder
+            cff.topDict = topDict;
+            var strings = new CFFStrings();
+            strings.add('Version 0.11');
+            // Version
+            strings.add('See original notice');
+            // Notice
+            strings.add(name);
+            // FullName
+            strings.add(name);
+            // FamilyName
+            strings.add('Medium');
+            // Weight
+            cff.strings = strings;
+            cff.globalSubrIndex = new CFFIndex();
+            var count = glyphs.length;
+            var charsetArray = [0];
+            var i, ii;
+            for (i = 0; i < count; i++) {
+              var index = CFFStandardStrings.indexOf(charstrings[i].glyphName);
+              // TODO: Insert the string and correctly map it.  Previously it was
+              // thought mapping names that aren't in the standard strings to .notdef
+              // was fine, however in issue818 when mapping them all to .notdef the
+              // adieresis glyph no longer worked.
+              if (index === -1) {
+                index = 0;
+              }
+              charsetArray.push(index >> 8 & 0xff, index & 0xff);
+            }
+            cff.charset = new CFFCharset(false, 0, [], charsetArray);
+            var charStringsIndex = new CFFIndex();
+            charStringsIndex.add([
+              0x8B,
+              0x0E
+            ]);
+            // .notdef
+            for (i = 0; i < count; i++) {
+              var glyph = glyphs[i];
+              // If the CharString outline is empty, replace it with .notdef to
+              // prevent OTS from rejecting the font (fixes bug1252420.pdf).
+              if (glyph.length === 0) {
+                charStringsIndex.add([
+                  0x8B,
+                  0x0E
+                ]);
+                // .notdef
+                continue;
+              }
+              charStringsIndex.add(glyph);
+            }
+            cff.charStrings = charStringsIndex;
+            var privateDict = new CFFPrivateDict();
+            privateDict.setByName('Subrs', null);
+            // placeholder
+            var fields = [
+              'BlueValues',
+              'OtherBlues',
+              'FamilyBlues',
+              'FamilyOtherBlues',
+              'StemSnapH',
+              'StemSnapV',
+              'BlueShift',
+              'BlueFuzz',
+              'BlueScale',
+              'LanguageGroup',
+              'ExpansionFactor',
+              'ForceBold',
+              'StdHW',
+              'StdVW'
+            ];
+            for (i = 0, ii = fields.length; i < ii; i++) {
+              var field = fields[i];
+              if (!(field in properties.privateData)) {
+                continue;
+              }
+              var value = properties.privateData[field];
+              if (isArray(value)) {
+                // All of the private dictionary array data in CFF must be stored as
+                // "delta-encoded" numbers.
+                for (var j = value.length - 1; j > 0; j--) {
+                  value[j] -= value[j - 1];
+                }
+              }
+              // ... difference from previous value
+              privateDict.setByName(field, value);
+            }
+            cff.topDict.privateDict = privateDict;
+            var subrIndex = new CFFIndex();
+            for (i = 0, ii = subrs.length; i < ii; i++) {
+              subrIndex.add(subrs[i]);
+            }
+            privateDict.subrsIndex = subrIndex;
+            var compiler = new CFFCompiler(cff);
+            return compiler.compile();
+          }
+        };
+        return Type1Font;
+      }();
+      var CFFFont = function CFFFontClosure() {
+        function CFFFont(file, properties) {
+          this.properties = properties;
+          var parser = new CFFParser(file, properties, SEAC_ANALYSIS_ENABLED);
+          this.cff = parser.parse();
+          var compiler = new CFFCompiler(this.cff);
+          this.seacs = this.cff.seacs;
+          try {
+            this.data = compiler.compile();
+          } catch (e) {
+            warn('Failed to compile font ' + properties.loadedName);
+            // There may have just been an issue with the compiler, set the data
+            // anyway and hope the font loaded.
+            this.data = file;
+          }
+        }
+        CFFFont.prototype = {
+          get numGlyphs() {
+            return this.cff.charStrings.count;
+          },
+          getCharset: function CFFFont_getCharset() {
+            return this.cff.charset.charset;
+          },
+          getGlyphMapping: function CFFFont_getGlyphMapping() {
+            var cff = this.cff;
+            var properties = this.properties;
+            var charsets = cff.charset.charset;
+            var charCodeToGlyphId;
+            var glyphId;
+            if (properties.composite) {
+              charCodeToGlyphId = Object.create(null);
+              if (cff.isCIDFont) {
+                // If the font is actually a CID font then we should use the charset
+                // to map CIDs to GIDs.
+                for (glyphId = 0; glyphId < charsets.length; glyphId++) {
+                  var cid = charsets[glyphId];
+                  var charCode = properties.cMap.charCodeOf(cid);
+                  charCodeToGlyphId[charCode] = glyphId;
+                }
+              } else {
+                // If it is NOT actually a CID font then CIDs should be mapped
+                // directly to GIDs.
+                for (glyphId = 0; glyphId < cff.charStrings.count; glyphId++) {
+                  charCodeToGlyphId[glyphId] = glyphId;
+                }
+              }
+              return charCodeToGlyphId;
+            }
+            var encoding = cff.encoding ? cff.encoding.encoding : null;
+            charCodeToGlyphId = type1FontGlyphMapping(properties, encoding, charsets);
+            return charCodeToGlyphId;
+          }
+        };
+        return CFFFont;
+      }();
+      // Workaround for seac on Windows.
+      (function checkSeacSupport() {
+        if (typeof navigator !== 'undefined' && /Windows/.test(navigator.userAgent)) {
+          SEAC_ANALYSIS_ENABLED = true;
+        }
+      }());
+      // Workaround for Private Use Area characters in Chrome on Windows
+      // http://code.google.com/p/chromium/issues/detail?id=122465
+      // https://github.com/mozilla/pdf.js/issues/1689
+      (function checkChromeWindows() {
+        if (typeof navigator !== 'undefined' && /Windows.*Chrome/.test(navigator.userAgent)) {
+          SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = true;
+        }
+      }());
+      exports.ErrorFont = ErrorFont;
+      exports.Font = Font;
+      exports.FontFlags = FontFlags;
+      exports.IdentityToUnicodeMap = IdentityToUnicodeMap;
+      exports.ToUnicodeMap = ToUnicodeMap;
+      exports.getFontType = getFontType;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCorePsParser = {}, root.pdfjsSharedUtil, root.pdfjsCoreParser);
+    }(this, function (exports, sharedUtil, coreParser) {
+      var error = sharedUtil.error;
+      var isSpace = sharedUtil.isSpace;
+      var EOF = coreParser.EOF;
+      var PostScriptParser = function PostScriptParserClosure() {
+        function PostScriptParser(lexer) {
+          this.lexer = lexer;
+          this.operators = [];
+          this.token = null;
+          this.prev = null;
+        }
+        PostScriptParser.prototype = {
+          nextToken: function PostScriptParser_nextToken() {
+            this.prev = this.token;
+            this.token = this.lexer.getToken();
+          },
+          accept: function PostScriptParser_accept(type) {
+            if (this.token.type === type) {
+              this.nextToken();
+              return true;
+            }
+            return false;
+          },
+          expect: function PostScriptParser_expect(type) {
+            if (this.accept(type)) {
+              return true;
+            }
+            error('Unexpected symbol: found ' + this.token.type + ' expected ' + type + '.');
+          },
+          parse: function PostScriptParser_parse() {
+            this.nextToken();
+            this.expect(PostScriptTokenTypes.LBRACE);
+            this.parseBlock();
+            this.expect(PostScriptTokenTypes.RBRACE);
+            return this.operators;
+          },
+          parseBlock: function PostScriptParser_parseBlock() {
+            while (true) {
+              if (this.accept(PostScriptTokenTypes.NUMBER)) {
+                this.operators.push(this.prev.value);
+              } else if (this.accept(PostScriptTokenTypes.OPERATOR)) {
+                this.operators.push(this.prev.value);
+              } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
+                this.parseCondition();
+              } else {
+                return;
+              }
+            }
+          },
+          parseCondition: function PostScriptParser_parseCondition() {
+            // Add two place holders that will be updated later
+            var conditionLocation = this.operators.length;
+            this.operators.push(null, null);
+            this.parseBlock();
+            this.expect(PostScriptTokenTypes.RBRACE);
+            if (this.accept(PostScriptTokenTypes.IF)) {
+              // The true block is right after the 'if' so it just falls through on
+              // true else it jumps and skips the true block.
+              this.operators[conditionLocation] = this.operators.length;
+              this.operators[conditionLocation + 1] = 'jz';
+            } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
+              var jumpLocation = this.operators.length;
+              this.operators.push(null, null);
+              var endOfTrue = this.operators.length;
+              this.parseBlock();
+              this.expect(PostScriptTokenTypes.RBRACE);
+              this.expect(PostScriptTokenTypes.IFELSE);
+              // The jump is added at the end of the true block to skip the false
+              // block.
+              this.operators[jumpLocation] = this.operators.length;
+              this.operators[jumpLocation + 1] = 'j';
+              this.operators[conditionLocation] = endOfTrue;
+              this.operators[conditionLocation + 1] = 'jz';
+            } else {
+              error('PS Function: error parsing conditional.');
+            }
+          }
+        };
+        return PostScriptParser;
+      }();
+      var PostScriptTokenTypes = {
+        LBRACE: 0,
+        RBRACE: 1,
+        NUMBER: 2,
+        OPERATOR: 3,
+        IF: 4,
+        IFELSE: 5
+      };
+      var PostScriptToken = function PostScriptTokenClosure() {
+        function PostScriptToken(type, value) {
+          this.type = type;
+          this.value = value;
+        }
+        var opCache = Object.create(null);
+        PostScriptToken.getOperator = function PostScriptToken_getOperator(op) {
+          var opValue = opCache[op];
+          if (opValue) {
+            return opValue;
+          }
+          return opCache[op] = new PostScriptToken(PostScriptTokenTypes.OPERATOR, op);
+        };
+        PostScriptToken.LBRACE = new PostScriptToken(PostScriptTokenTypes.LBRACE, '{');
+        PostScriptToken.RBRACE = new PostScriptToken(PostScriptTokenTypes.RBRACE, '}');
+        PostScriptToken.IF = new PostScriptToken(PostScriptTokenTypes.IF, 'IF');
+        PostScriptToken.IFELSE = new PostScriptToken(PostScriptTokenTypes.IFELSE, 'IFELSE');
+        return PostScriptToken;
+      }();
+      var PostScriptLexer = function PostScriptLexerClosure() {
+        function PostScriptLexer(stream) {
+          this.stream = stream;
+          this.nextChar();
+          this.strBuf = [];
+        }
+        PostScriptLexer.prototype = {
+          nextChar: function PostScriptLexer_nextChar() {
+            return this.currentChar = this.stream.getByte();
+          },
+          getToken: function PostScriptLexer_getToken() {
+            var comment = false;
+            var ch = this.currentChar;
+            // skip comments
+            while (true) {
+              if (ch < 0) {
+                return EOF;
+              }
+              if (comment) {
+                if (ch === 0x0A || ch === 0x0D) {
+                  comment = false;
+                }
+              } else if (ch === 0x25) {
+                // '%'
+                comment = true;
+              } else if (!isSpace(ch)) {
+                break;
+              }
+              ch = this.nextChar();
+            }
+            switch (ch | 0) {
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            // '0'-'4'
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            // '5'-'9'
+            case 0x2B:
+            case 0x2D:
+            case 0x2E:
+              // '+', '-', '.'
+              return new PostScriptToken(PostScriptTokenTypes.NUMBER, this.getNumber());
+            case 0x7B:
+              // '{'
+              this.nextChar();
+              return PostScriptToken.LBRACE;
+            case 0x7D:
+              // '}'
+              this.nextChar();
+              return PostScriptToken.RBRACE;
+            }
+            // operator
+            var strBuf = this.strBuf;
+            strBuf.length = 0;
+            strBuf[0] = String.fromCharCode(ch);
+            while ((ch = this.nextChar()) >= 0 && // and 'A'-'Z', 'a'-'z'
+              (ch >= 0x41 && ch <= 0x5A || ch >= 0x61 && ch <= 0x7A)) {
+              strBuf.push(String.fromCharCode(ch));
+            }
+            var str = strBuf.join('');
+            switch (str.toLowerCase()) {
+            case 'if':
+              return PostScriptToken.IF;
+            case 'ifelse':
+              return PostScriptToken.IFELSE;
+            default:
+              return PostScriptToken.getOperator(str);
+            }
+          },
+          getNumber: function PostScriptLexer_getNumber() {
+            var ch = this.currentChar;
+            var strBuf = this.strBuf;
+            strBuf.length = 0;
+            strBuf[0] = String.fromCharCode(ch);
+            while ((ch = this.nextChar()) >= 0) {
+              if (ch >= 0x30 && ch <= 0x39 || // '0'-'9'
+                ch === 0x2D || ch === 0x2E) {
+                // '-', '.'
+                strBuf.push(String.fromCharCode(ch));
+              } else {
+                break;
+              }
+            }
+            var value = parseFloat(strBuf.join(''));
+            if (isNaN(value)) {
+              error('Invalid floating point number: ' + value);
+            }
+            return value;
+          }
+        };
+        return PostScriptLexer;
+      }();
+      exports.PostScriptLexer = PostScriptLexer;
+      exports.PostScriptParser = PostScriptParser;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreFunction = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCorePsParser);
+    }(this, function (exports, sharedUtil, corePrimitives, corePsParser) {
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isBool = sharedUtil.isBool;
+      var isDict = corePrimitives.isDict;
+      var isStream = corePrimitives.isStream;
+      var PostScriptLexer = corePsParser.PostScriptLexer;
+      var PostScriptParser = corePsParser.PostScriptParser;
+      function toNumberArray(arr) {
+        if (!Array.isArray(arr)) {
+          return null;
+        }
+        var length = arr.length;
+        for (var i = 0; i < length; i++) {
+          if (typeof arr[i] !== 'number') {
+            var result = new Array(length);
+            for (var j = 0; j < length; j++) {
+              result[j] = +arr[j];
+            }
+            return result;
+          }
+        }
+        return arr;
+      }
+      var PDFFunction = function PDFFunctionClosure() {
+        var CONSTRUCT_SAMPLED = 0;
+        var CONSTRUCT_INTERPOLATED = 2;
+        var CONSTRUCT_STICHED = 3;
+        var CONSTRUCT_POSTSCRIPT = 4;
+        return {
+          getSampleArray: function PDFFunction_getSampleArray(size, outputSize, bps, str) {
+            var i, ii;
+            var length = 1;
+            for (i = 0, ii = size.length; i < ii; i++) {
+              length *= size[i];
+            }
+            length *= outputSize;
+            var array = new Array(length);
+            var codeSize = 0;
+            var codeBuf = 0;
+            // 32 is a valid bps so shifting won't work
+            var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);
+            var strBytes = str.getBytes((length * bps + 7) / 8);
+            var strIdx = 0;
+            for (i = 0; i < length; i++) {
+              while (codeSize < bps) {
+                codeBuf <<= 8;
+                codeBuf |= strBytes[strIdx++];
+                codeSize += 8;
+              }
+              codeSize -= bps;
+              array[i] = (codeBuf >> codeSize) * sampleMul;
+              codeBuf &= (1 << codeSize) - 1;
+            }
+            return array;
+          },
+          getIR: function PDFFunction_getIR(xref, fn) {
+            var dict = fn.dict;
+            if (!dict) {
+              dict = fn;
+            }
+            var types = [
+              this.constructSampled,
+              null,
+              this.constructInterpolated,
+              this.constructStiched,
+              this.constructPostScript
+            ];
+            var typeNum = dict.get('FunctionType');
+            var typeFn = types[typeNum];
+            if (!typeFn) {
+              error('Unknown type of function');
+            }
+            return typeFn.call(this, fn, dict, xref);
+          },
+          fromIR: function PDFFunction_fromIR(IR) {
+            var type = IR[0];
+            switch (type) {
+            case CONSTRUCT_SAMPLED:
+              return this.constructSampledFromIR(IR);
+            case CONSTRUCT_INTERPOLATED:
+              return this.constructInterpolatedFromIR(IR);
+            case CONSTRUCT_STICHED:
+              return this.constructStichedFromIR(IR);
+            //case CONSTRUCT_POSTSCRIPT:
+            default:
+              return this.constructPostScriptFromIR(IR);
+            }
+          },
+          parse: function PDFFunction_parse(xref, fn) {
+            var IR = this.getIR(xref, fn);
+            return this.fromIR(IR);
+          },
+          parseArray: function PDFFunction_parseArray(xref, fnObj) {
+            if (!isArray(fnObj)) {
+              // not an array -- parsing as regular function
+              return this.parse(xref, fnObj);
+            }
+            var fnArray = [];
+            for (var j = 0, jj = fnObj.length; j < jj; j++) {
+              var obj = xref.fetchIfRef(fnObj[j]);
+              fnArray.push(PDFFunction.parse(xref, obj));
+            }
+            return function (src, srcOffset, dest, destOffset) {
+              for (var i = 0, ii = fnArray.length; i < ii; i++) {
+                fnArray[i](src, srcOffset, dest, destOffset + i);
+              }
+            };
+          },
+          constructSampled: function PDFFunction_constructSampled(str, dict) {
+            function toMultiArray(arr) {
+              var inputLength = arr.length;
+              var out = [];
+              var index = 0;
+              for (var i = 0; i < inputLength; i += 2) {
+                out[index] = [
+                  arr[i],
+                  arr[i + 1]
+                ];
+                ++index;
+              }
+              return out;
+            }
+            var domain = toNumberArray(dict.getArray('Domain'));
+            var range = toNumberArray(dict.getArray('Range'));
+            if (!domain || !range) {
+              error('No domain or range');
+            }
+            var inputSize = domain.length / 2;
+            var outputSize = range.length / 2;
+            domain = toMultiArray(domain);
+            range = toMultiArray(range);
+            var size = toNumberArray(dict.get('Size'));
+            var bps = dict.get('BitsPerSample');
+            var order = dict.get('Order') || 1;
+            if (order !== 1) {
+              // No description how cubic spline interpolation works in PDF32000:2008
+              // As in poppler, ignoring order, linear interpolation may work as good
+              info('No support for cubic spline interpolation: ' + order);
+            }
+            var encode = toNumberArray(dict.getArray('Encode'));
+            if (!encode) {
+              encode = [];
+              for (var i = 0; i < inputSize; ++i) {
+                encode.push([0, size[i] - 1]);
+              }
+            } else {
+              encode = toMultiArray(encode);
+            }
+            var decode = toNumberArray(dict.getArray('Decode'));
+            if (!decode) {
+              decode = range;
+            } else {
+              decode = toMultiArray(decode);
+            }
+            var samples = this.getSampleArray(size, outputSize, bps, str);
+            return [
+              CONSTRUCT_SAMPLED,
+              inputSize,
+              domain,
+              encode,
+              decode,
+              samples,
+              size,
+              outputSize,
+              Math.pow(2, bps) - 1,
+              range
+            ];
+          },
+          constructSampledFromIR: function PDFFunction_constructSampledFromIR(IR) {
+            // See chapter 3, page 109 of the PDF reference
+            function interpolate(x, xmin, xmax, ymin, ymax) {
+              return ymin + (x - xmin) * ((ymax - ymin) / (xmax - xmin));
+            }
+            return function constructSampledFromIRResult(src, srcOffset, dest, destOffset) {
+              // See chapter 3, page 110 of the PDF reference.
+              var m = IR[1];
+              var domain = IR[2];
+              var encode = IR[3];
+              var decode = IR[4];
+              var samples = IR[5];
+              var size = IR[6];
+              var n = IR[7];
+              //var mask = IR[8];
+              var range = IR[9];
+              // Building the cube vertices: its part and sample index
+              // http://rjwagner49.com/Mathematics/Interpolation.pdf
+              var cubeVertices = 1 << m;
+              var cubeN = new Float64Array(cubeVertices);
+              var cubeVertex = new Uint32Array(cubeVertices);
+              var i, j;
+              for (j = 0; j < cubeVertices; j++) {
+                cubeN[j] = 1;
+              }
+              var k = n, pos = 1;
+              // Map x_i to y_j for 0 <= i < m using the sampled function.
+              for (i = 0; i < m; ++i) {
+                // x_i' = min(max(x_i, Domain_2i), Domain_2i+1)
+                var domain_2i = domain[i][0];
+                var domain_2i_1 = domain[i][1];
+                var xi = Math.min(Math.max(src[srcOffset + i], domain_2i), domain_2i_1);
+                // e_i = Interpolate(x_i', Domain_2i, Domain_2i+1,
+                //                   Encode_2i, Encode_2i+1)
+                var e = interpolate(xi, domain_2i, domain_2i_1, encode[i][0], encode[i][1]);
+                // e_i' = min(max(e_i, 0), Size_i - 1)
+                var size_i = size[i];
+                e = Math.min(Math.max(e, 0), size_i - 1);
+                // Adjusting the cube: N and vertex sample index
+                var e0 = e < size_i - 1 ? Math.floor(e) : e - 1;
+                // e1 = e0 + 1;
+                var n0 = e0 + 1 - e;
+                // (e1 - e) / (e1 - e0);
+                var n1 = e - e0;
+                // (e - e0) / (e1 - e0);
+                var offset0 = e0 * k;
+                var offset1 = offset0 + k;
+                // e1 * k
+                for (j = 0; j < cubeVertices; j++) {
+                  if (j & pos) {
+                    cubeN[j] *= n1;
+                    cubeVertex[j] += offset1;
+                  } else {
+                    cubeN[j] *= n0;
+                    cubeVertex[j] += offset0;
+                  }
+                }
+                k *= size_i;
+                pos <<= 1;
+              }
+              for (j = 0; j < n; ++j) {
+                // Sum all cube vertices' samples portions
+                var rj = 0;
+                for (i = 0; i < cubeVertices; i++) {
+                  rj += samples[cubeVertex[i] + j] * cubeN[i];
+                }
+                // r_j' = Interpolate(r_j, 0, 2^BitsPerSample - 1,
+                //                    Decode_2j, Decode_2j+1)
+                rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
+                // y_j = min(max(r_j, range_2j), range_2j+1)
+                dest[destOffset + j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);
+              }
+            };
+          },
+          constructInterpolated: function PDFFunction_constructInterpolated(str, dict) {
+            var c0 = toNumberArray(dict.getArray('C0')) || [0];
+            var c1 = toNumberArray(dict.getArray('C1')) || [1];
+            var n = dict.get('N');
+            var length = c0.length;
+            var diff = [];
+            for (var i = 0; i < length; ++i) {
+              diff.push(c1[i] - c0[i]);
+            }
+            return [
+              CONSTRUCT_INTERPOLATED,
+              c0,
+              diff,
+              n
+            ];
+          },
+          constructInterpolatedFromIR: function PDFFunction_constructInterpolatedFromIR(IR) {
+            var c0 = IR[1];
+            var diff = IR[2];
+            var n = IR[3];
+            var length = diff.length;
+            return function constructInterpolatedFromIRResult(src, srcOffset, dest, destOffset) {
+              var x = n === 1 ? src[srcOffset] : Math.pow(src[srcOffset], n);
+              for (var j = 0; j < length; ++j) {
+                dest[destOffset + j] = c0[j] + x * diff[j];
+              }
+            };
+          },
+          constructStiched: function PDFFunction_constructStiched(fn, dict, xref) {
+            var domain = toNumberArray(dict.getArray('Domain'));
+            if (!domain) {
+              error('No domain');
+            }
+            var inputSize = domain.length / 2;
+            if (inputSize !== 1) {
+              error('Bad domain for stiched function');
+            }
+            var fnRefs = dict.get('Functions');
+            var fns = [];
+            for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
+              fns.push(PDFFunction.parse(xref, xref.fetchIfRef(fnRefs[i])));
+            }
+            var bounds = toNumberArray(dict.getArray('Bounds'));
+            var encode = toNumberArray(dict.getArray('Encode'));
+            return [
+              CONSTRUCT_STICHED,
+              domain,
+              bounds,
+              encode,
+              fns
+            ];
+          },
+          constructStichedFromIR: function PDFFunction_constructStichedFromIR(IR) {
+            var domain = IR[1];
+            var bounds = IR[2];
+            var encode = IR[3];
+            var fns = IR[4];
+            var tmpBuf = new Float32Array(1);
+            return function constructStichedFromIRResult(src, srcOffset, dest, destOffset) {
+              var clip = function constructStichedFromIRClip(v, min, max) {
+                if (v > max) {
+                  v = max;
+                } else if (v < min) {
+                  v = min;
+                }
+                return v;
+              };
+              // clip to domain
+              var v = clip(src[srcOffset], domain[0], domain[1]);
+              // calculate which bound the value is in
+              for (var i = 0, ii = bounds.length; i < ii; ++i) {
+                if (v < bounds[i]) {
+                  break;
+                }
+              }
+              // encode value into domain of function
+              var dmin = domain[0];
+              if (i > 0) {
+                dmin = bounds[i - 1];
+              }
+              var dmax = domain[1];
+              if (i < bounds.length) {
+                dmax = bounds[i];
+              }
+              var rmin = encode[2 * i];
+              var rmax = encode[2 * i + 1];
+              // Prevent the value from becoming NaN as a result
+              // of division by zero (fixes issue6113.pdf).
+              tmpBuf[0] = dmin === dmax ? rmin : rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin);
+              // call the appropriate function
+              fns[i](tmpBuf, 0, dest, destOffset);
+            };
+          },
+          constructPostScript: function PDFFunction_constructPostScript(fn, dict, xref) {
+            var domain = toNumberArray(dict.getArray('Domain'));
+            var range = toNumberArray(dict.getArray('Range'));
+            if (!domain) {
+              error('No domain.');
+            }
+            if (!range) {
+              error('No range.');
+            }
+            var lexer = new PostScriptLexer(fn);
+            var parser = new PostScriptParser(lexer);
+            var code = parser.parse();
+            return [
+              CONSTRUCT_POSTSCRIPT,
+              domain,
+              range,
+              code
+            ];
+          },
+          constructPostScriptFromIR: function PDFFunction_constructPostScriptFromIR(IR) {
+            var domain = IR[1];
+            var range = IR[2];
+            var code = IR[3];
+            var compiled = new PostScriptCompiler().compile(code, domain, range);
+            if (compiled) {
+              // Compiled function consists of simple expressions such as addition,
+              // subtraction, Math.max, and also contains 'var' and 'return'
+              // statements. See the generation in the PostScriptCompiler below.
+              return new Function('src', 'srcOffset', 'dest', 'destOffset', compiled);
+            }
+            info('Unable to compile PS function');
+            var numOutputs = range.length >> 1;
+            var numInputs = domain.length >> 1;
+            var evaluator = new PostScriptEvaluator(code);
+            // Cache the values for a big speed up, the cache size is limited though
+            // since the number of possible values can be huge from a PS function.
+            var cache = Object.create(null);
+            // The MAX_CACHE_SIZE is set to ~4x the maximum number of distinct values
+            // seen in our tests.
+            var MAX_CACHE_SIZE = 2048 * 4;
+            var cache_available = MAX_CACHE_SIZE;
+            var tmpBuf = new Float32Array(numInputs);
+            return function constructPostScriptFromIRResult(src, srcOffset, dest, destOffset) {
+              var i, value;
+              var key = '';
+              var input = tmpBuf;
+              for (i = 0; i < numInputs; i++) {
+                value = src[srcOffset + i];
+                input[i] = value;
+                key += value + '_';
+              }
+              var cachedValue = cache[key];
+              if (cachedValue !== undefined) {
+                dest.set(cachedValue, destOffset);
+                return;
+              }
+              var output = new Float32Array(numOutputs);
+              var stack = evaluator.execute(input);
+              var stackIndex = stack.length - numOutputs;
+              for (i = 0; i < numOutputs; i++) {
+                value = stack[stackIndex + i];
+                var bound = range[i * 2];
+                if (value < bound) {
+                  value = bound;
+                } else {
+                  bound = range[i * 2 + 1];
+                  if (value > bound) {
+                    value = bound;
+                  }
+                }
+                output[i] = value;
+              }
+              if (cache_available > 0) {
+                cache_available--;
+                cache[key] = output;
+              }
+              dest.set(output, destOffset);
+            };
+          }
+        };
+      }();
+      function isPDFFunction(v) {
+        var fnDict;
+        if (typeof v !== 'object') {
+          return false;
+        } else if (isDict(v)) {
+          fnDict = v;
+        } else if (isStream(v)) {
+          fnDict = v.dict;
+        } else {
+          return false;
+        }
+        return fnDict.has('FunctionType');
+      }
+      var PostScriptStack = function PostScriptStackClosure() {
+        var MAX_STACK_SIZE = 100;
+        function PostScriptStack(initialStack) {
+          this.stack = !initialStack ? [] : Array.prototype.slice.call(initialStack, 0);
+        }
+        PostScriptStack.prototype = {
+          push: function PostScriptStack_push(value) {
+            if (this.stack.length >= MAX_STACK_SIZE) {
+              error('PostScript function stack overflow.');
+            }
+            this.stack.push(value);
+          },
+          pop: function PostScriptStack_pop() {
+            if (this.stack.length <= 0) {
+              error('PostScript function stack underflow.');
+            }
+            return this.stack.pop();
+          },
+          copy: function PostScriptStack_copy(n) {
+            if (this.stack.length + n >= MAX_STACK_SIZE) {
+              error('PostScript function stack overflow.');
+            }
+            var stack = this.stack;
+            for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
+              stack.push(stack[i]);
+            }
+          },
+          index: function PostScriptStack_index(n) {
+            this.push(this.stack[this.stack.length - n - 1]);
+          },
+          // rotate the last n stack elements p times
+          roll: function PostScriptStack_roll(n, p) {
+            var stack = this.stack;
+            var l = stack.length - n;
+            var r = stack.length - 1, c = l + (p - Math.floor(p / n) * n), i, j, t;
+            for (i = l, j = r; i < j; i++, j--) {
+              t = stack[i];
+              stack[i] = stack[j];
+              stack[j] = t;
+            }
+            for (i = l, j = c - 1; i < j; i++, j--) {
+              t = stack[i];
+              stack[i] = stack[j];
+              stack[j] = t;
+            }
+            for (i = c, j = r; i < j; i++, j--) {
+              t = stack[i];
+              stack[i] = stack[j];
+              stack[j] = t;
+            }
+          }
+        };
+        return PostScriptStack;
+      }();
+      var PostScriptEvaluator = function PostScriptEvaluatorClosure() {
+        function PostScriptEvaluator(operators) {
+          this.operators = operators;
+        }
+        PostScriptEvaluator.prototype = {
+          execute: function PostScriptEvaluator_execute(initialStack) {
+            var stack = new PostScriptStack(initialStack);
+            var counter = 0;
+            var operators = this.operators;
+            var length = operators.length;
+            var operator, a, b;
+            while (counter < length) {
+              operator = operators[counter++];
+              if (typeof operator === 'number') {
+                // Operator is really an operand and should be pushed to the stack.
+                stack.push(operator);
+                continue;
+              }
+              switch (operator) {
+              // non standard ps operators
+              case 'jz':
+                // jump if false
+                b = stack.pop();
+                a = stack.pop();
+                if (!a) {
+                  counter = b;
+                }
+                break;
+              case 'j':
+                // jump
+                a = stack.pop();
+                counter = a;
+                break;
+              // all ps operators in alphabetical order (excluding if/ifelse)
+              case 'abs':
+                a = stack.pop();
+                stack.push(Math.abs(a));
+                break;
+              case 'add':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a + b);
+                break;
+              case 'and':
+                b = stack.pop();
+                a = stack.pop();
+                if (isBool(a) && isBool(b)) {
+                  stack.push(a && b);
+                } else {
+                  stack.push(a & b);
+                }
+                break;
+              case 'atan':
+                a = stack.pop();
+                stack.push(Math.atan(a));
+                break;
+              case 'bitshift':
+                b = stack.pop();
+                a = stack.pop();
+                if (a > 0) {
+                  stack.push(a << b);
+                } else {
+                  stack.push(a >> b);
+                }
+                break;
+              case 'ceiling':
+                a = stack.pop();
+                stack.push(Math.ceil(a));
+                break;
+              case 'copy':
+                a = stack.pop();
+                stack.copy(a);
+                break;
+              case 'cos':
+                a = stack.pop();
+                stack.push(Math.cos(a));
+                break;
+              case 'cvi':
+                a = stack.pop() | 0;
+                stack.push(a);
+                break;
+              case 'cvr':
+                // noop
+                break;
+              case 'div':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a / b);
+                break;
+              case 'dup':
+                stack.copy(1);
+                break;
+              case 'eq':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a === b);
+                break;
+              case 'exch':
+                stack.roll(2, 1);
+                break;
+              case 'exp':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(Math.pow(a, b));
+                break;
+              case 'false':
+                stack.push(false);
+                break;
+              case 'floor':
+                a = stack.pop();
+                stack.push(Math.floor(a));
+                break;
+              case 'ge':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a >= b);
+                break;
+              case 'gt':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a > b);
+                break;
+              case 'idiv':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a / b | 0);
+                break;
+              case 'index':
+                a = stack.pop();
+                stack.index(a);
+                break;
+              case 'le':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a <= b);
+                break;
+              case 'ln':
+                a = stack.pop();
+                stack.push(Math.log(a));
+                break;
+              case 'log':
+                a = stack.pop();
+                stack.push(Math.log(a) / Math.LN10);
+                break;
+              case 'lt':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a < b);
+                break;
+              case 'mod':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a % b);
+                break;
+              case 'mul':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a * b);
+                break;
+              case 'ne':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a !== b);
+                break;
+              case 'neg':
+                a = stack.pop();
+                stack.push(-a);
+                break;
+              case 'not':
+                a = stack.pop();
+                if (isBool(a)) {
+                  stack.push(!a);
+                } else {
+                  stack.push(~a);
+                }
+                break;
+              case 'or':
+                b = stack.pop();
+                a = stack.pop();
+                if (isBool(a) && isBool(b)) {
+                  stack.push(a || b);
+                } else {
+                  stack.push(a | b);
+                }
+                break;
+              case 'pop':
+                stack.pop();
+                break;
+              case 'roll':
+                b = stack.pop();
+                a = stack.pop();
+                stack.roll(a, b);
+                break;
+              case 'round':
+                a = stack.pop();
+                stack.push(Math.round(a));
+                break;
+              case 'sin':
+                a = stack.pop();
+                stack.push(Math.sin(a));
+                break;
+              case 'sqrt':
+                a = stack.pop();
+                stack.push(Math.sqrt(a));
+                break;
+              case 'sub':
+                b = stack.pop();
+                a = stack.pop();
+                stack.push(a - b);
+                break;
+              case 'true':
+                stack.push(true);
+                break;
+              case 'truncate':
+                a = stack.pop();
+                a = a < 0 ? Math.ceil(a) : Math.floor(a);
+                stack.push(a);
+                break;
+              case 'xor':
+                b = stack.pop();
+                a = stack.pop();
+                if (isBool(a) && isBool(b)) {
+                  stack.push(a !== b);
+                } else {
+                  stack.push(a ^ b);
+                }
+                break;
+              default:
+                error('Unknown operator ' + operator);
+                break;
+              }
+            }
+            return stack.stack;
+          }
+        };
+        return PostScriptEvaluator;
+      }();
+      // Most of the PDFs functions consist of simple operations such as:
+      //   roll, exch, sub, cvr, pop, index, dup, mul, if, gt, add.
+      //
+      // We can compile most of such programs, and at the same moment, we can
+      // optimize some expressions using basic math properties. Keeping track of
+      // min/max values will allow us to avoid extra Math.min/Math.max calls.
+      var PostScriptCompiler = function PostScriptCompilerClosure() {
+        function AstNode(type) {
+          this.type = type;
+        }
+        AstNode.prototype.visit = function (visitor) {
+          throw new Error('abstract method');
+        };
+        function AstArgument(index, min, max) {
+          AstNode.call(this, 'args');
+          this.index = index;
+          this.min = min;
+          this.max = max;
+        }
+        AstArgument.prototype = Object.create(AstNode.prototype);
+        AstArgument.prototype.visit = function (visitor) {
+          visitor.visitArgument(this);
+        };
+        function AstLiteral(number) {
+          AstNode.call(this, 'literal');
+          this.number = number;
+          this.min = number;
+          this.max = number;
+        }
+        AstLiteral.prototype = Object.create(AstNode.prototype);
+        AstLiteral.prototype.visit = function (visitor) {
+          visitor.visitLiteral(this);
+        };
+        function AstBinaryOperation(op, arg1, arg2, min, max) {
+          AstNode.call(this, 'binary');
+          this.op = op;
+          this.arg1 = arg1;
+          this.arg2 = arg2;
+          this.min = min;
+          this.max = max;
+        }
+        AstBinaryOperation.prototype = Object.create(AstNode.prototype);
+        AstBinaryOperation.prototype.visit = function (visitor) {
+          visitor.visitBinaryOperation(this);
+        };
+        function AstMin(arg, max) {
+          AstNode.call(this, 'max');
+          this.arg = arg;
+          this.min = arg.min;
+          this.max = max;
+        }
+        AstMin.prototype = Object.create(AstNode.prototype);
+        AstMin.prototype.visit = function (visitor) {
+          visitor.visitMin(this);
+        };
+        function AstVariable(index, min, max) {
+          AstNode.call(this, 'var');
+          this.index = index;
+          this.min = min;
+          this.max = max;
+        }
+        AstVariable.prototype = Object.create(AstNode.prototype);
+        AstVariable.prototype.visit = function (visitor) {
+          visitor.visitVariable(this);
+        };
+        function AstVariableDefinition(variable, arg) {
+          AstNode.call(this, 'definition');
+          this.variable = variable;
+          this.arg = arg;
+        }
+        AstVariableDefinition.prototype = Object.create(AstNode.prototype);
+        AstVariableDefinition.prototype.visit = function (visitor) {
+          visitor.visitVariableDefinition(this);
+        };
+        function ExpressionBuilderVisitor() {
+          this.parts = [];
+        }
+        ExpressionBuilderVisitor.prototype = {
+          visitArgument: function (arg) {
+            this.parts.push('Math.max(', arg.min, ', Math.min(', arg.max, ', src[srcOffset + ', arg.index, ']))');
+          },
+          visitVariable: function (variable) {
+            this.parts.push('v', variable.index);
+          },
+          visitLiteral: function (literal) {
+            this.parts.push(literal.number);
+          },
+          visitBinaryOperation: function (operation) {
+            this.parts.push('(');
+            operation.arg1.visit(this);
+            this.parts.push(' ', operation.op, ' ');
+            operation.arg2.visit(this);
+            this.parts.push(')');
+          },
+          visitVariableDefinition: function (definition) {
+            this.parts.push('var ');
+            definition.variable.visit(this);
+            this.parts.push(' = ');
+            definition.arg.visit(this);
+            this.parts.push(';');
+          },
+          visitMin: function (max) {
+            this.parts.push('Math.min(');
+            max.arg.visit(this);
+            this.parts.push(', ', max.max, ')');
+          },
+          toString: function () {
+            return this.parts.join('');
+          }
+        };
+        function buildAddOperation(num1, num2) {
+          if (num2.type === 'literal' && num2.number === 0) {
+            // optimization: second operand is 0
+            return num1;
+          }
+          if (num1.type === 'literal' && num1.number === 0) {
+            // optimization: first operand is 0
+            return num2;
+          }
+          if (num2.type === 'literal' && num1.type === 'literal') {
+            // optimization: operands operand are literals
+            return new AstLiteral(num1.number + num2.number);
+          }
+          return new AstBinaryOperation('+', num1, num2, num1.min + num2.min, num1.max + num2.max);
+        }
+        function buildMulOperation(num1, num2) {
+          if (num2.type === 'literal') {
+            // optimization: second operands is a literal...
+            if (num2.number === 0) {
+              return new AstLiteral(0);
+            } else // and it's 0
+            if (num2.number === 1) {
+              return num1;
+            } else // and it's 1
+            if (num1.type === 'literal') {
+              // ... and first operands is a literal too
+              return new AstLiteral(num1.number * num2.number);
+            }
+          }
+          if (num1.type === 'literal') {
+            // optimization: first operands is a literal...
+            if (num1.number === 0) {
+              return new AstLiteral(0);
+            } else // and it's 0
+            if (num1.number === 1) {
+              return num2;
+            }
+          }
+          // and it's 1
+          var min = Math.min(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);
+          var max = Math.max(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);
+          return new AstBinaryOperation('*', num1, num2, min, max);
+        }
+        function buildSubOperation(num1, num2) {
+          if (num2.type === 'literal') {
+            // optimization: second operands is a literal...
+            if (num2.number === 0) {
+              return num1;
+            } else // ... and it's 0
+            if (num1.type === 'literal') {
+              // ... and first operands is a literal too
+              return new AstLiteral(num1.number - num2.number);
+            }
+          }
+          if (num2.type === 'binary' && num2.op === '-' && num1.type === 'literal' && num1.number === 1 && num2.arg1.type === 'literal' && num2.arg1.number === 1) {
+            // optimization for case: 1 - (1 - x)
+            return num2.arg2;
+          }
+          return new AstBinaryOperation('-', num1, num2, num1.min - num2.max, num1.max - num2.min);
+        }
+        function buildMinOperation(num1, max) {
+          if (num1.min >= max) {
+            // optimization: num1 min value is not less than required max
+            return new AstLiteral(max);
+          } else // just returning max
+          if (num1.max <= max) {
+            // optimization: num1 max value is not greater than required max
+            return num1;
+          }
+          // just returning an argument
+          return new AstMin(num1, max);
+        }
+        function PostScriptCompiler() {
+        }
+        PostScriptCompiler.prototype = {
+          compile: function PostScriptCompiler_compile(code, domain, range) {
+            var stack = [];
+            var i, ii;
+            var instructions = [];
+            var inputSize = domain.length >> 1, outputSize = range.length >> 1;
+            var lastRegister = 0;
+            var n, j;
+            var num1, num2, ast1, ast2, tmpVar, item;
+            for (i = 0; i < inputSize; i++) {
+              stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));
+            }
+            for (i = 0, ii = code.length; i < ii; i++) {
+              item = code[i];
+              if (typeof item === 'number') {
+                stack.push(new AstLiteral(item));
+                continue;
+              }
+              switch (item) {
+              case 'add':
+                if (stack.length < 2) {
+                  return null;
+                }
+                num2 = stack.pop();
+                num1 = stack.pop();
+                stack.push(buildAddOperation(num1, num2));
+                break;
+              case 'cvr':
+                if (stack.length < 1) {
+                  return null;
+                }
+                break;
+              case 'mul':
+                if (stack.length < 2) {
+                  return null;
+                }
+                num2 = stack.pop();
+                num1 = stack.pop();
+                stack.push(buildMulOperation(num1, num2));
+                break;
+              case 'sub':
+                if (stack.length < 2) {
+                  return null;
+                }
+                num2 = stack.pop();
+                num1 = stack.pop();
+                stack.push(buildSubOperation(num1, num2));
+                break;
+              case 'exch':
+                if (stack.length < 2) {
+                  return null;
+                }
+                ast1 = stack.pop();
+                ast2 = stack.pop();
+                stack.push(ast1, ast2);
+                break;
+              case 'pop':
+                if (stack.length < 1) {
+                  return null;
+                }
+                stack.pop();
+                break;
+              case 'index':
+                if (stack.length < 1) {
+                  return null;
+                }
+                num1 = stack.pop();
+                if (num1.type !== 'literal') {
+                  return null;
+                }
+                n = num1.number;
+                if (n < 0 || (n | 0) !== n || stack.length < n) {
+                  return null;
+                }
+                ast1 = stack[stack.length - n - 1];
+                if (ast1.type === 'literal' || ast1.type === 'var') {
+                  stack.push(ast1);
+                  break;
+                }
+                tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);
+                stack[stack.length - n - 1] = tmpVar;
+                stack.push(tmpVar);
+                instructions.push(new AstVariableDefinition(tmpVar, ast1));
+                break;
+              case 'dup':
+                if (stack.length < 1) {
+                  return null;
+                }
+                if (typeof code[i + 1] === 'number' && code[i + 2] === 'gt' && code[i + 3] === i + 7 && code[i + 4] === 'jz' && code[i + 5] === 'pop' && code[i + 6] === code[i + 1]) {
+                  // special case of the commands sequence for the min operation
+                  num1 = stack.pop();
+                  stack.push(buildMinOperation(num1, code[i + 1]));
+                  i += 6;
+                  break;
+                }
+                ast1 = stack[stack.length - 1];
+                if (ast1.type === 'literal' || ast1.type === 'var') {
+                  // we don't have to save into intermediate variable a literal or
+                  // variable.
+                  stack.push(ast1);
+                  break;
+                }
+                tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);
+                stack[stack.length - 1] = tmpVar;
+                stack.push(tmpVar);
+                instructions.push(new AstVariableDefinition(tmpVar, ast1));
+                break;
+              case 'roll':
+                if (stack.length < 2) {
+                  return null;
+                }
+                num2 = stack.pop();
+                num1 = stack.pop();
+                if (num2.type !== 'literal' || num1.type !== 'literal') {
+                  // both roll operands must be numbers
+                  return null;
+                }
+                j = num2.number;
+                n = num1.number;
+                if (n <= 0 || (n | 0) !== n || (j | 0) !== j || stack.length < n) {
+                  // ... and integers
+                  return null;
+                }
+                j = (j % n + n) % n;
+                if (j === 0) {
+                  break;
+                }
+                // just skipping -- there are nothing to rotate
+                Array.prototype.push.apply(stack, stack.splice(stack.length - n, n - j));
+                break;
+              default:
+                return null;
+              }
+            }
+            // unsupported operator
+            if (stack.length !== outputSize) {
+              return null;
+            }
+            var result = [];
+            instructions.forEach(function (instruction) {
+              var statementBuilder = new ExpressionBuilderVisitor();
+              instruction.visit(statementBuilder);
+              result.push(statementBuilder.toString());
+            });
+            stack.forEach(function (expr, i) {
+              var statementBuilder = new ExpressionBuilderVisitor();
+              expr.visit(statementBuilder);
+              var min = range[i * 2], max = range[i * 2 + 1];
+              var out = [statementBuilder.toString()];
+              if (min > expr.min) {
+                out.unshift('Math.max(', min, ', ');
+                out.push(')');
+              }
+              if (max < expr.max) {
+                out.unshift('Math.min(', max, ', ');
+                out.push(')');
+              }
+              out.unshift('dest[destOffset + ', i, '] = ');
+              out.push(';');
+              result.push(out.join(''));
+            });
+            return result.join('\n');
+          }
+        };
+        return PostScriptCompiler;
+      }();
+      exports.isPDFFunction = isPDFFunction;
+      exports.PDFFunction = PDFFunction;
+      exports.PostScriptEvaluator = PostScriptEvaluator;
+      exports.PostScriptCompiler = PostScriptCompiler;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreColorSpace = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreFunction);
+    }(this, function (exports, sharedUtil, corePrimitives, coreFunction) {
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isString = sharedUtil.isString;
+      var shadow = sharedUtil.shadow;
+      var warn = sharedUtil.warn;
+      var isDict = corePrimitives.isDict;
+      var isName = corePrimitives.isName;
+      var isStream = corePrimitives.isStream;
+      var PDFFunction = coreFunction.PDFFunction;
+      var ColorSpace = function ColorSpaceClosure() {
+        /**
+         * Resizes an RGB image with 3 components.
+         * @param {TypedArray} src - The source buffer.
+         * @param {Number} bpc - Number of bits per component.
+         * @param {Number} w1 - Original width.
+         * @param {Number} h1 - Original height.
+         * @param {Number} w2 - New width.
+         * @param {Number} h2 - New height.
+         * @param {Number} alpha01 - Size reserved for the alpha channel.
+         * @param {TypedArray} dest - The destination buffer.
+         */
+        function resizeRgbImage(src, bpc, w1, h1, w2, h2, alpha01, dest) {
+          var COMPONENTS = 3;
+          alpha01 = alpha01 !== 1 ? 0 : alpha01;
+          var xRatio = w1 / w2;
+          var yRatio = h1 / h2;
+          var i, j, py, newIndex = 0, oldIndex;
+          var xScaled = new Uint16Array(w2);
+          var w1Scanline = w1 * COMPONENTS;
+          for (i = 0; i < w2; i++) {
+            xScaled[i] = Math.floor(i * xRatio) * COMPONENTS;
+          }
+          for (i = 0; i < h2; i++) {
+            py = Math.floor(i * yRatio) * w1Scanline;
+            for (j = 0; j < w2; j++) {
+              oldIndex = py + xScaled[j];
+              dest[newIndex++] = src[oldIndex++];
+              dest[newIndex++] = src[oldIndex++];
+              dest[newIndex++] = src[oldIndex++];
+              newIndex += alpha01;
+            }
+          }
+        }
+        // Constructor should define this.numComps, this.defaultColor, this.name
+        function ColorSpace() {
+          error('should not call ColorSpace constructor');
+        }
+        ColorSpace.prototype = {
+          /**
+           * Converts the color value to the RGB color. The color components are
+           * located in the src array starting from the srcOffset. Returns the array
+           * of the rgb components, each value ranging from [0,255].
+           */
+          getRgb: function ColorSpace_getRgb(src, srcOffset) {
+            var rgb = new Uint8Array(3);
+            this.getRgbItem(src, srcOffset, rgb, 0);
+            return rgb;
+          },
+          /**
+           * Converts the color value to the RGB color, similar to the getRgb method.
+           * The result placed into the dest array starting from the destOffset.
+           */
+          getRgbItem: function ColorSpace_getRgbItem(src, srcOffset, dest, destOffset) {
+            error('Should not call ColorSpace.getRgbItem');
+          },
+          /**
+           * Converts the specified number of the color values to the RGB colors.
+           * The colors are located in the src array starting from the srcOffset.
+           * The result is placed into the dest array starting from the destOffset.
+           * The src array items shall be in [0,2^bits) range, the dest array items
+           * will be in [0,255] range. alpha01 indicates how many alpha components
+           * there are in the dest array; it will be either 0 (RGB array) or 1 (RGBA
+           * array).
+           */
+          getRgbBuffer: function ColorSpace_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            error('Should not call ColorSpace.getRgbBuffer');
+          },
+          /**
+           * Determines the number of bytes required to store the result of the
+           * conversion done by the getRgbBuffer method. As in getRgbBuffer,
+           * |alpha01| is either 0 (RGB output) or 1 (RGBA output).
+           */
+          getOutputLength: function ColorSpace_getOutputLength(inputLength, alpha01) {
+            error('Should not call ColorSpace.getOutputLength');
+          },
+          /**
+           * Returns true if source data will be equal the result/output data.
+           */
+          isPassthrough: function ColorSpace_isPassthrough(bits) {
+            return false;
+          },
+          /**
+           * Fills in the RGB colors in the destination buffer.  alpha01 indicates
+           * how many alpha components there are in the dest array; it will be either
+           * 0 (RGB array) or 1 (RGBA array).
+           */
+          fillRgb: function ColorSpace_fillRgb(dest, originalWidth, originalHeight, width, height, actualHeight, bpc, comps, alpha01) {
+            var count = originalWidth * originalHeight;
+            var rgbBuf = null;
+            var numComponentColors = 1 << bpc;
+            var needsResizing = originalHeight !== height || originalWidth !== width;
+            var i, ii;
+            if (this.isPassthrough(bpc)) {
+              rgbBuf = comps;
+            } else if (this.numComps === 1 && count > numComponentColors && this.name !== 'DeviceGray' && this.name !== 'DeviceRGB') {
+              // Optimization: create a color map when there is just one component and
+              // we are converting more colors than the size of the color map. We
+              // don't build the map if the colorspace is gray or rgb since those
+              // methods are faster than building a map. This mainly offers big speed
+              // ups for indexed and alternate colorspaces.
+              //
+              // TODO it may be worth while to cache the color map. While running
+              // testing I never hit a cache so I will leave that out for now (perhaps
+              // we are reparsing colorspaces too much?).
+              var allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : new Uint16Array(numComponentColors);
+              var key;
+              for (i = 0; i < numComponentColors; i++) {
+                allColors[i] = i;
+              }
+              var colorMap = new Uint8Array(numComponentColors * 3);
+              this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, /* alpha01 = */
+              0);
+              var destPos, rgbPos;
+              if (!needsResizing) {
+                // Fill in the RGB values directly into |dest|.
+                destPos = 0;
+                for (i = 0; i < count; ++i) {
+                  key = comps[i] * 3;
+                  dest[destPos++] = colorMap[key];
+                  dest[destPos++] = colorMap[key + 1];
+                  dest[destPos++] = colorMap[key + 2];
+                  destPos += alpha01;
+                }
+              } else {
+                rgbBuf = new Uint8Array(count * 3);
+                rgbPos = 0;
+                for (i = 0; i < count; ++i) {
+                  key = comps[i] * 3;
+                  rgbBuf[rgbPos++] = colorMap[key];
+                  rgbBuf[rgbPos++] = colorMap[key + 1];
+                  rgbBuf[rgbPos++] = colorMap[key + 2];
+                }
+              }
+            } else {
+              if (!needsResizing) {
+                // Fill in the RGB values directly into |dest|.
+                this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, alpha01);
+              } else {
+                rgbBuf = new Uint8Array(count * 3);
+                this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, /* alpha01 = */
+                0);
+              }
+            }
+            if (rgbBuf) {
+              if (needsResizing) {
+                resizeRgbImage(rgbBuf, bpc, originalWidth, originalHeight, width, height, alpha01, dest);
+              } else {
+                rgbPos = 0;
+                destPos = 0;
+                for (i = 0, ii = width * actualHeight; i < ii; i++) {
+                  dest[destPos++] = rgbBuf[rgbPos++];
+                  dest[destPos++] = rgbBuf[rgbPos++];
+                  dest[destPos++] = rgbBuf[rgbPos++];
+                  destPos += alpha01;
+                }
+              }
+            }
+          },
+          /**
+           * True if the colorspace has components in the default range of [0, 1].
+           * This should be true for all colorspaces except for lab color spaces
+           * which are [0,100], [-128, 127], [-128, 127].
+           */
+          usesZeroToOneRange: true
+        };
+        ColorSpace.parse = function ColorSpace_parse(cs, xref, res) {
+          var IR = ColorSpace.parseToIR(cs, xref, res);
+          if (IR instanceof AlternateCS) {
+            return IR;
+          }
+          return ColorSpace.fromIR(IR);
+        };
+        ColorSpace.fromIR = function ColorSpace_fromIR(IR) {
+          var name = isArray(IR) ? IR[0] : IR;
+          var whitePoint, blackPoint, gamma;
+          switch (name) {
+          case 'DeviceGrayCS':
+            return this.singletons.gray;
+          case 'DeviceRgbCS':
+            return this.singletons.rgb;
+          case 'DeviceCmykCS':
+            return this.singletons.cmyk;
+          case 'CalGrayCS':
+            whitePoint = IR[1];
+            blackPoint = IR[2];
+            gamma = IR[3];
+            return new CalGrayCS(whitePoint, blackPoint, gamma);
+          case 'CalRGBCS':
+            whitePoint = IR[1];
+            blackPoint = IR[2];
+            gamma = IR[3];
+            var matrix = IR[4];
+            return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
+          case 'PatternCS':
+            var basePatternCS = IR[1];
+            if (basePatternCS) {
+              basePatternCS = ColorSpace.fromIR(basePatternCS);
+            }
+            return new PatternCS(basePatternCS);
+          case 'IndexedCS':
+            var baseIndexedCS = IR[1];
+            var hiVal = IR[2];
+            var lookup = IR[3];
+            return new IndexedCS(ColorSpace.fromIR(baseIndexedCS), hiVal, lookup);
+          case 'AlternateCS':
+            var numComps = IR[1];
+            var alt = IR[2];
+            var tintFn = IR[3];
+            return new AlternateCS(numComps, ColorSpace.fromIR(alt), tintFn);
+          case 'LabCS':
+            whitePoint = IR[1];
+            blackPoint = IR[2];
+            var range = IR[3];
+            return new LabCS(whitePoint, blackPoint, range);
+          default:
+            error('Unknown name ' + name);
+          }
+          return null;
+        };
+        ColorSpace.parseToIR = function ColorSpace_parseToIR(cs, xref, res) {
+          if (isName(cs)) {
+            var colorSpaces = res.get('ColorSpace');
+            if (isDict(colorSpaces)) {
+              var refcs = colorSpaces.get(cs.name);
+              if (refcs) {
+                cs = refcs;
+              }
+            }
+          }
+          cs = xref.fetchIfRef(cs);
+          var mode;
+          if (isName(cs)) {
+            mode = cs.name;
+            this.mode = mode;
+            switch (mode) {
+            case 'DeviceGray':
+            case 'G':
+              return 'DeviceGrayCS';
+            case 'DeviceRGB':
+            case 'RGB':
+              return 'DeviceRgbCS';
+            case 'DeviceCMYK':
+            case 'CMYK':
+              return 'DeviceCmykCS';
+            case 'Pattern':
+              return [
+                'PatternCS',
+                null
+              ];
+            default:
+              error('unrecognized colorspace ' + mode);
+            }
+          } else if (isArray(cs)) {
+            mode = xref.fetchIfRef(cs[0]).name;
+            this.mode = mode;
+            var numComps, params, alt, whitePoint, blackPoint, gamma;
+            switch (mode) {
+            case 'DeviceGray':
+            case 'G':
+              return 'DeviceGrayCS';
+            case 'DeviceRGB':
+            case 'RGB':
+              return 'DeviceRgbCS';
+            case 'DeviceCMYK':
+            case 'CMYK':
+              return 'DeviceCmykCS';
+            case 'CalGray':
+              params = xref.fetchIfRef(cs[1]);
+              whitePoint = params.getArray('WhitePoint');
+              blackPoint = params.getArray('BlackPoint');
+              gamma = params.get('Gamma');
+              return [
+                'CalGrayCS',
+                whitePoint,
+                blackPoint,
+                gamma
+              ];
+            case 'CalRGB':
+              params = xref.fetchIfRef(cs[1]);
+              whitePoint = params.getArray('WhitePoint');
+              blackPoint = params.getArray('BlackPoint');
+              gamma = params.getArray('Gamma');
+              var matrix = params.getArray('Matrix');
+              return [
+                'CalRGBCS',
+                whitePoint,
+                blackPoint,
+                gamma,
+                matrix
+              ];
+            case 'ICCBased':
+              var stream = xref.fetchIfRef(cs[1]);
+              var dict = stream.dict;
+              numComps = dict.get('N');
+              alt = dict.get('Alternate');
+              if (alt) {
+                var altIR = ColorSpace.parseToIR(alt, xref, res);
+                // Parse the /Alternate CS to ensure that the number of components
+                // are correct, and also (indirectly) that it is not a PatternCS.
+                var altCS = ColorSpace.fromIR(altIR);
+                if (altCS.numComps === numComps) {
+                  return altIR;
+                }
+                warn('ICCBased color space: Ignoring incorrect /Alternate entry.');
+              }
+              if (numComps === 1) {
+                return 'DeviceGrayCS';
+              } else if (numComps === 3) {
+                return 'DeviceRgbCS';
+              } else if (numComps === 4) {
+                return 'DeviceCmykCS';
+              }
+              break;
+            case 'Pattern':
+              var basePatternCS = cs[1] || null;
+              if (basePatternCS) {
+                basePatternCS = ColorSpace.parseToIR(basePatternCS, xref, res);
+              }
+              return [
+                'PatternCS',
+                basePatternCS
+              ];
+            case 'Indexed':
+            case 'I':
+              var baseIndexedCS = ColorSpace.parseToIR(cs[1], xref, res);
+              var hiVal = xref.fetchIfRef(cs[2]) + 1;
+              var lookup = xref.fetchIfRef(cs[3]);
+              if (isStream(lookup)) {
+                lookup = lookup.getBytes();
+              }
+              return [
+                'IndexedCS',
+                baseIndexedCS,
+                hiVal,
+                lookup
+              ];
+            case 'Separation':
+            case 'DeviceN':
+              var name = xref.fetchIfRef(cs[1]);
+              numComps = 1;
+              if (isName(name)) {
+                numComps = 1;
+              } else if (isArray(name)) {
+                numComps = name.length;
+              }
+              alt = ColorSpace.parseToIR(cs[2], xref, res);
+              var tintFn = PDFFunction.parse(xref, xref.fetchIfRef(cs[3]));
+              return [
+                'AlternateCS',
+                numComps,
+                alt,
+                tintFn
+              ];
+            case 'Lab':
+              params = xref.fetchIfRef(cs[1]);
+              whitePoint = params.getArray('WhitePoint');
+              blackPoint = params.getArray('BlackPoint');
+              var range = params.getArray('Range');
+              return [
+                'LabCS',
+                whitePoint,
+                blackPoint,
+                range
+              ];
+            default:
+              error('unimplemented color space object "' + mode + '"');
+            }
+          } else {
+            error('unrecognized color space object: "' + cs + '"');
+          }
+          return null;
+        };
+        /**
+         * Checks if a decode map matches the default decode map for a color space.
+         * This handles the general decode maps where there are two values per
+         * component. e.g. [0, 1, 0, 1, 0, 1] for a RGB color.
+         * This does not handle Lab, Indexed, or Pattern decode maps since they are
+         * slightly different.
+         * @param {Array} decode Decode map (usually from an image).
+         * @param {Number} n Number of components the color space has.
+         */
+        ColorSpace.isDefaultDecode = function ColorSpace_isDefaultDecode(decode, n) {
+          if (!isArray(decode)) {
+            return true;
+          }
+          if (n * 2 !== decode.length) {
+            warn('The decode map is not the correct length');
+            return true;
+          }
+          for (var i = 0, ii = decode.length; i < ii; i += 2) {
+            if (decode[i] !== 0 || decode[i + 1] !== 1) {
+              return false;
+            }
+          }
+          return true;
+        };
+        ColorSpace.singletons = {
+          get gray() {
+            return shadow(this, 'gray', new DeviceGrayCS());
+          },
+          get rgb() {
+            return shadow(this, 'rgb', new DeviceRgbCS());
+          },
+          get cmyk() {
+            return shadow(this, 'cmyk', new DeviceCmykCS());
+          }
+        };
+        return ColorSpace;
+      }();
+      /**
+       * Alternate color space handles both Separation and DeviceN color spaces.  A
+       * Separation color space is actually just a DeviceN with one color component.
+       * Both color spaces use a tinting function to convert colors to a base color
+       * space.
+       */
+      var AlternateCS = function AlternateCSClosure() {
+        function AlternateCS(numComps, base, tintFn) {
+          this.name = 'Alternate';
+          this.numComps = numComps;
+          this.defaultColor = new Float32Array(numComps);
+          for (var i = 0; i < numComps; ++i) {
+            this.defaultColor[i] = 1;
+          }
+          this.base = base;
+          this.tintFn = tintFn;
+          this.tmpBuf = new Float32Array(base.numComps);
+        }
+        AlternateCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function AlternateCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            var tmpBuf = this.tmpBuf;
+            this.tintFn(src, srcOffset, tmpBuf, 0);
+            this.base.getRgbItem(tmpBuf, 0, dest, destOffset);
+          },
+          getRgbBuffer: function AlternateCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var tintFn = this.tintFn;
+            var base = this.base;
+            var scale = 1 / ((1 << bits) - 1);
+            var baseNumComps = base.numComps;
+            var usesZeroToOneRange = base.usesZeroToOneRange;
+            var isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && alpha01 === 0;
+            var pos = isPassthrough ? destOffset : 0;
+            var baseBuf = isPassthrough ? dest : new Uint8Array(baseNumComps * count);
+            var numComps = this.numComps;
+            var scaled = new Float32Array(numComps);
+            var tinted = new Float32Array(baseNumComps);
+            var i, j;
+            if (usesZeroToOneRange) {
+              for (i = 0; i < count; i++) {
+                for (j = 0; j < numComps; j++) {
+                  scaled[j] = src[srcOffset++] * scale;
+                }
+                tintFn(scaled, 0, tinted, 0);
+                for (j = 0; j < baseNumComps; j++) {
+                  baseBuf[pos++] = tinted[j] * 255;
+                }
+              }
+            } else {
+              for (i = 0; i < count; i++) {
+                for (j = 0; j < numComps; j++) {
+                  scaled[j] = src[srcOffset++] * scale;
+                }
+                tintFn(scaled, 0, tinted, 0);
+                base.getRgbItem(tinted, 0, baseBuf, pos);
+                pos += baseNumComps;
+              }
+            }
+            if (!isPassthrough) {
+              base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);
+            }
+          },
+          getOutputLength: function AlternateCS_getOutputLength(inputLength, alpha01) {
+            return this.base.getOutputLength(inputLength * this.base.numComps / this.numComps, alpha01);
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function AlternateCS_isDefaultDecode(decodeMap) {
+            return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+          },
+          usesZeroToOneRange: true
+        };
+        return AlternateCS;
+      }();
+      var PatternCS = function PatternCSClosure() {
+        function PatternCS(baseCS) {
+          this.name = 'Pattern';
+          this.base = baseCS;
+        }
+        PatternCS.prototype = {};
+        return PatternCS;
+      }();
+      var IndexedCS = function IndexedCSClosure() {
+        function IndexedCS(base, highVal, lookup) {
+          this.name = 'Indexed';
+          this.numComps = 1;
+          this.defaultColor = new Uint8Array([0]);
+          this.base = base;
+          this.highVal = highVal;
+          var baseNumComps = base.numComps;
+          var length = baseNumComps * highVal;
+          var lookupArray;
+          if (isStream(lookup)) {
+            lookupArray = new Uint8Array(length);
+            var bytes = lookup.getBytes(length);
+            lookupArray.set(bytes);
+          } else if (isString(lookup)) {
+            lookupArray = new Uint8Array(length);
+            for (var i = 0; i < length; ++i) {
+              lookupArray[i] = lookup.charCodeAt(i);
+            }
+          } else if (lookup instanceof Uint8Array || lookup instanceof Array) {
+            lookupArray = lookup;
+          } else {
+            error('Unrecognized lookup table: ' + lookup);
+          }
+          this.lookup = lookupArray;
+        }
+        IndexedCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function IndexedCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            var numComps = this.base.numComps;
+            var start = src[srcOffset] * numComps;
+            this.base.getRgbItem(this.lookup, start, dest, destOffset);
+          },
+          getRgbBuffer: function IndexedCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var base = this.base;
+            var numComps = base.numComps;
+            var outputDelta = base.getOutputLength(numComps, alpha01);
+            var lookup = this.lookup;
+            for (var i = 0; i < count; ++i) {
+              var lookupPos = src[srcOffset++] * numComps;
+              base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);
+              destOffset += outputDelta;
+            }
+          },
+          getOutputLength: function IndexedCS_getOutputLength(inputLength, alpha01) {
+            return this.base.getOutputLength(inputLength * this.base.numComps, alpha01);
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function IndexedCS_isDefaultDecode(decodeMap) {
+            // indexed color maps shouldn't be changed
+            return true;
+          },
+          usesZeroToOneRange: true
+        };
+        return IndexedCS;
+      }();
+      var DeviceGrayCS = function DeviceGrayCSClosure() {
+        function DeviceGrayCS() {
+          this.name = 'DeviceGray';
+          this.numComps = 1;
+          this.defaultColor = new Float32Array([0]);
+        }
+        DeviceGrayCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function DeviceGrayCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            var c = src[srcOffset] * 255 | 0;
+            c = c < 0 ? 0 : c > 255 ? 255 : c;
+            dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;
+          },
+          getRgbBuffer: function DeviceGrayCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var scale = 255 / ((1 << bits) - 1);
+            var j = srcOffset, q = destOffset;
+            for (var i = 0; i < count; ++i) {
+              var c = scale * src[j++] | 0;
+              dest[q++] = c;
+              dest[q++] = c;
+              dest[q++] = c;
+              q += alpha01;
+            }
+          },
+          getOutputLength: function DeviceGrayCS_getOutputLength(inputLength, alpha01) {
+            return inputLength * (3 + alpha01);
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function DeviceGrayCS_isDefaultDecode(decodeMap) {
+            return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+          },
+          usesZeroToOneRange: true
+        };
+        return DeviceGrayCS;
+      }();
+      var DeviceRgbCS = function DeviceRgbCSClosure() {
+        function DeviceRgbCS() {
+          this.name = 'DeviceRGB';
+          this.numComps = 3;
+          this.defaultColor = new Float32Array([
+            0,
+            0,
+            0
+          ]);
+        }
+        DeviceRgbCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function DeviceRgbCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            var r = src[srcOffset] * 255 | 0;
+            var g = src[srcOffset + 1] * 255 | 0;
+            var b = src[srcOffset + 2] * 255 | 0;
+            dest[destOffset] = r < 0 ? 0 : r > 255 ? 255 : r;
+            dest[destOffset + 1] = g < 0 ? 0 : g > 255 ? 255 : g;
+            dest[destOffset + 2] = b < 0 ? 0 : b > 255 ? 255 : b;
+          },
+          getRgbBuffer: function DeviceRgbCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            if (bits === 8 && alpha01 === 0) {
+              dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);
+              return;
+            }
+            var scale = 255 / ((1 << bits) - 1);
+            var j = srcOffset, q = destOffset;
+            for (var i = 0; i < count; ++i) {
+              dest[q++] = scale * src[j++] | 0;
+              dest[q++] = scale * src[j++] | 0;
+              dest[q++] = scale * src[j++] | 0;
+              q += alpha01;
+            }
+          },
+          getOutputLength: function DeviceRgbCS_getOutputLength(inputLength, alpha01) {
+            return inputLength * (3 + alpha01) / 3 | 0;
+          },
+          isPassthrough: function DeviceRgbCS_isPassthrough(bits) {
+            return bits === 8;
+          },
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function DeviceRgbCS_isDefaultDecode(decodeMap) {
+            return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+          },
+          usesZeroToOneRange: true
+        };
+        return DeviceRgbCS;
+      }();
+      var DeviceCmykCS = function DeviceCmykCSClosure() {
+        // The coefficients below was found using numerical analysis: the method of
+        // steepest descent for the sum((f_i - color_value_i)^2) for r/g/b colors,
+        // where color_value is the tabular value from the table of sampled RGB colors
+        // from CMYK US Web Coated (SWOP) colorspace, and f_i is the corresponding
+        // CMYK color conversion using the estimation below:
+        //   f(A, B,.. N) = Acc+Bcm+Ccy+Dck+c+Fmm+Gmy+Hmk+Im+Jyy+Kyk+Ly+Mkk+Nk+255
+        function convertToRgb(src, srcOffset, srcScale, dest, destOffset) {
+          var c = src[srcOffset + 0] * srcScale;
+          var m = src[srcOffset + 1] * srcScale;
+          var y = src[srcOffset + 2] * srcScale;
+          var k = src[srcOffset + 3] * srcScale;
+          var r = c * (-4.387332384609988 * c + 54.48615194189176 * m + 18.82290502165302 * y + 212.25662451639585 * k + -285.2331026137004) + m * (1.7149763477362134 * m - 5.6096736904047315 * y + -17.873870861415444 * k - 5.497006427196366) + y * (-2.5217340131683033 * y - 21.248923337353073 * k + 17.5119270841813) + k * (-21.86122147463605 * k - 189.48180835922747) + 255 | 0;
+          var g = c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k + -79.2970844816548) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) + k * (-20.737325471181034 * k - 187.80453709719578) + 255 | 0;
+          var b = c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k + -14.183576799673286) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) + y * (0.03296041114873217 * y + 115.60384449646641 * k + -193.58209356861505) + k * (-22.33816807309886 * k - 180.12613974708367) + 255 | 0;
+          dest[destOffset] = r > 255 ? 255 : r < 0 ? 0 : r;
+          dest[destOffset + 1] = g > 255 ? 255 : g < 0 ? 0 : g;
+          dest[destOffset + 2] = b > 255 ? 255 : b < 0 ? 0 : b;
+        }
+        function DeviceCmykCS() {
+          this.name = 'DeviceCMYK';
+          this.numComps = 4;
+          this.defaultColor = new Float32Array([
+            0,
+            0,
+            0,
+            1
+          ]);
+        }
+        DeviceCmykCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function DeviceCmykCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            convertToRgb(src, srcOffset, 1, dest, destOffset);
+          },
+          getRgbBuffer: function DeviceCmykCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var scale = 1 / ((1 << bits) - 1);
+            for (var i = 0; i < count; i++) {
+              convertToRgb(src, srcOffset, scale, dest, destOffset);
+              srcOffset += 4;
+              destOffset += 3 + alpha01;
+            }
+          },
+          getOutputLength: function DeviceCmykCS_getOutputLength(inputLength, alpha01) {
+            return inputLength / 4 * (3 + alpha01) | 0;
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function DeviceCmykCS_isDefaultDecode(decodeMap) {
+            return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+          },
+          usesZeroToOneRange: true
+        };
+        return DeviceCmykCS;
+      }();
+      //
+      // CalGrayCS: Based on "PDF Reference, Sixth Ed", p.245
+      //
+      var CalGrayCS = function CalGrayCSClosure() {
+        function CalGrayCS(whitePoint, blackPoint, gamma) {
+          this.name = 'CalGray';
+          this.numComps = 1;
+          this.defaultColor = new Float32Array([0]);
+          if (!whitePoint) {
+            error('WhitePoint missing - required for color space CalGray');
+          }
+          blackPoint = blackPoint || [
+            0,
+            0,
+            0
+          ];
+          gamma = gamma || 1;
+          // Translate arguments to spec variables.
+          this.XW = whitePoint[0];
+          this.YW = whitePoint[1];
+          this.ZW = whitePoint[2];
+          this.XB = blackPoint[0];
+          this.YB = blackPoint[1];
+          this.ZB = blackPoint[2];
+          this.G = gamma;
+          // Validate variables as per spec.
+          if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
+            error('Invalid WhitePoint components for ' + this.name + ', no fallback available');
+          }
+          if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
+            info('Invalid BlackPoint for ' + this.name + ', falling back to default');
+            this.XB = this.YB = this.ZB = 0;
+          }
+          if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {
+            warn(this.name + ', BlackPoint: XB: ' + this.XB + ', YB: ' + this.YB + ', ZB: ' + this.ZB + ', only default values are supported.');
+          }
+          if (this.G < 1) {
+            info('Invalid Gamma: ' + this.G + ' for ' + this.name + ', falling back to default');
+            this.G = 1;
+          }
+        }
+        function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
+          // A represents a gray component of a calibrated gray space.
+          // A <---> AG in the spec
+          var A = src[srcOffset] * scale;
+          var AG = Math.pow(A, cs.G);
+          // Computes L as per spec. ( = cs.YW * AG )
+          // Except if other than default BlackPoint values are used.
+          var L = cs.YW * AG;
+          // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html, Ch 4.
+          // Convert values to rgb range [0, 255].
+          var val = Math.max(295.8 * Math.pow(L, 0.333333333333333333) - 40.8, 0) | 0;
+          dest[destOffset] = val;
+          dest[destOffset + 1] = val;
+          dest[destOffset + 2] = val;
+        }
+        CalGrayCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function CalGrayCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            convertToRgb(this, src, srcOffset, dest, destOffset, 1);
+          },
+          getRgbBuffer: function CalGrayCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var scale = 1 / ((1 << bits) - 1);
+            for (var i = 0; i < count; ++i) {
+              convertToRgb(this, src, srcOffset, dest, destOffset, scale);
+              srcOffset += 1;
+              destOffset += 3 + alpha01;
+            }
+          },
+          getOutputLength: function CalGrayCS_getOutputLength(inputLength, alpha01) {
+            return inputLength * (3 + alpha01);
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function CalGrayCS_isDefaultDecode(decodeMap) {
+            return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+          },
+          usesZeroToOneRange: true
+        };
+        return CalGrayCS;
+      }();
+      //
+      // CalRGBCS: Based on "PDF Reference, Sixth Ed", p.247
+      //
+      var CalRGBCS = function CalRGBCSClosure() {
+        // See http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html for these
+        // matrices.
+        var BRADFORD_SCALE_MATRIX = new Float32Array([
+          0.8951,
+          0.2664,
+          -0.1614,
+          -0.7502,
+          1.7135,
+          0.0367,
+          0.0389,
+          -0.0685,
+          1.0296
+        ]);
+        var BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([
+          0.9869929,
+          -0.1470543,
+          0.1599627,
+          0.4323053,
+          0.5183603,
+          0.0492912,
+          -0.0085287,
+          0.0400428,
+          0.9684867
+        ]);
+        // See http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html.
+        var SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([
+          3.2404542,
+          -1.5371385,
+          -0.4985314,
+          -0.9692660,
+          1.8760108,
+          0.0415560,
+          0.0556434,
+          -0.2040259,
+          1.0572252
+        ]);
+        var FLAT_WHITEPOINT_MATRIX = new Float32Array([
+          1,
+          1,
+          1
+        ]);
+        var tempNormalizeMatrix = new Float32Array(3);
+        var tempConvertMatrix1 = new Float32Array(3);
+        var tempConvertMatrix2 = new Float32Array(3);
+        var DECODE_L_CONSTANT = Math.pow((8 + 16) / 116, 3) / 8.0;
+        function CalRGBCS(whitePoint, blackPoint, gamma, matrix) {
+          this.name = 'CalRGB';
+          this.numComps = 3;
+          this.defaultColor = new Float32Array(3);
+          if (!whitePoint) {
+            error('WhitePoint missing - required for color space CalRGB');
+          }
+          blackPoint = blackPoint || new Float32Array(3);
+          gamma = gamma || new Float32Array([
+            1,
+            1,
+            1
+          ]);
+          matrix = matrix || new Float32Array([
+            1,
+            0,
+            0,
+            0,
+            1,
+            0,
+            0,
+            0,
+            1
+          ]);
+          // Translate arguments to spec variables.
+          var XW = whitePoint[0];
+          var YW = whitePoint[1];
+          var ZW = whitePoint[2];
+          this.whitePoint = whitePoint;
+          var XB = blackPoint[0];
+          var YB = blackPoint[1];
+          var ZB = blackPoint[2];
+          this.blackPoint = blackPoint;
+          this.GR = gamma[0];
+          this.GG = gamma[1];
+          this.GB = gamma[2];
+          this.MXA = matrix[0];
+          this.MYA = matrix[1];
+          this.MZA = matrix[2];
+          this.MXB = matrix[3];
+          this.MYB = matrix[4];
+          this.MZB = matrix[5];
+          this.MXC = matrix[6];
+          this.MYC = matrix[7];
+          this.MZC = matrix[8];
+          // Validate variables as per spec.
+          if (XW < 0 || ZW < 0 || YW !== 1) {
+            error('Invalid WhitePoint components for ' + this.name + ', no fallback available');
+          }
+          if (XB < 0 || YB < 0 || ZB < 0) {
+            info('Invalid BlackPoint for ' + this.name + ' [' + XB + ', ' + YB + ', ' + ZB + '], falling back to default');
+            this.blackPoint = new Float32Array(3);
+          }
+          if (this.GR < 0 || this.GG < 0 || this.GB < 0) {
+            info('Invalid Gamma [' + this.GR + ', ' + this.GG + ', ' + this.GB + '] for ' + this.name + ', falling back to default');
+            this.GR = this.GG = this.GB = 1;
+          }
+          if (this.MXA < 0 || this.MYA < 0 || this.MZA < 0 || this.MXB < 0 || this.MYB < 0 || this.MZB < 0 || this.MXC < 0 || this.MYC < 0 || this.MZC < 0) {
+            info('Invalid Matrix for ' + this.name + ' [' + this.MXA + ', ' + this.MYA + ', ' + this.MZA + this.MXB + ', ' + this.MYB + ', ' + this.MZB + this.MXC + ', ' + this.MYC + ', ' + this.MZC + '], falling back to default');
+            this.MXA = this.MYB = this.MZC = 1;
+            this.MXB = this.MYA = this.MZA = this.MXC = this.MYC = this.MZB = 0;
+          }
+        }
+        function matrixProduct(a, b, result) {
+          result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+          result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2];
+          result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2];
+        }
+        function convertToFlat(sourceWhitePoint, LMS, result) {
+          result[0] = LMS[0] * 1 / sourceWhitePoint[0];
+          result[1] = LMS[1] * 1 / sourceWhitePoint[1];
+          result[2] = LMS[2] * 1 / sourceWhitePoint[2];
+        }
+        function convertToD65(sourceWhitePoint, LMS, result) {
+          var D65X = 0.95047;
+          var D65Y = 1;
+          var D65Z = 1.08883;
+          result[0] = LMS[0] * D65X / sourceWhitePoint[0];
+          result[1] = LMS[1] * D65Y / sourceWhitePoint[1];
+          result[2] = LMS[2] * D65Z / sourceWhitePoint[2];
+        }
+        function sRGBTransferFunction(color) {
+          // See http://en.wikipedia.org/wiki/SRGB.
+          if (color <= 0.0031308) {
+            return adjustToRange(0, 1, 12.92 * color);
+          }
+          return adjustToRange(0, 1, (1 + 0.055) * Math.pow(color, 1 / 2.4) - 0.055);
+        }
+        function adjustToRange(min, max, value) {
+          return Math.max(min, Math.min(max, value));
+        }
+        function decodeL(L) {
+          if (L < 0) {
+            return -decodeL(-L);
+          }
+          if (L > 8.0) {
+            return Math.pow((L + 16) / 116, 3);
+          }
+          return L * DECODE_L_CONSTANT;
+        }
+        function compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) {
+          // In case the blackPoint is already the default blackPoint then there is
+          // no need to do compensation.
+          if (sourceBlackPoint[0] === 0 && sourceBlackPoint[1] === 0 && sourceBlackPoint[2] === 0) {
+            result[0] = XYZ_Flat[0];
+            result[1] = XYZ_Flat[1];
+            result[2] = XYZ_Flat[2];
+            return;
+          }
+          // For the blackPoint calculation details, please see
+          // http://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/
+          // AdobeBPC.pdf.
+          // The destination blackPoint is the default blackPoint [0, 0, 0].
+          var zeroDecodeL = decodeL(0);
+          var X_DST = zeroDecodeL;
+          var X_SRC = decodeL(sourceBlackPoint[0]);
+          var Y_DST = zeroDecodeL;
+          var Y_SRC = decodeL(sourceBlackPoint[1]);
+          var Z_DST = zeroDecodeL;
+          var Z_SRC = decodeL(sourceBlackPoint[2]);
+          var X_Scale = (1 - X_DST) / (1 - X_SRC);
+          var X_Offset = 1 - X_Scale;
+          var Y_Scale = (1 - Y_DST) / (1 - Y_SRC);
+          var Y_Offset = 1 - Y_Scale;
+          var Z_Scale = (1 - Z_DST) / (1 - Z_SRC);
+          var Z_Offset = 1 - Z_Scale;
+          result[0] = XYZ_Flat[0] * X_Scale + X_Offset;
+          result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset;
+          result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset;
+        }
+        function normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) {
+          // In case the whitePoint is already flat then there is no need to do
+          // normalization.
+          if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) {
+            result[0] = XYZ_In[0];
+            result[1] = XYZ_In[1];
+            result[2] = XYZ_In[2];
+            return;
+          }
+          var LMS = result;
+          matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
+          var LMS_Flat = tempNormalizeMatrix;
+          convertToFlat(sourceWhitePoint, LMS, LMS_Flat);
+          matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result);
+        }
+        function normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) {
+          var LMS = result;
+          matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS);
+          var LMS_D65 = tempNormalizeMatrix;
+          convertToD65(sourceWhitePoint, LMS, LMS_D65);
+          matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result);
+        }
+        function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {
+          // A, B and C represent a red, green and blue components of a calibrated
+          // rgb space.
+          var A = adjustToRange(0, 1, src[srcOffset] * scale);
+          var B = adjustToRange(0, 1, src[srcOffset + 1] * scale);
+          var C = adjustToRange(0, 1, src[srcOffset + 2] * scale);
+          // A <---> AGR in the spec
+          // B <---> BGG in the spec
+          // C <---> CGB in the spec
+          var AGR = Math.pow(A, cs.GR);
+          var BGG = Math.pow(B, cs.GG);
+          var CGB = Math.pow(C, cs.GB);
+          // Computes intermediate variables L, M, N as per spec.
+          // To decode X, Y, Z values map L, M, N directly to them.
+          var X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB;
+          var Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB;
+          var Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB;
+          // The following calculations are based on this document:
+          // http://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/
+          // AdobeBPC.pdf.
+          var XYZ = tempConvertMatrix1;
+          XYZ[0] = X;
+          XYZ[1] = Y;
+          XYZ[2] = Z;
+          var XYZ_Flat = tempConvertMatrix2;
+          normalizeWhitePointToFlat(cs.whitePoint, XYZ, XYZ_Flat);
+          var XYZ_Black = tempConvertMatrix1;
+          compensateBlackPoint(cs.blackPoint, XYZ_Flat, XYZ_Black);
+          var XYZ_D65 = tempConvertMatrix2;
+          normalizeWhitePointToD65(FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65);
+          var SRGB = tempConvertMatrix1;
+          matrixProduct(SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB);
+          var sR = sRGBTransferFunction(SRGB[0]);
+          var sG = sRGBTransferFunction(SRGB[1]);
+          var sB = sRGBTransferFunction(SRGB[2]);
+          // Convert the values to rgb range [0, 255].
+          dest[destOffset] = Math.round(sR * 255);
+          dest[destOffset + 1] = Math.round(sG * 255);
+          dest[destOffset + 2] = Math.round(sB * 255);
+        }
+        CalRGBCS.prototype = {
+          getRgb: function CalRGBCS_getRgb(src, srcOffset) {
+            var rgb = new Uint8Array(3);
+            this.getRgbItem(src, srcOffset, rgb, 0);
+            return rgb;
+          },
+          getRgbItem: function CalRGBCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            convertToRgb(this, src, srcOffset, dest, destOffset, 1);
+          },
+          getRgbBuffer: function CalRGBCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var scale = 1 / ((1 << bits) - 1);
+            for (var i = 0; i < count; ++i) {
+              convertToRgb(this, src, srcOffset, dest, destOffset, scale);
+              srcOffset += 3;
+              destOffset += 3 + alpha01;
+            }
+          },
+          getOutputLength: function CalRGBCS_getOutputLength(inputLength, alpha01) {
+            return inputLength * (3 + alpha01) / 3 | 0;
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function CalRGBCS_isDefaultDecode(decodeMap) {
+            return ColorSpace.isDefaultDecode(decodeMap, this.numComps);
+          },
+          usesZeroToOneRange: true
+        };
+        return CalRGBCS;
+      }();
+      //
+      // LabCS: Based on "PDF Reference, Sixth Ed", p.250
+      //
+      var LabCS = function LabCSClosure() {
+        function LabCS(whitePoint, blackPoint, range) {
+          this.name = 'Lab';
+          this.numComps = 3;
+          this.defaultColor = new Float32Array([
+            0,
+            0,
+            0
+          ]);
+          if (!whitePoint) {
+            error('WhitePoint missing - required for color space Lab');
+          }
+          blackPoint = blackPoint || [
+            0,
+            0,
+            0
+          ];
+          range = range || [
+            -100,
+            100,
+            -100,
+            100
+          ];
+          // Translate args to spec variables
+          this.XW = whitePoint[0];
+          this.YW = whitePoint[1];
+          this.ZW = whitePoint[2];
+          this.amin = range[0];
+          this.amax = range[1];
+          this.bmin = range[2];
+          this.bmax = range[3];
+          // These are here just for completeness - the spec doesn't offer any
+          // formulas that use BlackPoint in Lab
+          this.XB = blackPoint[0];
+          this.YB = blackPoint[1];
+          this.ZB = blackPoint[2];
+          // Validate vars as per spec
+          if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {
+            error('Invalid WhitePoint components, no fallback available');
+          }
+          if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {
+            info('Invalid BlackPoint, falling back to default');
+            this.XB = this.YB = this.ZB = 0;
+          }
+          if (this.amin > this.amax || this.bmin > this.bmax) {
+            info('Invalid Range, falling back to defaults');
+            this.amin = -100;
+            this.amax = 100;
+            this.bmin = -100;
+            this.bmax = 100;
+          }
+        }
+        // Function g(x) from spec
+        function fn_g(x) {
+          if (x >= 6 / 29) {
+            return x * x * x;
+          } else {
+            return 108 / 841 * (x - 4 / 29);
+          }
+        }
+        function decode(value, high1, low2, high2) {
+          return low2 + value * (high2 - low2) / high1;
+        }
+        // If decoding is needed maxVal should be 2^bits per component - 1.
+        function convertToRgb(cs, src, srcOffset, maxVal, dest, destOffset) {
+          // XXX: Lab input is in the range of [0, 100], [amin, amax], [bmin, bmax]
+          // not the usual [0, 1]. If a command like setFillColor is used the src
+          // values will already be within the correct range. However, if we are
+          // converting an image we have to map the values to the correct range given
+          // above.
+          // Ls,as,bs <---> L*,a*,b* in the spec
+          var Ls = src[srcOffset];
+          var as = src[srcOffset + 1];
+          var bs = src[srcOffset + 2];
+          if (maxVal !== false) {
+            Ls = decode(Ls, maxVal, 0, 100);
+            as = decode(as, maxVal, cs.amin, cs.amax);
+            bs = decode(bs, maxVal, cs.bmin, cs.bmax);
+          }
+          // Adjust limits of 'as' and 'bs'
+          as = as > cs.amax ? cs.amax : as < cs.amin ? cs.amin : as;
+          bs = bs > cs.bmax ? cs.bmax : bs < cs.bmin ? cs.bmin : bs;
+          // Computes intermediate variables X,Y,Z as per spec
+          var M = (Ls + 16) / 116;
+          var L = M + as / 500;
+          var N = M - bs / 200;
+          var X = cs.XW * fn_g(L);
+          var Y = cs.YW * fn_g(M);
+          var Z = cs.ZW * fn_g(N);
+          var r, g, b;
+          // Using different conversions for D50 and D65 white points,
+          // per http://www.color.org/srgb.pdf
+          if (cs.ZW < 1) {
+            // Assuming D50 (X=0.9642, Y=1.00, Z=0.8249)
+            r = X * 3.1339 + Y * -1.6170 + Z * -0.4906;
+            g = X * -0.9785 + Y * 1.9160 + Z * 0.0333;
+            b = X * 0.0720 + Y * -0.2290 + Z * 1.4057;
+          } else {
+            // Assuming D65 (X=0.9505, Y=1.00, Z=1.0888)
+            r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;
+            g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;
+            b = X * 0.0557 + Y * -0.2040 + Z * 1.0570;
+          }
+          // clamp color values to [0,1] range then convert to [0,255] range.
+          dest[destOffset] = r <= 0 ? 0 : r >= 1 ? 255 : Math.sqrt(r) * 255 | 0;
+          dest[destOffset + 1] = g <= 0 ? 0 : g >= 1 ? 255 : Math.sqrt(g) * 255 | 0;
+          dest[destOffset + 2] = b <= 0 ? 0 : b >= 1 ? 255 : Math.sqrt(b) * 255 | 0;
+        }
+        LabCS.prototype = {
+          getRgb: ColorSpace.prototype.getRgb,
+          getRgbItem: function LabCS_getRgbItem(src, srcOffset, dest, destOffset) {
+            convertToRgb(this, src, srcOffset, false, dest, destOffset);
+          },
+          getRgbBuffer: function LabCS_getRgbBuffer(src, srcOffset, count, dest, destOffset, bits, alpha01) {
+            var maxVal = (1 << bits) - 1;
+            for (var i = 0; i < count; i++) {
+              convertToRgb(this, src, srcOffset, maxVal, dest, destOffset);
+              srcOffset += 3;
+              destOffset += 3 + alpha01;
+            }
+          },
+          getOutputLength: function LabCS_getOutputLength(inputLength, alpha01) {
+            return inputLength * (3 + alpha01) / 3 | 0;
+          },
+          isPassthrough: ColorSpace.prototype.isPassthrough,
+          fillRgb: ColorSpace.prototype.fillRgb,
+          isDefaultDecode: function LabCS_isDefaultDecode(decodeMap) {
+            // XXX: Decoding is handled with the lab conversion because of the strange
+            // ranges that are used.
+            return true;
+          },
+          usesZeroToOneRange: false
+        };
+        return LabCS;
+      }();
+      exports.ColorSpace = ColorSpace;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreImage = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreColorSpace, root.pdfjsCoreStream, root.pdfjsCoreJpx);
+    }(this, function (exports, sharedUtil, corePrimitives, coreColorSpace, coreStream, coreJpx) {
+      var ImageKind = sharedUtil.ImageKind;
+      var assert = sharedUtil.assert;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var warn = sharedUtil.warn;
+      var Name = corePrimitives.Name;
+      var isStream = corePrimitives.isStream;
+      var ColorSpace = coreColorSpace.ColorSpace;
+      var DecodeStream = coreStream.DecodeStream;
+      var JpegStream = coreStream.JpegStream;
+      var JpxImage = coreJpx.JpxImage;
+      var PDFImage = function PDFImageClosure() {
+        /**
+         * Decodes the image using native decoder if possible. Resolves the promise
+         * when the image data is ready.
+         */
+        function handleImageData(image, nativeDecoder) {
+          if (nativeDecoder && nativeDecoder.canDecode(image)) {
+            return nativeDecoder.decode(image);
+          } else {
+            return Promise.resolve(image);
+          }
+        }
+        /**
+         * Decode and clamp a value. The formula is different from the spec because we
+         * don't decode to float range [0,1], we decode it in the [0,max] range.
+         */
+        function decodeAndClamp(value, addend, coefficient, max) {
+          value = addend + value * coefficient;
+          // Clamp the value to the range
+          return value < 0 ? 0 : value > max ? max : value;
+        }
+        /**
+         * Resizes an image mask with 1 component.
+         * @param {TypedArray} src - The source buffer.
+         * @param {Number} bpc - Number of bits per component.
+         * @param {Number} w1 - Original width.
+         * @param {Number} h1 - Original height.
+         * @param {Number} w2 - New width.
+         * @param {Number} h2 - New height.
+         * @returns {TypedArray} The resized image mask buffer.
+         */
+        function resizeImageMask(src, bpc, w1, h1, w2, h2) {
+          var length = w2 * h2;
+          var dest = bpc <= 8 ? new Uint8Array(length) : bpc <= 16 ? new Uint16Array(length) : new Uint32Array(length);
+          var xRatio = w1 / w2;
+          var yRatio = h1 / h2;
+          var i, j, py, newIndex = 0, oldIndex;
+          var xScaled = new Uint16Array(w2);
+          var w1Scanline = w1;
+          for (i = 0; i < w2; i++) {
+            xScaled[i] = Math.floor(i * xRatio);
+          }
+          for (i = 0; i < h2; i++) {
+            py = Math.floor(i * yRatio) * w1Scanline;
+            for (j = 0; j < w2; j++) {
+              oldIndex = py + xScaled[j];
+              dest[newIndex++] = src[oldIndex];
+            }
+          }
+          return dest;
+        }
+        function PDFImage(xref, res, image, inline, smask, mask, isMask) {
+          this.image = image;
+          var dict = image.dict;
+          if (dict.has('Filter')) {
+            var filter = dict.get('Filter').name;
+            if (filter === 'JPXDecode') {
+              var jpxImage = new JpxImage();
+              jpxImage.parseImageProperties(image.stream);
+              image.stream.reset();
+              image.bitsPerComponent = jpxImage.bitsPerComponent;
+              image.numComps = jpxImage.componentsCount;
+            } else if (filter === 'JBIG2Decode') {
+              image.bitsPerComponent = 1;
+              image.numComps = 1;
+            }
+          }
+          // TODO cache rendered images?
+          this.width = dict.get('Width', 'W');
+          this.height = dict.get('Height', 'H');
+          if (this.width < 1 || this.height < 1) {
+            error('Invalid image width: ' + this.width + ' or height: ' + this.height);
+          }
+          this.interpolate = dict.get('Interpolate', 'I') || false;
+          this.imageMask = dict.get('ImageMask', 'IM') || false;
+          this.matte = dict.get('Matte') || false;
+          var bitsPerComponent = image.bitsPerComponent;
+          if (!bitsPerComponent) {
+            bitsPerComponent = dict.get('BitsPerComponent', 'BPC');
+            if (!bitsPerComponent) {
+              if (this.imageMask) {
+                bitsPerComponent = 1;
+              } else {
+                error('Bits per component missing in image: ' + this.imageMask);
+              }
+            }
+          }
+          this.bpc = bitsPerComponent;
+          if (!this.imageMask) {
+            var colorSpace = dict.get('ColorSpace', 'CS');
+            if (!colorSpace) {
+              info('JPX images (which do not require color spaces)');
+              switch (image.numComps) {
+              case 1:
+                colorSpace = Name.get('DeviceGray');
+                break;
+              case 3:
+                colorSpace = Name.get('DeviceRGB');
+                break;
+              case 4:
+                colorSpace = Name.get('DeviceCMYK');
+                break;
+              default:
+                error('JPX images with ' + this.numComps + ' color components not supported.');
+              }
+            }
+            this.colorSpace = ColorSpace.parse(colorSpace, xref, res);
+            this.numComps = this.colorSpace.numComps;
+          }
+          this.decode = dict.getArray('Decode', 'D');
+          this.needsDecode = false;
+          if (this.decode && (this.colorSpace && !this.colorSpace.isDefaultDecode(this.decode) || isMask && !ColorSpace.isDefaultDecode(this.decode, 1))) {
+            this.needsDecode = true;
+            // Do some preprocessing to avoid more math.
+            var max = (1 << bitsPerComponent) - 1;
+            this.decodeCoefficients = [];
+            this.decodeAddends = [];
+            for (var i = 0, j = 0; i < this.decode.length; i += 2, ++j) {
+              var dmin = this.decode[i];
+              var dmax = this.decode[i + 1];
+              this.decodeCoefficients[j] = dmax - dmin;
+              this.decodeAddends[j] = max * dmin;
+            }
+          }
+          if (smask) {
+            this.smask = new PDFImage(xref, res, smask, false);
+          } else if (mask) {
+            if (isStream(mask)) {
+              var maskDict = mask.dict, imageMask = maskDict.get('ImageMask', 'IM');
+              if (!imageMask) {
+                warn('Ignoring /Mask in image without /ImageMask.');
+              } else {
+                this.mask = new PDFImage(xref, res, mask, false, null, null, true);
+              }
+            } else {
+              // Color key mask (just an array).
+              this.mask = mask;
+            }
+          }
+        }
+        /**
+         * Handles processing of image data and returns the Promise that is resolved
+         * with a PDFImage when the image is ready to be used.
+         */
+        PDFImage.buildImage = function PDFImage_buildImage(handler, xref, res, image, inline, nativeDecoder) {
+          var imagePromise = handleImageData(image, nativeDecoder);
+          var smaskPromise;
+          var maskPromise;
+          var smask = image.dict.get('SMask');
+          var mask = image.dict.get('Mask');
+          if (smask) {
+            smaskPromise = handleImageData(smask, nativeDecoder);
+            maskPromise = Promise.resolve(null);
+          } else {
+            smaskPromise = Promise.resolve(null);
+            if (mask) {
+              if (isStream(mask)) {
+                maskPromise = handleImageData(mask, nativeDecoder);
+              } else if (isArray(mask)) {
+                maskPromise = Promise.resolve(mask);
+              } else {
+                warn('Unsupported mask format.');
+                maskPromise = Promise.resolve(null);
+              }
+            } else {
+              maskPromise = Promise.resolve(null);
+            }
+          }
+          return Promise.all([
+            imagePromise,
+            smaskPromise,
+            maskPromise
+          ]).then(function (results) {
+            var imageData = results[0];
+            var smaskData = results[1];
+            var maskData = results[2];
+            return new PDFImage(xref, res, imageData, inline, smaskData, maskData);
+          });
+        };
+        PDFImage.createMask = function PDFImage_createMask(imgArray, width, height, imageIsFromDecodeStream, inverseDecode) {
+          // |imgArray| might not contain full data for every pixel of the mask, so
+          // we need to distinguish between |computedLength| and |actualLength|.
+          // In particular, if inverseDecode is true, then the array we return must
+          // have a length of |computedLength|.
+          var computedLength = (width + 7 >> 3) * height;
+          var actualLength = imgArray.byteLength;
+          var haveFullData = computedLength === actualLength;
+          var data, i;
+          if (imageIsFromDecodeStream && (!inverseDecode || haveFullData)) {
+            // imgArray came from a DecodeStream and its data is in an appropriate
+            // form, so we can just transfer it.
+            data = imgArray;
+          } else if (!inverseDecode) {
+            data = new Uint8Array(actualLength);
+            data.set(imgArray);
+          } else {
+            data = new Uint8Array(computedLength);
+            data.set(imgArray);
+            for (i = actualLength; i < computedLength; i++) {
+              data[i] = 0xff;
+            }
+          }
+          // If necessary, invert the original mask data (but not any extra we might
+          // have added above). It's safe to modify the array -- whether it's the
+          // original or a copy, we're about to transfer it anyway, so nothing else
+          // in this thread can be relying on its contents.
+          if (inverseDecode) {
+            for (i = 0; i < actualLength; i++) {
+              data[i] = ~data[i];
+            }
+          }
+          return {
+            data: data,
+            width: width,
+            height: height
+          };
+        };
+        PDFImage.prototype = {
+          get drawWidth() {
+            return Math.max(this.width, this.smask && this.smask.width || 0, this.mask && this.mask.width || 0);
+          },
+          get drawHeight() {
+            return Math.max(this.height, this.smask && this.smask.height || 0, this.mask && this.mask.height || 0);
+          },
+          decodeBuffer: function PDFImage_decodeBuffer(buffer) {
+            var bpc = this.bpc;
+            var numComps = this.numComps;
+            var decodeAddends = this.decodeAddends;
+            var decodeCoefficients = this.decodeCoefficients;
+            var max = (1 << bpc) - 1;
+            var i, ii;
+            if (bpc === 1) {
+              // If the buffer needed decode that means it just needs to be inverted.
+              for (i = 0, ii = buffer.length; i < ii; i++) {
+                buffer[i] = +!buffer[i];
+              }
+              return;
+            }
+            var index = 0;
+            for (i = 0, ii = this.width * this.height; i < ii; i++) {
+              for (var j = 0; j < numComps; j++) {
+                buffer[index] = decodeAndClamp(buffer[index], decodeAddends[j], decodeCoefficients[j], max);
+                index++;
+              }
+            }
+          },
+          getComponents: function PDFImage_getComponents(buffer) {
+            var bpc = this.bpc;
+            // This image doesn't require any extra work.
+            if (bpc === 8) {
+              return buffer;
+            }
+            var width = this.width;
+            var height = this.height;
+            var numComps = this.numComps;
+            var length = width * height * numComps;
+            var bufferPos = 0;
+            var output = bpc <= 8 ? new Uint8Array(length) : bpc <= 16 ? new Uint16Array(length) : new Uint32Array(length);
+            var rowComps = width * numComps;
+            var max = (1 << bpc) - 1;
+            var i = 0, ii, buf;
+            if (bpc === 1) {
+              // Optimization for reading 1 bpc images.
+              var mask, loop1End, loop2End;
+              for (var j = 0; j < height; j++) {
+                loop1End = i + (rowComps & ~7);
+                loop2End = i + rowComps;
+                // unroll loop for all full bytes
+                while (i < loop1End) {
+                  buf = buffer[bufferPos++];
+                  output[i] = buf >> 7 & 1;
+                  output[i + 1] = buf >> 6 & 1;
+                  output[i + 2] = buf >> 5 & 1;
+                  output[i + 3] = buf >> 4 & 1;
+                  output[i + 4] = buf >> 3 & 1;
+                  output[i + 5] = buf >> 2 & 1;
+                  output[i + 6] = buf >> 1 & 1;
+                  output[i + 7] = buf & 1;
+                  i += 8;
+                }
+                // handle remaining bits
+                if (i < loop2End) {
+                  buf = buffer[bufferPos++];
+                  mask = 128;
+                  while (i < loop2End) {
+                    output[i++] = +!!(buf & mask);
+                    mask >>= 1;
+                  }
+                }
+              }
+            } else {
+              // The general case that handles all other bpc values.
+              var bits = 0;
+              buf = 0;
+              for (i = 0, ii = length; i < ii; ++i) {
+                if (i % rowComps === 0) {
+                  buf = 0;
+                  bits = 0;
+                }
+                while (bits < bpc) {
+                  buf = buf << 8 | buffer[bufferPos++];
+                  bits += 8;
+                }
+                var remainingBits = bits - bpc;
+                var value = buf >> remainingBits;
+                output[i] = value < 0 ? 0 : value > max ? max : value;
+                buf = buf & (1 << remainingBits) - 1;
+                bits = remainingBits;
+              }
+            }
+            return output;
+          },
+          fillOpacity: function PDFImage_fillOpacity(rgbaBuf, width, height, actualHeight, image) {
+            var smask = this.smask;
+            var mask = this.mask;
+            var alphaBuf, sw, sh, i, ii, j;
+            if (smask) {
+              sw = smask.width;
+              sh = smask.height;
+              alphaBuf = new Uint8Array(sw * sh);
+              smask.fillGrayBuffer(alphaBuf);
+              if (sw !== width || sh !== height) {
+                alphaBuf = resizeImageMask(alphaBuf, smask.bpc, sw, sh, width, height);
+              }
+            } else if (mask) {
+              if (mask instanceof PDFImage) {
+                sw = mask.width;
+                sh = mask.height;
+                alphaBuf = new Uint8Array(sw * sh);
+                mask.numComps = 1;
+                mask.fillGrayBuffer(alphaBuf);
+                // Need to invert values in rgbaBuf
+                for (i = 0, ii = sw * sh; i < ii; ++i) {
+                  alphaBuf[i] = 255 - alphaBuf[i];
+                }
+                if (sw !== width || sh !== height) {
+                  alphaBuf = resizeImageMask(alphaBuf, mask.bpc, sw, sh, width, height);
+                }
+              } else if (isArray(mask)) {
+                // Color key mask: if any of the components are outside the range
+                // then they should be painted.
+                alphaBuf = new Uint8Array(width * height);
+                var numComps = this.numComps;
+                for (i = 0, ii = width * height; i < ii; ++i) {
+                  var opacity = 0;
+                  var imageOffset = i * numComps;
+                  for (j = 0; j < numComps; ++j) {
+                    var color = image[imageOffset + j];
+                    var maskOffset = j * 2;
+                    if (color < mask[maskOffset] || color > mask[maskOffset + 1]) {
+                      opacity = 255;
+                      break;
+                    }
+                  }
+                  alphaBuf[i] = opacity;
+                }
+              } else {
+                error('Unknown mask format.');
+              }
+            }
+            if (alphaBuf) {
+              for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {
+                rgbaBuf[j] = alphaBuf[i];
+              }
+            } else {
+              // No mask.
+              for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {
+                rgbaBuf[j] = 255;
+              }
+            }
+          },
+          undoPreblend: function PDFImage_undoPreblend(buffer, width, height) {
+            var matte = this.smask && this.smask.matte;
+            if (!matte) {
+              return;
+            }
+            var matteRgb = this.colorSpace.getRgb(matte, 0);
+            var matteR = matteRgb[0];
+            var matteG = matteRgb[1];
+            var matteB = matteRgb[2];
+            var length = width * height * 4;
+            var r, g, b;
+            for (var i = 0; i < length; i += 4) {
+              var alpha = buffer[i + 3];
+              if (alpha === 0) {
+                // according formula we have to get Infinity in all components
+                // making it white (typical paper color) should be okay
+                buffer[i] = 255;
+                buffer[i + 1] = 255;
+                buffer[i + 2] = 255;
+                continue;
+              }
+              var k = 255 / alpha;
+              r = (buffer[i] - matteR) * k + matteR;
+              g = (buffer[i + 1] - matteG) * k + matteG;
+              b = (buffer[i + 2] - matteB) * k + matteB;
+              buffer[i] = r <= 0 ? 0 : r >= 255 ? 255 : r | 0;
+              buffer[i + 1] = g <= 0 ? 0 : g >= 255 ? 255 : g | 0;
+              buffer[i + 2] = b <= 0 ? 0 : b >= 255 ? 255 : b | 0;
+            }
+          },
+          createImageData: function PDFImage_createImageData(forceRGBA) {
+            var drawWidth = this.drawWidth;
+            var drawHeight = this.drawHeight;
+            var imgData = {
+              // other fields are filled in below
+              width: drawWidth,
+              height: drawHeight
+            };
+            var numComps = this.numComps;
+            var originalWidth = this.width;
+            var originalHeight = this.height;
+            var bpc = this.bpc;
+            // Rows start at byte boundary.
+            var rowBytes = originalWidth * numComps * bpc + 7 >> 3;
+            var imgArray;
+            if (!forceRGBA) {
+              // If it is a 1-bit-per-pixel grayscale (i.e. black-and-white) image
+              // without any complications, we pass a same-sized copy to the main
+              // thread rather than expanding by 32x to RGBA form. This saves *lots*
+              // of memory for many scanned documents. It's also much faster.
+              //
+              // Similarly, if it is a 24-bit-per pixel RGB image without any
+              // complications, we avoid expanding by 1.333x to RGBA form.
+              var kind;
+              if (this.colorSpace.name === 'DeviceGray' && bpc === 1) {
+                kind = ImageKind.GRAYSCALE_1BPP;
+              } else if (this.colorSpace.name === 'DeviceRGB' && bpc === 8 && !this.needsDecode) {
+                kind = ImageKind.RGB_24BPP;
+              }
+              if (kind && !this.smask && !this.mask && drawWidth === originalWidth && drawHeight === originalHeight) {
+                imgData.kind = kind;
+                imgArray = this.getImageBytes(originalHeight * rowBytes);
+                // If imgArray came from a DecodeStream, we're safe to transfer it
+                // (and thus detach its underlying buffer) because it will constitute
+                // the entire DecodeStream's data.  But if it came from a Stream, we
+                // need to copy it because it'll only be a portion of the Stream's
+                // data, and the rest will be read later on.
+                if (this.image instanceof DecodeStream) {
+                  imgData.data = imgArray;
+                } else {
+                  var newArray = new Uint8Array(imgArray.length);
+                  newArray.set(imgArray);
+                  imgData.data = newArray;
+                }
+                if (this.needsDecode) {
+                  // Invert the buffer (which must be grayscale if we reached here).
+                  assert(kind === ImageKind.GRAYSCALE_1BPP);
+                  var buffer = imgData.data;
+                  for (var i = 0, ii = buffer.length; i < ii; i++) {
+                    buffer[i] ^= 0xff;
+                  }
+                }
+                return imgData;
+              }
+              if (this.image instanceof JpegStream && !this.smask && !this.mask && (this.colorSpace.name === 'DeviceGray' || this.colorSpace.name === 'DeviceRGB' || this.colorSpace.name === 'DeviceCMYK')) {
+                imgData.kind = ImageKind.RGB_24BPP;
+                imgData.data = this.getImageBytes(originalHeight * rowBytes, drawWidth, drawHeight, true);
+                return imgData;
+              }
+            }
+            imgArray = this.getImageBytes(originalHeight * rowBytes);
+            // imgArray can be incomplete (e.g. after CCITT fax encoding).
+            var actualHeight = 0 | imgArray.length / rowBytes * drawHeight / originalHeight;
+            var comps = this.getComponents(imgArray);
+            // If opacity data is present, use RGBA_32BPP form. Otherwise, use the
+            // more compact RGB_24BPP form if allowable.
+            var alpha01, maybeUndoPreblend;
+            if (!forceRGBA && !this.smask && !this.mask) {
+              imgData.kind = ImageKind.RGB_24BPP;
+              imgData.data = new Uint8Array(drawWidth * drawHeight * 3);
+              alpha01 = 0;
+              maybeUndoPreblend = false;
+            } else {
+              imgData.kind = ImageKind.RGBA_32BPP;
+              imgData.data = new Uint8Array(drawWidth * drawHeight * 4);
+              alpha01 = 1;
+              maybeUndoPreblend = true;
+              // Color key masking (opacity) must be performed before decoding.
+              this.fillOpacity(imgData.data, drawWidth, drawHeight, actualHeight, comps);
+            }
+            if (this.needsDecode) {
+              this.decodeBuffer(comps);
+            }
+            this.colorSpace.fillRgb(imgData.data, originalWidth, originalHeight, drawWidth, drawHeight, actualHeight, bpc, comps, alpha01);
+            if (maybeUndoPreblend) {
+              this.undoPreblend(imgData.data, drawWidth, actualHeight);
+            }
+            return imgData;
+          },
+          fillGrayBuffer: function PDFImage_fillGrayBuffer(buffer) {
+            var numComps = this.numComps;
+            if (numComps !== 1) {
+              error('Reading gray scale from a color image: ' + numComps);
+            }
+            var width = this.width;
+            var height = this.height;
+            var bpc = this.bpc;
+            // rows start at byte boundary
+            var rowBytes = width * numComps * bpc + 7 >> 3;
+            var imgArray = this.getImageBytes(height * rowBytes);
+            var comps = this.getComponents(imgArray);
+            var i, length;
+            if (bpc === 1) {
+              // inline decoding (= inversion) for 1 bpc images
+              length = width * height;
+              if (this.needsDecode) {
+                // invert and scale to {0, 255}
+                for (i = 0; i < length; ++i) {
+                  buffer[i] = comps[i] - 1 & 255;
+                }
+              } else {
+                // scale to {0, 255}
+                for (i = 0; i < length; ++i) {
+                  buffer[i] = -comps[i] & 255;
+                }
+              }
+              return;
+            }
+            if (this.needsDecode) {
+              this.decodeBuffer(comps);
+            }
+            length = width * height;
+            // we aren't using a colorspace so we need to scale the value
+            var scale = 255 / ((1 << bpc) - 1);
+            for (i = 0; i < length; ++i) {
+              buffer[i] = scale * comps[i] | 0;
+            }
+          },
+          getImageBytes: function PDFImage_getImageBytes(length, drawWidth, drawHeight, forceRGB) {
+            this.image.reset();
+            this.image.drawWidth = drawWidth || this.width;
+            this.image.drawHeight = drawHeight || this.height;
+            this.image.forceRGB = !!forceRGB;
+            return this.image.getBytes(length);
+          }
+        };
+        return PDFImage;
+      }();
+      exports.PDFImage = PDFImage;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreObj = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreCrypto, root.pdfjsCoreParser, root.pdfjsCoreChunkedStream, root.pdfjsCoreColorSpace);
+    }(this, function (exports, sharedUtil, corePrimitives, coreCrypto, coreParser, coreChunkedStream, coreColorSpace) {
+      var InvalidPDFException = sharedUtil.InvalidPDFException;
+      var MissingDataException = sharedUtil.MissingDataException;
+      var XRefParseException = sharedUtil.XRefParseException;
+      var assert = sharedUtil.assert;
+      var bytesToString = sharedUtil.bytesToString;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isBool = sharedUtil.isBool;
+      var isInt = sharedUtil.isInt;
+      var isString = sharedUtil.isString;
+      var shadow = sharedUtil.shadow;
+      var stringToPDFString = sharedUtil.stringToPDFString;
+      var stringToUTF8String = sharedUtil.stringToUTF8String;
+      var warn = sharedUtil.warn;
+      var createValidAbsoluteUrl = sharedUtil.createValidAbsoluteUrl;
+      var Util = sharedUtil.Util;
+      var Ref = corePrimitives.Ref;
+      var RefSet = corePrimitives.RefSet;
+      var RefSetCache = corePrimitives.RefSetCache;
+      var isName = corePrimitives.isName;
+      var isCmd = corePrimitives.isCmd;
+      var isDict = corePrimitives.isDict;
+      var isRef = corePrimitives.isRef;
+      var isRefsEqual = corePrimitives.isRefsEqual;
+      var isStream = corePrimitives.isStream;
+      var CipherTransformFactory = coreCrypto.CipherTransformFactory;
+      var Lexer = coreParser.Lexer;
+      var Parser = coreParser.Parser;
+      var ChunkedStream = coreChunkedStream.ChunkedStream;
+      var ColorSpace = coreColorSpace.ColorSpace;
+      var Catalog = function CatalogClosure() {
+        function Catalog(pdfManager, xref, pageFactory) {
+          this.pdfManager = pdfManager;
+          this.xref = xref;
+          this.catDict = xref.getCatalogObj();
+          this.fontCache = new RefSetCache();
+          assert(isDict(this.catDict), 'catalog object is not a dictionary');
+          // TODO refactor to move getPage() to the PDFDocument.
+          this.pageFactory = pageFactory;
+          this.pagePromises = [];
+        }
+        Catalog.prototype = {
+          get metadata() {
+            var streamRef = this.catDict.getRaw('Metadata');
+            if (!isRef(streamRef)) {
+              return shadow(this, 'metadata', null);
+            }
+            var encryptMetadata = !this.xref.encrypt ? false : this.xref.encrypt.encryptMetadata;
+            var stream = this.xref.fetch(streamRef, !encryptMetadata);
+            var metadata;
+            if (stream && isDict(stream.dict)) {
+              var type = stream.dict.get('Type');
+              var subtype = stream.dict.get('Subtype');
+              if (isName(type, 'Metadata') && isName(subtype, 'XML')) {
+                // XXX: This should examine the charset the XML document defines,
+                // however since there are currently no real means to decode
+                // arbitrary charsets, let's just hope that the author of the PDF
+                // was reasonable enough to stick with the XML default charset,
+                // which is UTF-8.
+                try {
+                  metadata = stringToUTF8String(bytesToString(stream.getBytes()));
+                } catch (e) {
+                  info('Skipping invalid metadata.');
+                }
+              }
+            }
+            return shadow(this, 'metadata', metadata);
+          },
+          get toplevelPagesDict() {
+            var pagesObj = this.catDict.get('Pages');
+            assert(isDict(pagesObj), 'invalid top-level pages dictionary');
+            // shadow the prototype getter
+            return shadow(this, 'toplevelPagesDict', pagesObj);
+          },
+          get documentOutline() {
+            var obj = null;
+            try {
+              obj = this.readDocumentOutline();
+            } catch (ex) {
+              if (ex instanceof MissingDataException) {
+                throw ex;
+              }
+              warn('Unable to read document outline');
+            }
+            return shadow(this, 'documentOutline', obj);
+          },
+          readDocumentOutline: function Catalog_readDocumentOutline() {
+            var obj = this.catDict.get('Outlines');
+            if (!isDict(obj)) {
+              return null;
+            }
+            obj = obj.getRaw('First');
+            if (!isRef(obj)) {
+              return null;
+            }
+            var root = { items: [] };
+            var queue = [{
+                obj: obj,
+                parent: root
+              }];
+            // To avoid recursion, keep track of the already processed items.
+            var processed = new RefSet();
+            processed.put(obj);
+            var xref = this.xref, blackColor = new Uint8Array(3);
+            while (queue.length > 0) {
+              var i = queue.shift();
+              var outlineDict = xref.fetchIfRef(i.obj);
+              if (outlineDict === null) {
+                continue;
+              }
+              assert(outlineDict.has('Title'), 'Invalid outline item');
+              var data = {
+                url: null,
+                dest: null
+              };
+              Catalog.parseDestDictionary({
+                destDict: outlineDict,
+                resultObj: data,
+                docBaseUrl: this.pdfManager.docBaseUrl
+              });
+              var title = outlineDict.get('Title');
+              var flags = outlineDict.get('F') || 0;
+              var color = outlineDict.getArray('C'), rgbColor = blackColor;
+              // We only need to parse the color when it's valid, and non-default.
+              if (isArray(color) && color.length === 3 && (color[0] !== 0 || color[1] !== 0 || color[2] !== 0)) {
+                rgbColor = ColorSpace.singletons.rgb.getRgb(color, 0);
+              }
+              var outlineItem = {
+                dest: data.dest,
+                url: data.url,
+                unsafeUrl: data.unsafeUrl,
+                newWindow: data.newWindow,
+                title: stringToPDFString(title),
+                color: rgbColor,
+                count: outlineDict.get('Count'),
+                bold: !!(flags & 2),
+                italic: !!(flags & 1),
+                items: []
+              };
+              i.parent.items.push(outlineItem);
+              obj = outlineDict.getRaw('First');
+              if (isRef(obj) && !processed.has(obj)) {
+                queue.push({
+                  obj: obj,
+                  parent: outlineItem
+                });
+                processed.put(obj);
+              }
+              obj = outlineDict.getRaw('Next');
+              if (isRef(obj) && !processed.has(obj)) {
+                queue.push({
+                  obj: obj,
+                  parent: i.parent
+                });
+                processed.put(obj);
+              }
+            }
+            return root.items.length > 0 ? root.items : null;
+          },
+          get numPages() {
+            var obj = this.toplevelPagesDict.get('Count');
+            assert(isInt(obj), 'page count in top level pages object is not an integer');
+            // shadow the prototype getter
+            return shadow(this, 'num', obj);
+          },
+          get destinations() {
+            function fetchDestination(dest) {
+              return isDict(dest) ? dest.get('D') : dest;
+            }
+            var xref = this.xref;
+            var dests = {}, nameTreeRef, nameDictionaryRef;
+            var obj = this.catDict.get('Names');
+            if (obj && obj.has('Dests')) {
+              nameTreeRef = obj.getRaw('Dests');
+            } else if (this.catDict.has('Dests')) {
+              nameDictionaryRef = this.catDict.get('Dests');
+            }
+            if (nameDictionaryRef) {
+              // reading simple destination dictionary
+              obj = nameDictionaryRef;
+              obj.forEach(function catalogForEach(key, value) {
+                if (!value) {
+                  return;
+                }
+                dests[key] = fetchDestination(value);
+              });
+            }
+            if (nameTreeRef) {
+              var nameTree = new NameTree(nameTreeRef, xref);
+              var names = nameTree.getAll();
+              for (var name in names) {
+                dests[name] = fetchDestination(names[name]);
+              }
+            }
+            return shadow(this, 'destinations', dests);
+          },
+          getDestination: function Catalog_getDestination(destinationId) {
+            function fetchDestination(dest) {
+              return isDict(dest) ? dest.get('D') : dest;
+            }
+            var xref = this.xref;
+            var dest = null, nameTreeRef, nameDictionaryRef;
+            var obj = this.catDict.get('Names');
+            if (obj && obj.has('Dests')) {
+              nameTreeRef = obj.getRaw('Dests');
+            } else if (this.catDict.has('Dests')) {
+              nameDictionaryRef = this.catDict.get('Dests');
+            }
+            if (nameDictionaryRef) {
+              // Simple destination dictionary.
+              var value = nameDictionaryRef.get(destinationId);
+              if (value) {
+                dest = fetchDestination(value);
+              }
+            }
+            if (nameTreeRef) {
+              var nameTree = new NameTree(nameTreeRef, xref);
+              dest = fetchDestination(nameTree.get(destinationId));
+            }
+            return dest;
+          },
+          get pageLabels() {
+            var obj = null;
+            try {
+              obj = this.readPageLabels();
+            } catch (ex) {
+              if (ex instanceof MissingDataException) {
+                throw ex;
+              }
+              warn('Unable to read page labels.');
+            }
+            return shadow(this, 'pageLabels', obj);
+          },
+          readPageLabels: function Catalog_readPageLabels() {
+            var obj = this.catDict.getRaw('PageLabels');
+            if (!obj) {
+              return null;
+            }
+            var pageLabels = new Array(this.numPages);
+            var style = null;
+            var prefix = '';
+            var numberTree = new NumberTree(obj, this.xref);
+            var nums = numberTree.getAll();
+            var currentLabel = '', currentIndex = 1;
+            for (var i = 0, ii = this.numPages; i < ii; i++) {
+              if (i in nums) {
+                var labelDict = nums[i];
+                assert(isDict(labelDict), 'The PageLabel is not a dictionary.');
+                var type = labelDict.get('Type');
+                assert(!type || isName(type, 'PageLabel'), 'Invalid type in PageLabel dictionary.');
+                var s = labelDict.get('S');
+                assert(!s || isName(s), 'Invalid style in PageLabel dictionary.');
+                style = s ? s.name : null;
+                var p = labelDict.get('P');
+                assert(!p || isString(p), 'Invalid prefix in PageLabel dictionary.');
+                prefix = p ? stringToPDFString(p) : '';
+                var st = labelDict.get('St');
+                assert(!st || isInt(st) && st >= 1, 'Invalid start in PageLabel dictionary.');
+                currentIndex = st || 1;
+              }
+              switch (style) {
+              case 'D':
+                currentLabel = currentIndex;
+                break;
+              case 'R':
+              case 'r':
+                currentLabel = Util.toRoman(currentIndex, style === 'r');
+                break;
+              case 'A':
+              case 'a':
+                var LIMIT = 26;
+                // Use only the characters A--Z, or a--z.
+                var A_UPPER_CASE = 0x41, A_LOWER_CASE = 0x61;
+                var baseCharCode = style === 'a' ? A_LOWER_CASE : A_UPPER_CASE;
+                var letterIndex = currentIndex - 1;
+                var character = String.fromCharCode(baseCharCode + letterIndex % LIMIT);
+                var charBuf = [];
+                for (var j = 0, jj = letterIndex / LIMIT | 0; j <= jj; j++) {
+                  charBuf.push(character);
+                }
+                currentLabel = charBuf.join('');
+                break;
+              default:
+                assert(!style, 'Invalid style "' + style + '" in PageLabel dictionary.');
+              }
+              pageLabels[i] = prefix + currentLabel;
+              currentLabel = '';
+              currentIndex++;
+            }
+            return pageLabels;
+          },
+          get attachments() {
+            var xref = this.xref;
+            var attachments = null, nameTreeRef;
+            var obj = this.catDict.get('Names');
+            if (obj) {
+              nameTreeRef = obj.getRaw('EmbeddedFiles');
+            }
+            if (nameTreeRef) {
+              var nameTree = new NameTree(nameTreeRef, xref);
+              var names = nameTree.getAll();
+              for (var name in names) {
+                var fs = new FileSpec(names[name], xref);
+                if (!attachments) {
+                  attachments = Object.create(null);
+                }
+                attachments[stringToPDFString(name)] = fs.serializable;
+              }
+            }
+            return shadow(this, 'attachments', attachments);
+          },
+          get javaScript() {
+            var xref = this.xref;
+            var obj = this.catDict.get('Names');
+            var javaScript = [];
+            function appendIfJavaScriptDict(jsDict) {
+              var type = jsDict.get('S');
+              if (!isName(type, 'JavaScript')) {
+                return;
+              }
+              var js = jsDict.get('JS');
+              if (isStream(js)) {
+                js = bytesToString(js.getBytes());
+              } else if (!isString(js)) {
+                return;
+              }
+              javaScript.push(stringToPDFString(js));
+            }
+            if (obj && obj.has('JavaScript')) {
+              var nameTree = new NameTree(obj.getRaw('JavaScript'), xref);
+              var names = nameTree.getAll();
+              for (var name in names) {
+                // We don't really use the JavaScript right now. This code is
+                // defensive so we don't cause errors on document load.
+                var jsDict = names[name];
+                if (isDict(jsDict)) {
+                  appendIfJavaScriptDict(jsDict);
+                }
+              }
+            }
+            // Append OpenAction actions to javaScript array
+            var openactionDict = this.catDict.get('OpenAction');
+            if (isDict(openactionDict, 'Action')) {
+              var actionType = openactionDict.get('S');
+              if (isName(actionType, 'Named')) {
+                // The named Print action is not a part of the PDF 1.7 specification,
+                // but is supported by many PDF readers/writers (including Adobe's).
+                var action = openactionDict.get('N');
+                if (isName(action, 'Print')) {
+                  javaScript.push('print({});');
+                }
+              } else {
+                appendIfJavaScriptDict(openactionDict);
+              }
+            }
+            return shadow(this, 'javaScript', javaScript);
+          },
+          cleanup: function Catalog_cleanup() {
+            var promises = [];
+            this.fontCache.forEach(function (promise) {
+              promises.push(promise);
+            });
+            return Promise.all(promises).then(function (translatedFonts) {
+              for (var i = 0, ii = translatedFonts.length; i < ii; i++) {
+                var font = translatedFonts[i].dict;
+                delete font.translated;
+              }
+              this.fontCache.clear();
+            }.bind(this));
+          },
+          getPage: function Catalog_getPage(pageIndex) {
+            if (!(pageIndex in this.pagePromises)) {
+              this.pagePromises[pageIndex] = this.getPageDict(pageIndex).then(function (a) {
+                var dict = a[0];
+                var ref = a[1];
+                return this.pageFactory.createPage(pageIndex, dict, ref, this.fontCache);
+              }.bind(this));
+            }
+            return this.pagePromises[pageIndex];
+          },
+          getPageDict: function Catalog_getPageDict(pageIndex) {
+            var capability = createPromiseCapability();
+            var nodesToVisit = [this.catDict.getRaw('Pages')];
+            var currentPageIndex = 0;
+            var xref = this.xref;
+            var checkAllKids = false;
+            function next() {
+              while (nodesToVisit.length) {
+                var currentNode = nodesToVisit.pop();
+                if (isRef(currentNode)) {
+                  xref.fetchAsync(currentNode).then(function (obj) {
+                    if (isDict(obj, 'Page') || isDict(obj) && !obj.has('Kids')) {
+                      if (pageIndex === currentPageIndex) {
+                        capability.resolve([
+                          obj,
+                          currentNode
+                        ]);
+                      } else {
+                        currentPageIndex++;
+                        next();
+                      }
+                      return;
+                    }
+                    nodesToVisit.push(obj);
+                    next();
+                  }, capability.reject);
+                  return;
+                }
+                // Must be a child page dictionary.
+                assert(isDict(currentNode), 'page dictionary kid reference points to wrong type of object');
+                var count = currentNode.get('Count');
+                // If the current node doesn't have any children, avoid getting stuck
+                // in an empty node further down in the tree (see issue5644.pdf).
+                if (count === 0) {
+                  checkAllKids = true;
+                }
+                // Skip nodes where the page can't be.
+                if (currentPageIndex + count <= pageIndex) {
+                  currentPageIndex += count;
+                  continue;
+                }
+                var kids = currentNode.get('Kids');
+                assert(isArray(kids), 'page dictionary kids object is not an array');
+                if (!checkAllKids && count === kids.length) {
+                  // Nodes that don't have the page have been skipped and this is the
+                  // bottom of the tree which means the page requested must be a
+                  // descendant of this pages node. Ideally we would just resolve the
+                  // promise with the page ref here, but there is the case where more
+                  // pages nodes could link to single a page (see issue 3666 pdf). To
+                  // handle this push it back on the queue so if it is a pages node it
+                  // will be descended into.
+                  nodesToVisit = [kids[pageIndex - currentPageIndex]];
+                  currentPageIndex = pageIndex;
+                  continue;
+                } else {
+                  for (var last = kids.length - 1; last >= 0; last--) {
+                    nodesToVisit.push(kids[last]);
+                  }
+                }
+              }
+              capability.reject('Page index ' + pageIndex + ' not found.');
+            }
+            next();
+            return capability.promise;
+          },
+          getPageIndex: function Catalog_getPageIndex(pageRef) {
+            // The page tree nodes have the count of all the leaves below them. To get
+            // how many pages are before we just have to walk up the tree and keep
+            // adding the count of siblings to the left of the node.
+            var xref = this.xref;
+            function pagesBeforeRef(kidRef) {
+              var total = 0;
+              var parentRef;
+              return xref.fetchAsync(kidRef).then(function (node) {
+                if (isRefsEqual(kidRef, pageRef) && !isDict(node, 'Page') && !(isDict(node) && !node.has('Type') && node.has('Contents'))) {
+                  throw new Error('The reference does not point to a /Page Dict.');
+                }
+                if (!node) {
+                  return null;
+                }
+                assert(isDict(node), 'node must be a Dict.');
+                parentRef = node.getRaw('Parent');
+                return node.getAsync('Parent');
+              }).then(function (parent) {
+                if (!parent) {
+                  return null;
+                }
+                assert(isDict(parent), 'parent must be a Dict.');
+                return parent.getAsync('Kids');
+              }).then(function (kids) {
+                if (!kids) {
+                  return null;
+                }
+                var kidPromises = [];
+                var found = false;
+                for (var i = 0; i < kids.length; i++) {
+                  var kid = kids[i];
+                  assert(isRef(kid), 'kid must be a Ref.');
+                  if (kid.num === kidRef.num) {
+                    found = true;
+                    break;
+                  }
+                  kidPromises.push(xref.fetchAsync(kid).then(function (kid) {
+                    if (kid.has('Count')) {
+                      var count = kid.get('Count');
+                      total += count;
+                    } else {
+                      // page leaf node
+                      total++;
+                    }
+                  }));
+                }
+                if (!found) {
+                  error('kid ref not found in parents kids');
+                }
+                return Promise.all(kidPromises).then(function () {
+                  return [
+                    total,
+                    parentRef
+                  ];
+                });
+              });
+            }
+            var total = 0;
+            function next(ref) {
+              return pagesBeforeRef(ref).then(function (args) {
+                if (!args) {
+                  return total;
+                }
+                var count = args[0];
+                var parentRef = args[1];
+                total += count;
+                return next(parentRef);
+              });
+            }
+            return next(pageRef);
+          }
+        };
+        /**
+         * Helper function used to parse the contents of destination dictionaries.
+         * @param {Dict} destDict - The dictionary containing the destination.
+         * @param {Object} resultObj - The object where the parsed destination
+         *   properties will be placed.
+         * @param {string} docBaseUrl - (optional) The document base URL that is used
+         *   when attempting to recover valid absolute URLs from relative ones.
+         */
+        Catalog.parseDestDictionary = function Catalog_parseDestDictionary(params) {
+          // Lets URLs beginning with 'www.' default to using the 'http://' protocol.
+          function addDefaultProtocolToUrl(url) {
+            if (url.indexOf('www.') === 0) {
+              return 'http://' + url;
+            }
+            return url;
+          }
+          // According to ISO 32000-1:2008, section 12.6.4.7, URIs should be encoded
+          // in 7-bit ASCII. Some bad PDFs use UTF-8 encoding, see Bugzilla 1122280.
+          function tryConvertUrlEncoding(url) {
+            try {
+              return stringToUTF8String(url);
+            } catch (e) {
+              return url;
+            }
+          }
+          var destDict = params.destDict;
+          if (!isDict(destDict)) {
+            warn('Catalog_parseDestDictionary: "destDict" must be a dictionary.');
+            return;
+          }
+          var resultObj = params.resultObj;
+          if (typeof resultObj !== 'object') {
+            warn('Catalog_parseDestDictionary: "resultObj" must be an object.');
+            return;
+          }
+          var docBaseUrl = params.docBaseUrl || null;
+          var action = destDict.get('A'), url, dest;
+          if (isDict(action)) {
+            var linkType = action.get('S').name;
+            switch (linkType) {
+            case 'URI':
+              url = action.get('URI');
+              if (isName(url)) {
+                // Some bad PDFs do not put parentheses around relative URLs.
+                url = '/' + url.name;
+              } else if (isString(url)) {
+                url = addDefaultProtocolToUrl(url);
+              }
+              // TODO: pdf spec mentions urls can be relative to a Base
+              // entry in the dictionary.
+              break;
+            case 'GoTo':
+              dest = action.get('D');
+              break;
+            case 'Launch':
+            // We neither want, nor can, support arbitrary 'Launch' actions.
+            // However, in practice they are mostly used for linking to other PDF
+            // files, which we thus attempt to support (utilizing `docBaseUrl`).
+            case 'GoToR':
+              var urlDict = action.get('F');
+              if (isDict(urlDict)) {
+                // We assume that we found a FileSpec dictionary
+                // and fetch the URL without checking any further.
+                url = urlDict.get('F') || null;
+              } else if (isString(urlDict)) {
+                url = urlDict;
+              }
+              // NOTE: the destination is relative to the *remote* document.
+              var remoteDest = action.get('D');
+              if (remoteDest) {
+                if (isName(remoteDest)) {
+                  remoteDest = remoteDest.name;
+                }
+                if (isString(url)) {
+                  var baseUrl = url.split('#')[0];
+                  if (isString(remoteDest)) {
+                    // In practice, a named destination may contain only a number.
+                    // If that happens, use the '#nameddest=' form to avoid the link
+                    // redirecting to a page, instead of the correct destination.
+                    url = baseUrl + '#' + (/^\d+$/.test(remoteDest) ? 'nameddest=' : '') + remoteDest;
+                  } else if (isArray(remoteDest)) {
+                    url = baseUrl + '#' + JSON.stringify(remoteDest);
+                  }
+                }
+              }
+              // The 'NewWindow' property, equal to `LinkTarget.BLANK`.
+              var newWindow = action.get('NewWindow');
+              if (isBool(newWindow)) {
+                resultObj.newWindow = newWindow;
+              }
+              break;
+            case 'Named':
+              var namedAction = action.get('N');
+              if (isName(namedAction)) {
+                resultObj.action = namedAction.name;
+              }
+              break;
+            case 'JavaScript':
+              var jsAction = action.get('JS'), js;
+              if (isStream(jsAction)) {
+                js = bytesToString(jsAction.getBytes());
+              } else if (isString(jsAction)) {
+                js = jsAction;
+              }
+              if (js) {
+                // Attempt to recover valid URLs from 'JS' entries with certain
+                // white-listed formats, e.g.
+                //  - window.open('http://example.com')
+                //  - app.launchURL('http://example.com', true)
+                var URL_OPEN_METHODS = [
+                  'app.launchURL',
+                  'window.open'
+                ];
+                var regex = new RegExp('^(?:' + URL_OPEN_METHODS.join('|') + ')' + '\\((?:\'|\")(\\S+)(?:\'|\")(?:,|\\))');
+                var jsUrl = regex.exec(stringToPDFString(js), 'i');
+                if (jsUrl && jsUrl[1]) {
+                  url = jsUrl[1];
+                  break;
+                }
+              }
+            default:
+              warn('Catalog_parseDestDictionary: Unrecognized link type "' + linkType + '".');
+              break;
+            }
+          } else if (destDict.has('Dest')) {
+            // Simple destination link.
+            dest = destDict.get('Dest');
+          }
+          if (isString(url)) {
+            url = tryConvertUrlEncoding(url);
+            var absoluteUrl = createValidAbsoluteUrl(url, docBaseUrl);
+            if (absoluteUrl) {
+              resultObj.url = absoluteUrl.href;
+            }
+            resultObj.unsafeUrl = url;
+          }
+          if (dest) {
+            if (isName(dest)) {
+              dest = dest.name;
+            }
+            if (isString(dest) || isArray(dest)) {
+              resultObj.dest = dest;
+            }
+          }
+        };
+        return Catalog;
+      }();
+      var XRef = function XRefClosure() {
+        function XRef(stream, password) {
+          this.stream = stream;
+          this.entries = [];
+          this.xrefstms = Object.create(null);
+          // prepare the XRef cache
+          this.cache = [];
+          this.password = password;
+          this.stats = {
+            streamTypes: [],
+            fontTypes: []
+          };
+        }
+        XRef.prototype = {
+          setStartXRef: function XRef_setStartXRef(startXRef) {
+            // Store the starting positions of xref tables as we process them
+            // so we can recover from missing data errors
+            this.startXRefQueue = [startXRef];
+          },
+          parse: function XRef_parse(recoveryMode) {
+            var trailerDict;
+            if (!recoveryMode) {
+              trailerDict = this.readXRef();
+            } else {
+              warn('Indexing all PDF objects');
+              trailerDict = this.indexObjects();
+            }
+            trailerDict.assignXref(this);
+            this.trailer = trailerDict;
+            var encrypt = trailerDict.get('Encrypt');
+            if (encrypt) {
+              var ids = trailerDict.get('ID');
+              var fileId = ids && ids.length ? ids[0] : '';
+              // The 'Encrypt' dictionary itself should not be encrypted, and by
+              // setting `suppressEncryption` we can prevent an infinite loop inside
+              // of `XRef_fetchUncompressed` if the dictionary contains indirect
+              // objects (fixes issue7665.pdf).
+              encrypt.suppressEncryption = true;
+              this.encrypt = new CipherTransformFactory(encrypt, fileId, this.password);
+            }
+            // get the root dictionary (catalog) object
+            if (!(this.root = trailerDict.get('Root'))) {
+              error('Invalid root reference');
+            }
+          },
+          processXRefTable: function XRef_processXRefTable(parser) {
+            if (!('tableState' in this)) {
+              // Stores state of the table as we process it so we can resume
+              // from middle of table in case of missing data error
+              this.tableState = {
+                entryNum: 0,
+                streamPos: parser.lexer.stream.pos,
+                parserBuf1: parser.buf1,
+                parserBuf2: parser.buf2
+              };
+            }
+            var obj = this.readXRefTable(parser);
+            // Sanity check
+            if (!isCmd(obj, 'trailer')) {
+              error('Invalid XRef table: could not find trailer dictionary');
+            }
+            // Read trailer dictionary, e.g.
+            // trailer
+            //    << /Size 22
+            //      /Root 20R
+            //      /Info 10R
+            //      /ID [ <81b14aafa313db63dbd6f981e49f94f4> ]
+            //    >>
+            // The parser goes through the entire stream << ... >> and provides
+            // a getter interface for the key-value table
+            var dict = parser.getObj();
+            // The pdflib PDF generator can generate a nested trailer dictionary
+            if (!isDict(dict) && dict.dict) {
+              dict = dict.dict;
+            }
+            if (!isDict(dict)) {
+              error('Invalid XRef table: could not parse trailer dictionary');
+            }
+            delete this.tableState;
+            return dict;
+          },
+          readXRefTable: function XRef_readXRefTable(parser) {
+            // Example of cross-reference table:
+            // xref
+            // 0 1                    <-- subsection header (first obj #, obj count)
+            // 0000000000 65535 f     <-- actual object (offset, generation #, f/n)
+            // 23 2                   <-- subsection header ... and so on ...
+            // 0000025518 00002 n
+            // 0000025635 00000 n
+            // trailer
+            // ...
+            var stream = parser.lexer.stream;
+            var tableState = this.tableState;
+            stream.pos = tableState.streamPos;
+            parser.buf1 = tableState.parserBuf1;
+            parser.buf2 = tableState.parserBuf2;
+            // Outer loop is over subsection headers
+            var obj;
+            while (true) {
+              if (!('firstEntryNum' in tableState) || !('entryCount' in tableState)) {
+                if (isCmd(obj = parser.getObj(), 'trailer')) {
+                  break;
+                }
+                tableState.firstEntryNum = obj;
+                tableState.entryCount = parser.getObj();
+              }
+              var first = tableState.firstEntryNum;
+              var count = tableState.entryCount;
+              if (!isInt(first) || !isInt(count)) {
+                error('Invalid XRef table: wrong types in subsection header');
+              }
+              // Inner loop is over objects themselves
+              for (var i = tableState.entryNum; i < count; i++) {
+                tableState.streamPos = stream.pos;
+                tableState.entryNum = i;
+                tableState.parserBuf1 = parser.buf1;
+                tableState.parserBuf2 = parser.buf2;
+                var entry = {};
+                entry.offset = parser.getObj();
+                entry.gen = parser.getObj();
+                var type = parser.getObj();
+                if (isCmd(type, 'f')) {
+                  entry.free = true;
+                } else if (isCmd(type, 'n')) {
+                  entry.uncompressed = true;
+                }
+                // Validate entry obj
+                if (!isInt(entry.offset) || !isInt(entry.gen) || !(entry.free || entry.uncompressed)) {
+                  error('Invalid entry in XRef subsection: ' + first + ', ' + count);
+                }
+                // The first xref table entry, i.e. obj 0, should be free. Attempting
+                // to adjust an incorrect first obj # (fixes issue 3248 and 7229).
+                if (i === 0 && entry.free && first === 1) {
+                  first = 0;
+                }
+                if (!this.entries[i + first]) {
+                  this.entries[i + first] = entry;
+                }
+              }
+              tableState.entryNum = 0;
+              tableState.streamPos = stream.pos;
+              tableState.parserBuf1 = parser.buf1;
+              tableState.parserBuf2 = parser.buf2;
+              delete tableState.firstEntryNum;
+              delete tableState.entryCount;
+            }
+            // Sanity check: as per spec, first object must be free
+            if (this.entries[0] && !this.entries[0].free) {
+              error('Invalid XRef table: unexpected first object');
+            }
+            return obj;
+          },
+          processXRefStream: function XRef_processXRefStream(stream) {
+            if (!('streamState' in this)) {
+              // Stores state of the stream as we process it so we can resume
+              // from middle of stream in case of missing data error
+              var streamParameters = stream.dict;
+              var byteWidths = streamParameters.get('W');
+              var range = streamParameters.get('Index');
+              if (!range) {
+                range = [
+                  0,
+                  streamParameters.get('Size')
+                ];
+              }
+              this.streamState = {
+                entryRanges: range,
+                byteWidths: byteWidths,
+                entryNum: 0,
+                streamPos: stream.pos
+              };
+            }
+            this.readXRefStream(stream);
+            delete this.streamState;
+            return stream.dict;
+          },
+          readXRefStream: function XRef_readXRefStream(stream) {
+            var i, j;
+            var streamState = this.streamState;
+            stream.pos = streamState.streamPos;
+            var byteWidths = streamState.byteWidths;
+            var typeFieldWidth = byteWidths[0];
+            var offsetFieldWidth = byteWidths[1];
+            var generationFieldWidth = byteWidths[2];
+            var entryRanges = streamState.entryRanges;
+            while (entryRanges.length > 0) {
+              var first = entryRanges[0];
+              var n = entryRanges[1];
+              if (!isInt(first) || !isInt(n)) {
+                error('Invalid XRef range fields: ' + first + ', ' + n);
+              }
+              if (!isInt(typeFieldWidth) || !isInt(offsetFieldWidth) || !isInt(generationFieldWidth)) {
+                error('Invalid XRef entry fields length: ' + first + ', ' + n);
+              }
+              for (i = streamState.entryNum; i < n; ++i) {
+                streamState.entryNum = i;
+                streamState.streamPos = stream.pos;
+                var type = 0, offset = 0, generation = 0;
+                for (j = 0; j < typeFieldWidth; ++j) {
+                  type = type << 8 | stream.getByte();
+                }
+                // if type field is absent, its default value is 1
+                if (typeFieldWidth === 0) {
+                  type = 1;
+                }
+                for (j = 0; j < offsetFieldWidth; ++j) {
+                  offset = offset << 8 | stream.getByte();
+                }
+                for (j = 0; j < generationFieldWidth; ++j) {
+                  generation = generation << 8 | stream.getByte();
+                }
+                var entry = {};
+                entry.offset = offset;
+                entry.gen = generation;
+                switch (type) {
+                case 0:
+                  entry.free = true;
+                  break;
+                case 1:
+                  entry.uncompressed = true;
+                  break;
+                case 2:
+                  break;
+                default:
+                  error('Invalid XRef entry type: ' + type);
+                }
+                if (!this.entries[first + i]) {
+                  this.entries[first + i] = entry;
+                }
+              }
+              streamState.entryNum = 0;
+              streamState.streamPos = stream.pos;
+              entryRanges.splice(0, 2);
+            }
+          },
+          indexObjects: function XRef_indexObjects() {
+            // Simple scan through the PDF content to find objects,
+            // trailers and XRef streams.
+            var TAB = 0x9, LF = 0xA, CR = 0xD, SPACE = 0x20;
+            var PERCENT = 0x25, LT = 0x3C;
+            function readToken(data, offset) {
+              var token = '', ch = data[offset];
+              while (ch !== LF && ch !== CR && ch !== LT) {
+                if (++offset >= data.length) {
+                  break;
+                }
+                token += String.fromCharCode(ch);
+                ch = data[offset];
+              }
+              return token;
+            }
+            function skipUntil(data, offset, what) {
+              var length = what.length, dataLength = data.length;
+              var skipped = 0;
+              // finding byte sequence
+              while (offset < dataLength) {
+                var i = 0;
+                while (i < length && data[offset + i] === what[i]) {
+                  ++i;
+                }
+                if (i >= length) {
+                  break;
+                }
+                // sequence found
+                offset++;
+                skipped++;
+              }
+              return skipped;
+            }
+            var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/;
+            var trailerBytes = new Uint8Array([
+              116,
+              114,
+              97,
+              105,
+              108,
+              101,
+              114
+            ]);
+            var startxrefBytes = new Uint8Array([
+              115,
+              116,
+              97,
+              114,
+              116,
+              120,
+              114,
+              101,
+              102
+            ]);
+            var endobjBytes = new Uint8Array([
+              101,
+              110,
+              100,
+              111,
+              98,
+              106
+            ]);
+            var xrefBytes = new Uint8Array([
+              47,
+              88,
+              82,
+              101,
+              102
+            ]);
+            // Clear out any existing entries, since they may be bogus.
+            this.entries.length = 0;
+            var stream = this.stream;
+            stream.pos = 0;
+            var buffer = stream.getBytes();
+            var position = stream.start, length = buffer.length;
+            var trailers = [], xrefStms = [];
+            while (position < length) {
+              var ch = buffer[position];
+              if (ch === TAB || ch === LF || ch === CR || ch === SPACE) {
+                ++position;
+                continue;
+              }
+              if (ch === PERCENT) {
+                // %-comment
+                do {
+                  ++position;
+                  if (position >= length) {
+                    break;
+                  }
+                  ch = buffer[position];
+                } while (ch !== LF && ch !== CR);
+                continue;
+              }
+              var token = readToken(buffer, position);
+              var m;
+              if (token.indexOf('xref') === 0 && (token.length === 4 || /\s/.test(token[4]))) {
+                position += skipUntil(buffer, position, trailerBytes);
+                trailers.push(position);
+                position += skipUntil(buffer, position, startxrefBytes);
+              } else if (m = objRegExp.exec(token)) {
+                if (typeof this.entries[m[1]] === 'undefined') {
+                  this.entries[m[1]] = {
+                    offset: position - stream.start,
+                    gen: m[2] | 0,
+                    uncompressed: true
+                  };
+                }
+                var contentLength = skipUntil(buffer, position, endobjBytes) + 7;
+                var content = buffer.subarray(position, position + contentLength);
+                // checking XRef stream suspect
+                // (it shall have '/XRef' and next char is not a letter)
+                var xrefTagOffset = skipUntil(content, 0, xrefBytes);
+                if (xrefTagOffset < contentLength && content[xrefTagOffset + 5] < 64) {
+                  xrefStms.push(position - stream.start);
+                  this.xrefstms[position - stream.start] = 1;
+                }
+                // Avoid recursion
+                position += contentLength;
+              } else if (token.indexOf('trailer') === 0 && (token.length === 7 || /\s/.test(token[7]))) {
+                trailers.push(position);
+                position += skipUntil(buffer, position, startxrefBytes);
+              } else {
+                position += token.length + 1;
+              }
+            }
+            // reading XRef streams
+            var i, ii;
+            for (i = 0, ii = xrefStms.length; i < ii; ++i) {
+              this.startXRefQueue.push(xrefStms[i]);
+              this.readXRef(/* recoveryMode */
+              true);
+            }
+            // finding main trailer
+            var dict;
+            for (i = 0, ii = trailers.length; i < ii; ++i) {
+              stream.pos = trailers[i];
+              var parser = new Parser(new Lexer(stream), /* allowStreams = */
+              true, /* xref = */
+              this, /* recoveryMode = */
+              true);
+              var obj = parser.getObj();
+              if (!isCmd(obj, 'trailer')) {
+                continue;
+              }
+              // read the trailer dictionary
+              dict = parser.getObj();
+              if (!isDict(dict)) {
+                continue;
+              }
+              // taking the first one with 'ID'
+              if (dict.has('ID')) {
+                return dict;
+              }
+            }
+            // no tailer with 'ID', taking last one (if exists)
+            if (dict) {
+              return dict;
+            }
+            // nothing helps
+            // calling error() would reject worker with an UnknownErrorException.
+            throw new InvalidPDFException('Invalid PDF structure');
+          },
+          readXRef: function XRef_readXRef(recoveryMode) {
+            var stream = this.stream;
+            try {
+              while (this.startXRefQueue.length) {
+                var startXRef = this.startXRefQueue[0];
+                stream.pos = startXRef + stream.start;
+                var parser = new Parser(new Lexer(stream), true, this);
+                var obj = parser.getObj();
+                var dict;
+                // Get dictionary
+                if (isCmd(obj, 'xref')) {
+                  // Parse end-of-file XRef
+                  dict = this.processXRefTable(parser);
+                  if (!this.topDict) {
+                    this.topDict = dict;
+                  }
+                  // Recursively get other XRefs 'XRefStm', if any
+                  obj = dict.get('XRefStm');
+                  if (isInt(obj)) {
+                    var pos = obj;
+                    // ignore previously loaded xref streams
+                    // (possible infinite recursion)
+                    if (!(pos in this.xrefstms)) {
+                      this.xrefstms[pos] = 1;
+                      this.startXRefQueue.push(pos);
+                    }
+                  }
+                } else if (isInt(obj)) {
+                  // Parse in-stream XRef
+                  if (!isInt(parser.getObj()) || !isCmd(parser.getObj(), 'obj') || !isStream(obj = parser.getObj())) {
+                    error('Invalid XRef stream');
+                  }
+                  dict = this.processXRefStream(obj);
+                  if (!this.topDict) {
+                    this.topDict = dict;
+                  }
+                  if (!dict) {
+                    error('Failed to read XRef stream');
+                  }
+                } else {
+                  error('Invalid XRef stream header');
+                }
+                // Recursively get previous dictionary, if any
+                obj = dict.get('Prev');
+                if (isInt(obj)) {
+                  this.startXRefQueue.push(obj);
+                } else if (isRef(obj)) {
+                  // The spec says Prev must not be a reference, i.e. "/Prev NNN"
+                  // This is a fallback for non-compliant PDFs, i.e. "/Prev NNN 0 R"
+                  this.startXRefQueue.push(obj.num);
+                }
+                this.startXRefQueue.shift();
+              }
+              return this.topDict;
+            } catch (e) {
+              if (e instanceof MissingDataException) {
+                throw e;
+              }
+              info('(while reading XRef): ' + e);
+            }
+            if (recoveryMode) {
+              return;
+            }
+            throw new XRefParseException();
+          },
+          getEntry: function XRef_getEntry(i) {
+            var xrefEntry = this.entries[i];
+            if (xrefEntry && !xrefEntry.free && xrefEntry.offset) {
+              return xrefEntry;
+            }
+            return null;
+          },
+          fetchIfRef: function XRef_fetchIfRef(obj, suppressEncryption) {
+            if (!isRef(obj)) {
+              return obj;
+            }
+            return this.fetch(obj, suppressEncryption);
+          },
+          fetch: function XRef_fetch(ref, suppressEncryption) {
+            assert(isRef(ref), 'ref object is not a reference');
+            var num = ref.num;
+            if (num in this.cache) {
+              var cacheEntry = this.cache[num];
+              return cacheEntry;
+            }
+            var xrefEntry = this.getEntry(num);
+            // the referenced entry can be free
+            if (xrefEntry === null) {
+              return this.cache[num] = null;
+            }
+            if (xrefEntry.uncompressed) {
+              xrefEntry = this.fetchUncompressed(ref, xrefEntry, suppressEncryption);
+            } else {
+              xrefEntry = this.fetchCompressed(xrefEntry, suppressEncryption);
+            }
+            if (isDict(xrefEntry)) {
+              xrefEntry.objId = ref.toString();
+            } else if (isStream(xrefEntry)) {
+              xrefEntry.dict.objId = ref.toString();
+            }
+            return xrefEntry;
+          },
+          fetchUncompressed: function XRef_fetchUncompressed(ref, xrefEntry, suppressEncryption) {
+            var gen = ref.gen;
+            var num = ref.num;
+            if (xrefEntry.gen !== gen) {
+              error('inconsistent generation in XRef');
+            }
+            var stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
+            var parser = new Parser(new Lexer(stream), true, this);
+            var obj1 = parser.getObj();
+            var obj2 = parser.getObj();
+            var obj3 = parser.getObj();
+            if (!isInt(obj1) || parseInt(obj1, 10) !== num || !isInt(obj2) || parseInt(obj2, 10) !== gen || !isCmd(obj3)) {
+              error('bad XRef entry');
+            }
+            if (!isCmd(obj3, 'obj')) {
+              // some bad PDFs use "obj1234" and really mean 1234
+              if (obj3.cmd.indexOf('obj') === 0) {
+                num = parseInt(obj3.cmd.substring(3), 10);
+                if (!isNaN(num)) {
+                  return num;
+                }
+              }
+              error('bad XRef entry');
+            }
+            if (this.encrypt && !suppressEncryption) {
+              xrefEntry = parser.getObj(this.encrypt.createCipherTransform(num, gen));
+            } else {
+              xrefEntry = parser.getObj();
+            }
+            if (!isStream(xrefEntry)) {
+              this.cache[num] = xrefEntry;
+            }
+            return xrefEntry;
+          },
+          fetchCompressed: function XRef_fetchCompressed(xrefEntry, suppressEncryption) {
+            var tableOffset = xrefEntry.offset;
+            var stream = this.fetch(new Ref(tableOffset, 0));
+            if (!isStream(stream)) {
+              error('bad ObjStm stream');
+            }
+            var first = stream.dict.get('First');
+            var n = stream.dict.get('N');
+            if (!isInt(first) || !isInt(n)) {
+              error('invalid first and n parameters for ObjStm stream');
+            }
+            var parser = new Parser(new Lexer(stream), false, this);
+            parser.allowStreams = true;
+            var i, entries = [], num, nums = [];
+            // read the object numbers to populate cache
+            for (i = 0; i < n; ++i) {
+              num = parser.getObj();
+              if (!isInt(num)) {
+                error('invalid object number in the ObjStm stream: ' + num);
+              }
+              nums.push(num);
+              var offset = parser.getObj();
+              if (!isInt(offset)) {
+                error('invalid object offset in the ObjStm stream: ' + offset);
+              }
+            }
+            // read stream objects for cache
+            for (i = 0; i < n; ++i) {
+              entries.push(parser.getObj());
+              // The ObjStm should not contain 'endobj'. If it's present, skip over it
+              // to support corrupt PDFs (fixes issue 5241, bug 898610, bug 1037816).
+              if (isCmd(parser.buf1, 'endobj')) {
+                parser.shift();
+              }
+              num = nums[i];
+              var entry = this.entries[num];
+              if (entry && entry.offset === tableOffset && entry.gen === i) {
+                this.cache[num] = entries[i];
+              }
+            }
+            xrefEntry = entries[xrefEntry.gen];
+            if (xrefEntry === undefined) {
+              error('bad XRef entry for compressed object');
+            }
+            return xrefEntry;
+          },
+          fetchIfRefAsync: function XRef_fetchIfRefAsync(obj, suppressEncryption) {
+            if (!isRef(obj)) {
+              return Promise.resolve(obj);
+            }
+            return this.fetchAsync(obj, suppressEncryption);
+          },
+          fetchAsync: function XRef_fetchAsync(ref, suppressEncryption) {
+            var streamManager = this.stream.manager;
+            var xref = this;
+            return new Promise(function tryFetch(resolve, reject) {
+              try {
+                resolve(xref.fetch(ref, suppressEncryption));
+              } catch (e) {
+                if (e instanceof MissingDataException) {
+                  streamManager.requestRange(e.begin, e.end).then(function () {
+                    tryFetch(resolve, reject);
+                  }, reject);
+                  return;
+                }
+                reject(e);
+              }
+            });
+          },
+          getCatalogObj: function XRef_getCatalogObj() {
+            return this.root;
+          }
+        };
+        return XRef;
+      }();
+      /**
+       * A NameTree/NumberTree is like a Dict but has some advantageous properties,
+       * see the specification (7.9.6 and 7.9.7) for additional details.
+       * TODO: implement all the Dict functions and make this more efficient.
+       */
+      var NameOrNumberTree = function NameOrNumberTreeClosure() {
+        function NameOrNumberTree(root, xref) {
+          throw new Error('Cannot initialize NameOrNumberTree.');
+        }
+        NameOrNumberTree.prototype = {
+          getAll: function NameOrNumberTree_getAll() {
+            var dict = Object.create(null);
+            if (!this.root) {
+              return dict;
+            }
+            var xref = this.xref;
+            // Reading Name/Number tree.
+            var processed = new RefSet();
+            processed.put(this.root);
+            var queue = [this.root];
+            while (queue.length > 0) {
+              var i, n;
+              var obj = xref.fetchIfRef(queue.shift());
+              if (!isDict(obj)) {
+                continue;
+              }
+              if (obj.has('Kids')) {
+                var kids = obj.get('Kids');
+                for (i = 0, n = kids.length; i < n; i++) {
+                  var kid = kids[i];
+                  assert(!processed.has(kid), 'Duplicate entry in "' + this._type + '" tree.');
+                  queue.push(kid);
+                  processed.put(kid);
+                }
+                continue;
+              }
+              var entries = obj.get(this._type);
+              if (isArray(entries)) {
+                for (i = 0, n = entries.length; i < n; i += 2) {
+                  dict[xref.fetchIfRef(entries[i])] = xref.fetchIfRef(entries[i + 1]);
+                }
+              }
+            }
+            return dict;
+          },
+          get: function NameOrNumberTree_get(key) {
+            if (!this.root) {
+              return null;
+            }
+            var xref = this.xref;
+            var kidsOrEntries = xref.fetchIfRef(this.root);
+            var loopCount = 0;
+            var MAX_LEVELS = 10;
+            var l, r, m;
+            // Perform a binary search to quickly find the entry that
+            // contains the key we are looking for.
+            while (kidsOrEntries.has('Kids')) {
+              if (++loopCount > MAX_LEVELS) {
+                warn('Search depth limit reached for "' + this._type + '" tree.');
+                return null;
+              }
+              var kids = kidsOrEntries.get('Kids');
+              if (!isArray(kids)) {
+                return null;
+              }
+              l = 0;
+              r = kids.length - 1;
+              while (l <= r) {
+                m = l + r >> 1;
+                var kid = xref.fetchIfRef(kids[m]);
+                var limits = kid.get('Limits');
+                if (key < xref.fetchIfRef(limits[0])) {
+                  r = m - 1;
+                } else if (key > xref.fetchIfRef(limits[1])) {
+                  l = m + 1;
+                } else {
+                  kidsOrEntries = xref.fetchIfRef(kids[m]);
+                  break;
+                }
+              }
+              if (l > r) {
+                return null;
+              }
+            }
+            // If we get here, then we have found the right entry. Now go through the
+            // entries in the dictionary until we find the key we're looking for.
+            var entries = kidsOrEntries.get(this._type);
+            if (isArray(entries)) {
+              // Perform a binary search to reduce the lookup time.
+              l = 0;
+              r = entries.length - 2;
+              while (l <= r) {
+                // Check only even indices (0, 2, 4, ...) because the
+                // odd indices contain the actual data.
+                m = l + r & ~1;
+                var currentKey = xref.fetchIfRef(entries[m]);
+                if (key < currentKey) {
+                  r = m - 2;
+                } else if (key > currentKey) {
+                  l = m + 2;
+                } else {
+                  return xref.fetchIfRef(entries[m + 1]);
+                }
+              }
+            }
+            return null;
+          }
+        };
+        return NameOrNumberTree;
+      }();
+      var NameTree = function NameTreeClosure() {
+        function NameTree(root, xref) {
+          this.root = root;
+          this.xref = xref;
+          this._type = 'Names';
+        }
+        Util.inherit(NameTree, NameOrNumberTree, {});
+        return NameTree;
+      }();
+      var NumberTree = function NumberTreeClosure() {
+        function NumberTree(root, xref) {
+          this.root = root;
+          this.xref = xref;
+          this._type = 'Nums';
+        }
+        Util.inherit(NumberTree, NameOrNumberTree, {});
+        return NumberTree;
+      }();
+      /**
+       * "A PDF file can refer to the contents of another file by using a File
+       * Specification (PDF 1.1)", see the spec (7.11) for more details.
+       * NOTE: Only embedded files are supported (as part of the attachments support)
+       * TODO: support the 'URL' file system (with caching if !/V), portable
+       * collections attributes and related files (/RF)
+       */
+      var FileSpec = function FileSpecClosure() {
+        function FileSpec(root, xref) {
+          if (!root || !isDict(root)) {
+            return;
+          }
+          this.xref = xref;
+          this.root = root;
+          if (root.has('FS')) {
+            this.fs = root.get('FS');
+          }
+          this.description = root.has('Desc') ? stringToPDFString(root.get('Desc')) : '';
+          if (root.has('RF')) {
+            warn('Related file specifications are not supported');
+          }
+          this.contentAvailable = true;
+          if (!root.has('EF')) {
+            this.contentAvailable = false;
+            warn('Non-embedded file specifications are not supported');
+          }
+        }
+        function pickPlatformItem(dict) {
+          // Look for the filename in this order:
+          // UF, F, Unix, Mac, DOS
+          if (dict.has('UF')) {
+            return dict.get('UF');
+          } else if (dict.has('F')) {
+            return dict.get('F');
+          } else if (dict.has('Unix')) {
+            return dict.get('Unix');
+          } else if (dict.has('Mac')) {
+            return dict.get('Mac');
+          } else if (dict.has('DOS')) {
+            return dict.get('DOS');
+          } else {
+            return null;
+          }
+        }
+        FileSpec.prototype = {
+          get filename() {
+            if (!this._filename && this.root) {
+              var filename = pickPlatformItem(this.root) || 'unnamed';
+              this._filename = stringToPDFString(filename).replace(/\\\\/g, '\\').replace(/\\\//g, '/').replace(/\\/g, '/');
+            }
+            return this._filename;
+          },
+          get content() {
+            if (!this.contentAvailable) {
+              return null;
+            }
+            if (!this.contentRef && this.root) {
+              this.contentRef = pickPlatformItem(this.root.get('EF'));
+            }
+            var content = null;
+            if (this.contentRef) {
+              var xref = this.xref;
+              var fileObj = xref.fetchIfRef(this.contentRef);
+              if (fileObj && isStream(fileObj)) {
+                content = fileObj.getBytes();
+              } else {
+                warn('Embedded file specification points to non-existing/invalid ' + 'content');
+              }
+            } else {
+              warn('Embedded file specification does not have a content');
+            }
+            return content;
+          },
+          get serializable() {
+            return {
+              filename: this.filename,
+              content: this.content
+            };
+          }
+        };
+        return FileSpec;
+      }();
+      /**
+       * A helper for loading missing data in object graphs. It traverses the graph
+       * depth first and queues up any objects that have missing data. Once it has
+       * has traversed as many objects that are available it attempts to bundle the
+       * missing data requests and then resume from the nodes that weren't ready.
+       *
+       * NOTE: It provides protection from circular references by keeping track of
+       * of loaded references. However, you must be careful not to load any graphs
+       * that have references to the catalog or other pages since that will cause the
+       * entire PDF document object graph to be traversed.
+       */
+      var ObjectLoader = function () {
+        function mayHaveChildren(value) {
+          return isRef(value) || isDict(value) || isArray(value) || isStream(value);
+        }
+        function addChildren(node, nodesToVisit) {
+          var value;
+          if (isDict(node) || isStream(node)) {
+            var map;
+            if (isDict(node)) {
+              map = node.map;
+            } else {
+              map = node.dict.map;
+            }
+            for (var key in map) {
+              value = map[key];
+              if (mayHaveChildren(value)) {
+                nodesToVisit.push(value);
+              }
+            }
+          } else if (isArray(node)) {
+            for (var i = 0, ii = node.length; i < ii; i++) {
+              value = node[i];
+              if (mayHaveChildren(value)) {
+                nodesToVisit.push(value);
+              }
+            }
+          }
+        }
+        function ObjectLoader(obj, keys, xref) {
+          this.obj = obj;
+          this.keys = keys;
+          this.xref = xref;
+          this.refSet = null;
+          this.capability = null;
+        }
+        ObjectLoader.prototype = {
+          load: function ObjectLoader_load() {
+            var keys = this.keys;
+            this.capability = createPromiseCapability();
+            // Don't walk the graph if all the data is already loaded.
+            if (!(this.xref.stream instanceof ChunkedStream) || this.xref.stream.getMissingChunks().length === 0) {
+              this.capability.resolve();
+              return this.capability.promise;
+            }
+            this.refSet = new RefSet();
+            // Setup the initial nodes to visit.
+            var nodesToVisit = [];
+            for (var i = 0; i < keys.length; i++) {
+              nodesToVisit.push(this.obj[keys[i]]);
+            }
+            this._walk(nodesToVisit);
+            return this.capability.promise;
+          },
+          _walk: function ObjectLoader_walk(nodesToVisit) {
+            var nodesToRevisit = [];
+            var pendingRequests = [];
+            // DFS walk of the object graph.
+            while (nodesToVisit.length) {
+              var currentNode = nodesToVisit.pop();
+              // Only references or chunked streams can cause missing data exceptions.
+              if (isRef(currentNode)) {
+                // Skip nodes that have already been visited.
+                if (this.refSet.has(currentNode)) {
+                  continue;
+                }
+                try {
+                  var ref = currentNode;
+                  this.refSet.put(ref);
+                  currentNode = this.xref.fetch(currentNode);
+                } catch (e) {
+                  if (!(e instanceof MissingDataException)) {
+                    throw e;
+                  }
+                  nodesToRevisit.push(currentNode);
+                  pendingRequests.push({
+                    begin: e.begin,
+                    end: e.end
+                  });
+                }
+              }
+              if (currentNode && currentNode.getBaseStreams) {
+                var baseStreams = currentNode.getBaseStreams();
+                var foundMissingData = false;
+                for (var i = 0; i < baseStreams.length; i++) {
+                  var stream = baseStreams[i];
+                  if (stream.getMissingChunks && stream.getMissingChunks().length) {
+                    foundMissingData = true;
+                    pendingRequests.push({
+                      begin: stream.start,
+                      end: stream.end
+                    });
+                  }
+                }
+                if (foundMissingData) {
+                  nodesToRevisit.push(currentNode);
+                }
+              }
+              addChildren(currentNode, nodesToVisit);
+            }
+            if (pendingRequests.length) {
+              this.xref.stream.manager.requestRanges(pendingRequests).then(function pendingRequestCallback() {
+                nodesToVisit = nodesToRevisit;
+                for (var i = 0; i < nodesToRevisit.length; i++) {
+                  var node = nodesToRevisit[i];
+                  // Remove any reference nodes from the currrent refset so they
+                  // aren't skipped when we revist them.
+                  if (isRef(node)) {
+                    this.refSet.remove(node);
+                  }
+                }
+                this._walk(nodesToVisit);
+              }.bind(this), this.capability.reject);
+              return;
+            }
+            // Everything is loaded.
+            this.refSet = null;
+            this.capability.resolve();
+          }
+        };
+        return ObjectLoader;
+      }();
+      exports.Catalog = Catalog;
+      exports.ObjectLoader = ObjectLoader;
+      exports.XRef = XRef;
+      exports.FileSpec = FileSpec;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCorePattern = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreFunction, root.pdfjsCoreColorSpace);
+    }(this, function (exports, sharedUtil, corePrimitives, coreFunction, coreColorSpace) {
+      var UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES;
+      var MissingDataException = sharedUtil.MissingDataException;
+      var Util = sharedUtil.Util;
+      var assert = sharedUtil.assert;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var warn = sharedUtil.warn;
+      var isStream = corePrimitives.isStream;
+      var PDFFunction = coreFunction.PDFFunction;
+      var ColorSpace = coreColorSpace.ColorSpace;
+      var ShadingType = {
+        FUNCTION_BASED: 1,
+        AXIAL: 2,
+        RADIAL: 3,
+        FREE_FORM_MESH: 4,
+        LATTICE_FORM_MESH: 5,
+        COONS_PATCH_MESH: 6,
+        TENSOR_PATCH_MESH: 7
+      };
+      var Pattern = function PatternClosure() {
+        // Constructor should define this.getPattern
+        function Pattern() {
+          error('should not call Pattern constructor');
+        }
+        Pattern.prototype = {
+          // Input: current Canvas context
+          // Output: the appropriate fillStyle or strokeStyle
+          getPattern: function Pattern_getPattern(ctx) {
+            error('Should not call Pattern.getStyle: ' + ctx);
+          }
+        };
+        Pattern.parseShading = function Pattern_parseShading(shading, matrix, xref, res, handler) {
+          var dict = isStream(shading) ? shading.dict : shading;
+          var type = dict.get('ShadingType');
+          try {
+            switch (type) {
+            case ShadingType.AXIAL:
+            case ShadingType.RADIAL:
+              // Both radial and axial shadings are handled by RadialAxial shading.
+              return new Shadings.RadialAxial(dict, matrix, xref, res);
+            case ShadingType.FREE_FORM_MESH:
+            case ShadingType.LATTICE_FORM_MESH:
+            case ShadingType.COONS_PATCH_MESH:
+            case ShadingType.TENSOR_PATCH_MESH:
+              return new Shadings.Mesh(shading, matrix, xref, res);
+            default:
+              throw new Error('Unsupported ShadingType: ' + type);
+            }
+          } catch (ex) {
+            if (ex instanceof MissingDataException) {
+              throw ex;
+            }
+            handler.send('UnsupportedFeature', { featureId: UNSUPPORTED_FEATURES.shadingPattern });
+            warn(ex);
+            return new Shadings.Dummy();
+          }
+        };
+        return Pattern;
+      }();
+      var Shadings = {};
+      // A small number to offset the first/last color stops so we can insert ones to
+      // support extend. Number.MIN_VALUE is too small and breaks the extend.
+      Shadings.SMALL_NUMBER = 1e-6;
+      // Radial and axial shading have very similar implementations
+      // If needed, the implementations can be broken into two classes
+      Shadings.RadialAxial = function RadialAxialClosure() {
+        function RadialAxial(dict, matrix, xref, res) {
+          this.matrix = matrix;
+          this.coordsArr = dict.getArray('Coords');
+          this.shadingType = dict.get('ShadingType');
+          this.type = 'Pattern';
+          var cs = dict.get('ColorSpace', 'CS');
+          cs = ColorSpace.parse(cs, xref, res);
+          this.cs = cs;
+          var t0 = 0.0, t1 = 1.0;
+          if (dict.has('Domain')) {
+            var domainArr = dict.getArray('Domain');
+            t0 = domainArr[0];
+            t1 = domainArr[1];
+          }
+          var extendStart = false, extendEnd = false;
+          if (dict.has('Extend')) {
+            var extendArr = dict.getArray('Extend');
+            extendStart = extendArr[0];
+            extendEnd = extendArr[1];
+          }
+          if (this.shadingType === ShadingType.RADIAL && (!extendStart || !extendEnd)) {
+            // Radial gradient only currently works if either circle is fully within
+            // the other circle.
+            var x1 = this.coordsArr[0];
+            var y1 = this.coordsArr[1];
+            var r1 = this.coordsArr[2];
+            var x2 = this.coordsArr[3];
+            var y2 = this.coordsArr[4];
+            var r2 = this.coordsArr[5];
+            var distance = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+            if (r1 <= r2 + distance && r2 <= r1 + distance) {
+              warn('Unsupported radial gradient.');
+            }
+          }
+          this.extendStart = extendStart;
+          this.extendEnd = extendEnd;
+          var fnObj = dict.get('Function');
+          var fn = PDFFunction.parseArray(xref, fnObj);
+          // 10 samples seems good enough for now, but probably won't work
+          // if there are sharp color changes. Ideally, we would implement
+          // the spec faithfully and add lossless optimizations.
+          var diff = t1 - t0;
+          var step = diff / 10;
+          var colorStops = this.colorStops = [];
+          // Protect against bad domains so we don't end up in an infinte loop below.
+          if (t0 >= t1 || step <= 0) {
+            // Acrobat doesn't seem to handle these cases so we'll ignore for
+            // now.
+            info('Bad shading domain.');
+            return;
+          }
+          var color = new Float32Array(cs.numComps), ratio = new Float32Array(1);
+          var rgbColor;
+          for (var i = t0; i <= t1; i += step) {
+            ratio[0] = i;
+            fn(ratio, 0, color, 0);
+            rgbColor = cs.getRgb(color, 0);
+            var cssColor = Util.makeCssRgb(rgbColor[0], rgbColor[1], rgbColor[2]);
+            colorStops.push([
+              (i - t0) / diff,
+              cssColor
+            ]);
+          }
+          var background = 'transparent';
+          if (dict.has('Background')) {
+            rgbColor = cs.getRgb(dict.get('Background'), 0);
+            background = Util.makeCssRgb(rgbColor[0], rgbColor[1], rgbColor[2]);
+          }
+          if (!extendStart) {
+            // Insert a color stop at the front and offset the first real color stop
+            // so it doesn't conflict with the one we insert.
+            colorStops.unshift([
+              0,
+              background
+            ]);
+            colorStops[1][0] += Shadings.SMALL_NUMBER;
+          }
+          if (!extendEnd) {
+            // Same idea as above in extendStart but for the end.
+            colorStops[colorStops.length - 1][0] -= Shadings.SMALL_NUMBER;
+            colorStops.push([
+              1,
+              background
+            ]);
+          }
+          this.colorStops = colorStops;
+        }
+        RadialAxial.prototype = {
+          getIR: function RadialAxial_getIR() {
+            var coordsArr = this.coordsArr;
+            var shadingType = this.shadingType;
+            var type, p0, p1, r0, r1;
+            if (shadingType === ShadingType.AXIAL) {
+              p0 = [
+                coordsArr[0],
+                coordsArr[1]
+              ];
+              p1 = [
+                coordsArr[2],
+                coordsArr[3]
+              ];
+              r0 = null;
+              r1 = null;
+              type = 'axial';
+            } else if (shadingType === ShadingType.RADIAL) {
+              p0 = [
+                coordsArr[0],
+                coordsArr[1]
+              ];
+              p1 = [
+                coordsArr[3],
+                coordsArr[4]
+              ];
+              r0 = coordsArr[2];
+              r1 = coordsArr[5];
+              type = 'radial';
+            } else {
+              error('getPattern type unknown: ' + shadingType);
+            }
+            var matrix = this.matrix;
+            if (matrix) {
+              p0 = Util.applyTransform(p0, matrix);
+              p1 = Util.applyTransform(p1, matrix);
+              if (shadingType === ShadingType.RADIAL) {
+                var scale = Util.singularValueDecompose2dScale(matrix);
+                r0 *= scale[0];
+                r1 *= scale[1];
+              }
+            }
+            return [
+              'RadialAxial',
+              type,
+              this.colorStops,
+              p0,
+              p1,
+              r0,
+              r1
+            ];
+          }
+        };
+        return RadialAxial;
+      }();
+      // All mesh shading. For now, they will be presented as set of the triangles
+      // to be drawn on the canvas and rgb color for each vertex.
+      Shadings.Mesh = function MeshClosure() {
+        function MeshStreamReader(stream, context) {
+          this.stream = stream;
+          this.context = context;
+          this.buffer = 0;
+          this.bufferLength = 0;
+          var numComps = context.numComps;
+          this.tmpCompsBuf = new Float32Array(numComps);
+          var csNumComps = context.colorSpace.numComps;
+          this.tmpCsCompsBuf = context.colorFn ? new Float32Array(csNumComps) : this.tmpCompsBuf;
+        }
+        MeshStreamReader.prototype = {
+          get hasData() {
+            if (this.stream.end) {
+              return this.stream.pos < this.stream.end;
+            }
+            if (this.bufferLength > 0) {
+              return true;
+            }
+            var nextByte = this.stream.getByte();
+            if (nextByte < 0) {
+              return false;
+            }
+            this.buffer = nextByte;
+            this.bufferLength = 8;
+            return true;
+          },
+          readBits: function MeshStreamReader_readBits(n) {
+            var buffer = this.buffer;
+            var bufferLength = this.bufferLength;
+            if (n === 32) {
+              if (bufferLength === 0) {
+                return (this.stream.getByte() << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.getByte()) >>> 0;
+              }
+              buffer = buffer << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.getByte();
+              var nextByte = this.stream.getByte();
+              this.buffer = nextByte & (1 << bufferLength) - 1;
+              return (buffer << 8 - bufferLength | (nextByte & 0xFF) >> bufferLength) >>> 0;
+            }
+            if (n === 8 && bufferLength === 0) {
+              return this.stream.getByte();
+            }
+            while (bufferLength < n) {
+              buffer = buffer << 8 | this.stream.getByte();
+              bufferLength += 8;
+            }
+            bufferLength -= n;
+            this.bufferLength = bufferLength;
+            this.buffer = buffer & (1 << bufferLength) - 1;
+            return buffer >> bufferLength;
+          },
+          align: function MeshStreamReader_align() {
+            this.buffer = 0;
+            this.bufferLength = 0;
+          },
+          readFlag: function MeshStreamReader_readFlag() {
+            return this.readBits(this.context.bitsPerFlag);
+          },
+          readCoordinate: function MeshStreamReader_readCoordinate() {
+            var bitsPerCoordinate = this.context.bitsPerCoordinate;
+            var xi = this.readBits(bitsPerCoordinate);
+            var yi = this.readBits(bitsPerCoordinate);
+            var decode = this.context.decode;
+            var scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) : 2.3283064365386963e-10;
+            // 2 ^ -32
+            return [
+              xi * scale * (decode[1] - decode[0]) + decode[0],
+              yi * scale * (decode[3] - decode[2]) + decode[2]
+            ];
+          },
+          readComponents: function MeshStreamReader_readComponents() {
+            var numComps = this.context.numComps;
+            var bitsPerComponent = this.context.bitsPerComponent;
+            var scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) : 2.3283064365386963e-10;
+            // 2 ^ -32
+            var decode = this.context.decode;
+            var components = this.tmpCompsBuf;
+            for (var i = 0, j = 4; i < numComps; i++, j += 2) {
+              var ci = this.readBits(bitsPerComponent);
+              components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j];
+            }
+            var color = this.tmpCsCompsBuf;
+            if (this.context.colorFn) {
+              this.context.colorFn(components, 0, color, 0);
+            }
+            return this.context.colorSpace.getRgb(color, 0);
+          }
+        };
+        function decodeType4Shading(mesh, reader) {
+          var coords = mesh.coords;
+          var colors = mesh.colors;
+          var operators = [];
+          var ps = [];
+          // not maintaining cs since that will match ps
+          var verticesLeft = 0;
+          // assuming we have all data to start a new triangle
+          while (reader.hasData) {
+            var f = reader.readFlag();
+            var coord = reader.readCoordinate();
+            var color = reader.readComponents();
+            if (verticesLeft === 0) {
+              // ignoring flags if we started a triangle
+              assert(0 <= f && f <= 2, 'Unknown type4 flag');
+              switch (f) {
+              case 0:
+                verticesLeft = 3;
+                break;
+              case 1:
+                ps.push(ps[ps.length - 2], ps[ps.length - 1]);
+                verticesLeft = 1;
+                break;
+              case 2:
+                ps.push(ps[ps.length - 3], ps[ps.length - 1]);
+                verticesLeft = 1;
+                break;
+              }
+              operators.push(f);
+            }
+            ps.push(coords.length);
+            coords.push(coord);
+            colors.push(color);
+            verticesLeft--;
+            reader.align();
+          }
+          mesh.figures.push({
+            type: 'triangles',
+            coords: new Int32Array(ps),
+            colors: new Int32Array(ps)
+          });
+        }
+        function decodeType5Shading(mesh, reader, verticesPerRow) {
+          var coords = mesh.coords;
+          var colors = mesh.colors;
+          var ps = [];
+          // not maintaining cs since that will match ps
+          while (reader.hasData) {
+            var coord = reader.readCoordinate();
+            var color = reader.readComponents();
+            ps.push(coords.length);
+            coords.push(coord);
+            colors.push(color);
+          }
+          mesh.figures.push({
+            type: 'lattice',
+            coords: new Int32Array(ps),
+            colors: new Int32Array(ps),
+            verticesPerRow: verticesPerRow
+          });
+        }
+        var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;
+        var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;
+        var TRIANGLE_DENSITY = 20;
+        // count of triangles per entire mesh bounds
+        var getB = function getBClosure() {
+          function buildB(count) {
+            var lut = [];
+            for (var i = 0; i <= count; i++) {
+              var t = i / count, t_ = 1 - t;
+              lut.push(new Float32Array([
+                t_ * t_ * t_,
+                3 * t * t_ * t_,
+                3 * t * t * t_,
+                t * t * t
+              ]));
+            }
+            return lut;
+          }
+          var cache = [];
+          return function getB(count) {
+            if (!cache[count]) {
+              cache[count] = buildB(count);
+            }
+            return cache[count];
+          };
+        }();
+        function buildFigureFromPatch(mesh, index) {
+          var figure = mesh.figures[index];
+          assert(figure.type === 'patch', 'Unexpected patch mesh figure');
+          var coords = mesh.coords, colors = mesh.colors;
+          var pi = figure.coords;
+          var ci = figure.colors;
+          var figureMinX = Math.min(coords[pi[0]][0], coords[pi[3]][0], coords[pi[12]][0], coords[pi[15]][0]);
+          var figureMinY = Math.min(coords[pi[0]][1], coords[pi[3]][1], coords[pi[12]][1], coords[pi[15]][1]);
+          var figureMaxX = Math.max(coords[pi[0]][0], coords[pi[3]][0], coords[pi[12]][0], coords[pi[15]][0]);
+          var figureMaxY = Math.max(coords[pi[0]][1], coords[pi[3]][1], coords[pi[12]][1], coords[pi[15]][1]);
+          var splitXBy = Math.ceil((figureMaxX - figureMinX) * TRIANGLE_DENSITY / (mesh.bounds[2] - mesh.bounds[0]));
+          splitXBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy));
+          var splitYBy = Math.ceil((figureMaxY - figureMinY) * TRIANGLE_DENSITY / (mesh.bounds[3] - mesh.bounds[1]));
+          splitYBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy));
+          var verticesPerRow = splitXBy + 1;
+          var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);
+          var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);
+          var k = 0;
+          var cl = new Uint8Array(3), cr = new Uint8Array(3);
+          var c0 = colors[ci[0]], c1 = colors[ci[1]], c2 = colors[ci[2]], c3 = colors[ci[3]];
+          var bRow = getB(splitYBy), bCol = getB(splitXBy);
+          for (var row = 0; row <= splitYBy; row++) {
+            cl[0] = (c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy | 0;
+            cl[1] = (c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy | 0;
+            cl[2] = (c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy | 0;
+            cr[0] = (c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy | 0;
+            cr[1] = (c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy | 0;
+            cr[2] = (c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy | 0;
+            for (var col = 0; col <= splitXBy; col++, k++) {
+              if ((row === 0 || row === splitYBy) && (col === 0 || col === splitXBy)) {
+                continue;
+              }
+              var x = 0, y = 0;
+              var q = 0;
+              for (var i = 0; i <= 3; i++) {
+                for (var j = 0; j <= 3; j++, q++) {
+                  var m = bRow[row][i] * bCol[col][j];
+                  x += coords[pi[q]][0] * m;
+                  y += coords[pi[q]][1] * m;
+                }
+              }
+              figureCoords[k] = coords.length;
+              coords.push([
+                x,
+                y
+              ]);
+              figureColors[k] = colors.length;
+              var newColor = new Uint8Array(3);
+              newColor[0] = (cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy | 0;
+              newColor[1] = (cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy | 0;
+              newColor[2] = (cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy | 0;
+              colors.push(newColor);
+            }
+          }
+          figureCoords[0] = pi[0];
+          figureColors[0] = ci[0];
+          figureCoords[splitXBy] = pi[3];
+          figureColors[splitXBy] = ci[1];
+          figureCoords[verticesPerRow * splitYBy] = pi[12];
+          figureColors[verticesPerRow * splitYBy] = ci[2];
+          figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];
+          figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];
+          mesh.figures[index] = {
+            type: 'lattice',
+            coords: figureCoords,
+            colors: figureColors,
+            verticesPerRow: verticesPerRow
+          };
+        }
+        function decodeType6Shading(mesh, reader) {
+          // A special case of Type 7. The p11, p12, p21, p22 automatically filled
+          var coords = mesh.coords;
+          var colors = mesh.colors;
+          var ps = new Int32Array(16);
+          // p00, p10, ..., p30, p01, ..., p33
+          var cs = new Int32Array(4);
+          // c00, c30, c03, c33
+          while (reader.hasData) {
+            var f = reader.readFlag();
+            assert(0 <= f && f <= 3, 'Unknown type6 flag');
+            var i, ii;
+            var pi = coords.length;
+            for (i = 0, ii = f !== 0 ? 8 : 12; i < ii; i++) {
+              coords.push(reader.readCoordinate());
+            }
+            var ci = colors.length;
+            for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+              colors.push(reader.readComponents());
+            }
+            var tmp1, tmp2, tmp3, tmp4;
+            switch (f) {
+            case 0:
+              ps[12] = pi + 3;
+              ps[13] = pi + 4;
+              ps[14] = pi + 5;
+              ps[15] = pi + 6;
+              ps[8] = pi + 2;
+              /* values for 5, 6, 9, 10 are    */
+              ps[11] = pi + 7;
+              ps[4] = pi + 1;
+              /* calculated below              */
+              ps[7] = pi + 8;
+              ps[0] = pi;
+              ps[1] = pi + 11;
+              ps[2] = pi + 10;
+              ps[3] = pi + 9;
+              cs[2] = ci + 1;
+              cs[3] = ci + 2;
+              cs[0] = ci;
+              cs[1] = ci + 3;
+              break;
+            case 1:
+              tmp1 = ps[12];
+              tmp2 = ps[13];
+              tmp3 = ps[14];
+              tmp4 = ps[15];
+              ps[12] = tmp4;
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = tmp3;
+              /* values for 5, 6, 9, 10 are    */
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              /* calculated below              */
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[2];
+              tmp2 = cs[3];
+              cs[2] = tmp2;
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            case 2:
+              tmp1 = ps[15];
+              tmp2 = ps[11];
+              ps[12] = ps[3];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[7];
+              /* values for 5, 6, 9, 10 are    */
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              /* calculated below              */
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[3];
+              cs[2] = cs[1];
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            case 3:
+              ps[12] = ps[0];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[1];
+              /* values for 5, 6, 9, 10 are    */
+              ps[11] = pi + 3;
+              ps[4] = ps[2];
+              /* calculated below              */
+              ps[7] = pi + 4;
+              ps[0] = ps[3];
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              cs[2] = cs[0];
+              cs[3] = ci;
+              cs[0] = cs[1];
+              cs[1] = ci + 1;
+              break;
+            }
+            // set p11, p12, p21, p22
+            ps[5] = coords.length;
+            coords.push([
+              (-4 * coords[ps[0]][0] - coords[ps[15]][0] + 6 * (coords[ps[4]][0] + coords[ps[1]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9,
+              (-4 * coords[ps[0]][1] - coords[ps[15]][1] + 6 * (coords[ps[4]][1] + coords[ps[1]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9
+            ]);
+            ps[6] = coords.length;
+            coords.push([
+              (-4 * coords[ps[3]][0] - coords[ps[12]][0] + 6 * (coords[ps[2]][0] + coords[ps[7]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9,
+              (-4 * coords[ps[3]][1] - coords[ps[12]][1] + 6 * (coords[ps[2]][1] + coords[ps[7]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9
+            ]);
+            ps[9] = coords.length;
+            coords.push([
+              (-4 * coords[ps[12]][0] - coords[ps[3]][0] + 6 * (coords[ps[8]][0] + coords[ps[13]][0]) - 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + 3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9,
+              (-4 * coords[ps[12]][1] - coords[ps[3]][1] + 6 * (coords[ps[8]][1] + coords[ps[13]][1]) - 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + 3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9
+            ]);
+            ps[10] = coords.length;
+            coords.push([
+              (-4 * coords[ps[15]][0] - coords[ps[0]][0] + 6 * (coords[ps[11]][0] + coords[ps[14]][0]) - 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + 3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9,
+              (-4 * coords[ps[15]][1] - coords[ps[0]][1] + 6 * (coords[ps[11]][1] + coords[ps[14]][1]) - 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + 3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9
+            ]);
+            mesh.figures.push({
+              type: 'patch',
+              coords: new Int32Array(ps),
+              // making copies of ps and cs
+              colors: new Int32Array(cs)
+            });
+          }
+        }
+        function decodeType7Shading(mesh, reader) {
+          var coords = mesh.coords;
+          var colors = mesh.colors;
+          var ps = new Int32Array(16);
+          // p00, p10, ..., p30, p01, ..., p33
+          var cs = new Int32Array(4);
+          // c00, c30, c03, c33
+          while (reader.hasData) {
+            var f = reader.readFlag();
+            assert(0 <= f && f <= 3, 'Unknown type7 flag');
+            var i, ii;
+            var pi = coords.length;
+            for (i = 0, ii = f !== 0 ? 12 : 16; i < ii; i++) {
+              coords.push(reader.readCoordinate());
+            }
+            var ci = colors.length;
+            for (i = 0, ii = f !== 0 ? 2 : 4; i < ii; i++) {
+              colors.push(reader.readComponents());
+            }
+            var tmp1, tmp2, tmp3, tmp4;
+            switch (f) {
+            case 0:
+              ps[12] = pi + 3;
+              ps[13] = pi + 4;
+              ps[14] = pi + 5;
+              ps[15] = pi + 6;
+              ps[8] = pi + 2;
+              ps[9] = pi + 13;
+              ps[10] = pi + 14;
+              ps[11] = pi + 7;
+              ps[4] = pi + 1;
+              ps[5] = pi + 12;
+              ps[6] = pi + 15;
+              ps[7] = pi + 8;
+              ps[0] = pi;
+              ps[1] = pi + 11;
+              ps[2] = pi + 10;
+              ps[3] = pi + 9;
+              cs[2] = ci + 1;
+              cs[3] = ci + 2;
+              cs[0] = ci;
+              cs[1] = ci + 3;
+              break;
+            case 1:
+              tmp1 = ps[12];
+              tmp2 = ps[13];
+              tmp3 = ps[14];
+              tmp4 = ps[15];
+              ps[12] = tmp4;
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = tmp3;
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[2];
+              tmp2 = cs[3];
+              cs[2] = tmp2;
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            case 2:
+              tmp1 = ps[15];
+              tmp2 = ps[11];
+              ps[12] = ps[3];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[7];
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = tmp2;
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = tmp1;
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              tmp1 = cs[3];
+              cs[2] = cs[1];
+              cs[3] = ci;
+              cs[0] = tmp1;
+              cs[1] = ci + 1;
+              break;
+            case 3:
+              ps[12] = ps[0];
+              ps[13] = pi + 0;
+              ps[14] = pi + 1;
+              ps[15] = pi + 2;
+              ps[8] = ps[1];
+              ps[9] = pi + 9;
+              ps[10] = pi + 10;
+              ps[11] = pi + 3;
+              ps[4] = ps[2];
+              ps[5] = pi + 8;
+              ps[6] = pi + 11;
+              ps[7] = pi + 4;
+              ps[0] = ps[3];
+              ps[1] = pi + 7;
+              ps[2] = pi + 6;
+              ps[3] = pi + 5;
+              cs[2] = cs[0];
+              cs[3] = ci;
+              cs[0] = cs[1];
+              cs[1] = ci + 1;
+              break;
+            }
+            mesh.figures.push({
+              type: 'patch',
+              coords: new Int32Array(ps),
+              // making copies of ps and cs
+              colors: new Int32Array(cs)
+            });
+          }
+        }
+        function updateBounds(mesh) {
+          var minX = mesh.coords[0][0], minY = mesh.coords[0][1], maxX = minX, maxY = minY;
+          for (var i = 1, ii = mesh.coords.length; i < ii; i++) {
+            var x = mesh.coords[i][0], y = mesh.coords[i][1];
+            minX = minX > x ? x : minX;
+            minY = minY > y ? y : minY;
+            maxX = maxX < x ? x : maxX;
+            maxY = maxY < y ? y : maxY;
+          }
+          mesh.bounds = [
+            minX,
+            minY,
+            maxX,
+            maxY
+          ];
+        }
+        function packData(mesh) {
+          var i, ii, j, jj;
+          var coords = mesh.coords;
+          var coordsPacked = new Float32Array(coords.length * 2);
+          for (i = 0, j = 0, ii = coords.length; i < ii; i++) {
+            var xy = coords[i];
+            coordsPacked[j++] = xy[0];
+            coordsPacked[j++] = xy[1];
+          }
+          mesh.coords = coordsPacked;
+          var colors = mesh.colors;
+          var colorsPacked = new Uint8Array(colors.length * 3);
+          for (i = 0, j = 0, ii = colors.length; i < ii; i++) {
+            var c = colors[i];
+            colorsPacked[j++] = c[0];
+            colorsPacked[j++] = c[1];
+            colorsPacked[j++] = c[2];
+          }
+          mesh.colors = colorsPacked;
+          var figures = mesh.figures;
+          for (i = 0, ii = figures.length; i < ii; i++) {
+            var figure = figures[i], ps = figure.coords, cs = figure.colors;
+            for (j = 0, jj = ps.length; j < jj; j++) {
+              ps[j] *= 2;
+              cs[j] *= 3;
+            }
+          }
+        }
+        function Mesh(stream, matrix, xref, res) {
+          assert(isStream(stream), 'Mesh data is not a stream');
+          var dict = stream.dict;
+          this.matrix = matrix;
+          this.shadingType = dict.get('ShadingType');
+          this.type = 'Pattern';
+          this.bbox = dict.getArray('BBox');
+          var cs = dict.get('ColorSpace', 'CS');
+          cs = ColorSpace.parse(cs, xref, res);
+          this.cs = cs;
+          this.background = dict.has('Background') ? cs.getRgb(dict.get('Background'), 0) : null;
+          var fnObj = dict.get('Function');
+          var fn = fnObj ? PDFFunction.parseArray(xref, fnObj) : null;
+          this.coords = [];
+          this.colors = [];
+          this.figures = [];
+          var decodeContext = {
+            bitsPerCoordinate: dict.get('BitsPerCoordinate'),
+            bitsPerComponent: dict.get('BitsPerComponent'),
+            bitsPerFlag: dict.get('BitsPerFlag'),
+            decode: dict.getArray('Decode'),
+            colorFn: fn,
+            colorSpace: cs,
+            numComps: fn ? 1 : cs.numComps
+          };
+          var reader = new MeshStreamReader(stream, decodeContext);
+          var patchMesh = false;
+          switch (this.shadingType) {
+          case ShadingType.FREE_FORM_MESH:
+            decodeType4Shading(this, reader);
+            break;
+          case ShadingType.LATTICE_FORM_MESH:
+            var verticesPerRow = dict.get('VerticesPerRow') | 0;
+            assert(verticesPerRow >= 2, 'Invalid VerticesPerRow');
+            decodeType5Shading(this, reader, verticesPerRow);
+            break;
+          case ShadingType.COONS_PATCH_MESH:
+            decodeType6Shading(this, reader);
+            patchMesh = true;
+            break;
+          case ShadingType.TENSOR_PATCH_MESH:
+            decodeType7Shading(this, reader);
+            patchMesh = true;
+            break;
+          default:
+            error('Unsupported mesh type.');
+            break;
+          }
+          if (patchMesh) {
+            // dirty bounds calculation for determining, how dense shall be triangles
+            updateBounds(this);
+            for (var i = 0, ii = this.figures.length; i < ii; i++) {
+              buildFigureFromPatch(this, i);
+            }
+          }
+          // calculate bounds
+          updateBounds(this);
+          packData(this);
+        }
+        Mesh.prototype = {
+          getIR: function Mesh_getIR() {
+            return [
+              'Mesh',
+              this.shadingType,
+              this.coords,
+              this.colors,
+              this.figures,
+              this.bounds,
+              this.matrix,
+              this.bbox,
+              this.background
+            ];
+          }
+        };
+        return Mesh;
+      }();
+      Shadings.Dummy = function DummyClosure() {
+        function Dummy() {
+          this.type = 'Pattern';
+        }
+        Dummy.prototype = {
+          getIR: function Dummy_getIR() {
+            return ['Dummy'];
+          }
+        };
+        return Dummy;
+      }();
+      function getTilingPatternIR(operatorList, dict, args) {
+        var matrix = dict.getArray('Matrix');
+        var bbox = dict.getArray('BBox');
+        var xstep = dict.get('XStep');
+        var ystep = dict.get('YStep');
+        var paintType = dict.get('PaintType');
+        var tilingType = dict.get('TilingType');
+        return [
+          'TilingPattern',
+          args,
+          operatorList,
+          matrix,
+          bbox,
+          xstep,
+          ystep,
+          paintType,
+          tilingType
+        ];
+      }
+      exports.Pattern = Pattern;
+      exports.getTilingPatternIR = getTilingPatternIR;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreEvaluator = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreParser, root.pdfjsCoreImage, root.pdfjsCoreColorSpace, root.pdfjsCoreMurmurHash3, root.pdfjsCoreFonts, root.pdfjsCoreFunction, root.pdfjsCorePattern, root.pdfjsCoreCMap, root.pdfjsCoreMetrics, root.pdfjsCoreBidi, root.pdfjsCoreEncodings, root.pdfjsCoreStandardFonts, root.pdfjsCoreUnicode, root.pdfjsCoreGlyphList);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream, coreParser, coreImage, coreColorSpace, coreMurmurHash3, coreFonts, coreFunction, corePattern, coreCMap, coreMetrics, coreBidi, coreEncodings, coreStandardFonts, coreUnicode, coreGlyphList) {
+      var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX;
+      var IDENTITY_MATRIX = sharedUtil.IDENTITY_MATRIX;
+      var UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES;
+      var ImageKind = sharedUtil.ImageKind;
+      var OPS = sharedUtil.OPS;
+      var TextRenderingMode = sharedUtil.TextRenderingMode;
+      var Util = sharedUtil.Util;
+      var assert = sharedUtil.assert;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isNum = sharedUtil.isNum;
+      var isString = sharedUtil.isString;
+      var getLookupTableFactory = sharedUtil.getLookupTableFactory;
+      var warn = sharedUtil.warn;
+      var Dict = corePrimitives.Dict;
+      var Name = corePrimitives.Name;
+      var isCmd = corePrimitives.isCmd;
+      var isDict = corePrimitives.isDict;
+      var isName = corePrimitives.isName;
+      var isRef = corePrimitives.isRef;
+      var isStream = corePrimitives.isStream;
+      var DecodeStream = coreStream.DecodeStream;
+      var JpegStream = coreStream.JpegStream;
+      var Stream = coreStream.Stream;
+      var Lexer = coreParser.Lexer;
+      var Parser = coreParser.Parser;
+      var isEOF = coreParser.isEOF;
+      var PDFImage = coreImage.PDFImage;
+      var ColorSpace = coreColorSpace.ColorSpace;
+      var MurmurHash3_64 = coreMurmurHash3.MurmurHash3_64;
+      var ErrorFont = coreFonts.ErrorFont;
+      var FontFlags = coreFonts.FontFlags;
+      var Font = coreFonts.Font;
+      var IdentityToUnicodeMap = coreFonts.IdentityToUnicodeMap;
+      var ToUnicodeMap = coreFonts.ToUnicodeMap;
+      var getFontType = coreFonts.getFontType;
+      var isPDFFunction = coreFunction.isPDFFunction;
+      var PDFFunction = coreFunction.PDFFunction;
+      var Pattern = corePattern.Pattern;
+      var getTilingPatternIR = corePattern.getTilingPatternIR;
+      var CMapFactory = coreCMap.CMapFactory;
+      var IdentityCMap = coreCMap.IdentityCMap;
+      var getMetrics = coreMetrics.getMetrics;
+      var bidi = coreBidi.bidi;
+      var WinAnsiEncoding = coreEncodings.WinAnsiEncoding;
+      var StandardEncoding = coreEncodings.StandardEncoding;
+      var MacRomanEncoding = coreEncodings.MacRomanEncoding;
+      var SymbolSetEncoding = coreEncodings.SymbolSetEncoding;
+      var ZapfDingbatsEncoding = coreEncodings.ZapfDingbatsEncoding;
+      var getEncoding = coreEncodings.getEncoding;
+      var getStdFontMap = coreStandardFonts.getStdFontMap;
+      var getSerifFonts = coreStandardFonts.getSerifFonts;
+      var getSymbolsFonts = coreStandardFonts.getSymbolsFonts;
+      var getNormalizedUnicodes = coreUnicode.getNormalizedUnicodes;
+      var reverseIfRtl = coreUnicode.reverseIfRtl;
+      var getUnicodeForGlyph = coreUnicode.getUnicodeForGlyph;
+      var getGlyphsUnicode = coreGlyphList.getGlyphsUnicode;
+      var PartialEvaluator = function PartialEvaluatorClosure() {
+        var DefaultPartialEvaluatorOptions = {
+          forceDataSchema: false,
+          maxImageSize: -1,
+          disableFontFace: false,
+          cMapOptions: {
+            url: null,
+            packed: false
+          }
+        };
+        function NativeImageDecoder(xref, resources, handler, forceDataSchema) {
+          this.xref = xref;
+          this.resources = resources;
+          this.handler = handler;
+          this.forceDataSchema = forceDataSchema;
+        }
+        NativeImageDecoder.prototype = {
+          canDecode: function (image) {
+            return image instanceof JpegStream && NativeImageDecoder.isDecodable(image, this.xref, this.resources);
+          },
+          decode: function (image) {
+            // For natively supported JPEGs send them to the main thread for decoding.
+            var dict = image.dict;
+            var colorSpace = dict.get('ColorSpace', 'CS');
+            colorSpace = ColorSpace.parse(colorSpace, this.xref, this.resources);
+            var numComps = colorSpace.numComps;
+            var decodePromise = this.handler.sendWithPromise('JpegDecode', [
+              image.getIR(this.forceDataSchema),
+              numComps
+            ]);
+            return decodePromise.then(function (message) {
+              var data = message.data;
+              return new Stream(data, 0, data.length, image.dict);
+            });
+          }
+        };
+        /**
+         * Checks if the image can be decoded and displayed by the browser without any
+         * further processing such as color space conversions.
+         */
+        NativeImageDecoder.isSupported = function NativeImageDecoder_isSupported(image, xref, res) {
+          var dict = image.dict;
+          if (dict.has('DecodeParms') || dict.has('DP')) {
+            return false;
+          }
+          var cs = ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res);
+          return (cs.name === 'DeviceGray' || cs.name === 'DeviceRGB') && cs.isDefaultDecode(dict.getArray('Decode', 'D'));
+        };
+        /**
+         * Checks if the image can be decoded by the browser.
+         */
+        NativeImageDecoder.isDecodable = function NativeImageDecoder_isDecodable(image, xref, res) {
+          var dict = image.dict;
+          if (dict.has('DecodeParms') || dict.has('DP')) {
+            return false;
+          }
+          var cs = ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res);
+          return (cs.numComps === 1 || cs.numComps === 3) && cs.isDefaultDecode(dict.getArray('Decode', 'D'));
+        };
+        function PartialEvaluator(pdfManager, xref, handler, pageIndex, uniquePrefix, idCounters, fontCache, options) {
+          this.pdfManager = pdfManager;
+          this.xref = xref;
+          this.handler = handler;
+          this.pageIndex = pageIndex;
+          this.uniquePrefix = uniquePrefix;
+          this.idCounters = idCounters;
+          this.fontCache = fontCache;
+          this.options = options || DefaultPartialEvaluatorOptions;
+        }
+        // Trying to minimize Date.now() usage and check every 100 time
+        var TIME_SLOT_DURATION_MS = 20;
+        var CHECK_TIME_EVERY = 100;
+        function TimeSlotManager() {
+          this.reset();
+        }
+        TimeSlotManager.prototype = {
+          check: function TimeSlotManager_check() {
+            if (++this.checked < CHECK_TIME_EVERY) {
+              return false;
+            }
+            this.checked = 0;
+            return this.endTime <= Date.now();
+          },
+          reset: function TimeSlotManager_reset() {
+            this.endTime = Date.now() + TIME_SLOT_DURATION_MS;
+            this.checked = 0;
+          }
+        };
+        var deferred = Promise.resolve();
+        var TILING_PATTERN = 1, SHADING_PATTERN = 2;
+        PartialEvaluator.prototype = {
+          hasBlendModes: function PartialEvaluator_hasBlendModes(resources) {
+            if (!isDict(resources)) {
+              return false;
+            }
+            var processed = Object.create(null);
+            if (resources.objId) {
+              processed[resources.objId] = true;
+            }
+            var nodes = [resources], xref = this.xref;
+            while (nodes.length) {
+              var key, i, ii;
+              var node = nodes.shift();
+              // First check the current resources for blend modes.
+              var graphicStates = node.get('ExtGState');
+              if (isDict(graphicStates)) {
+                var graphicStatesKeys = graphicStates.getKeys();
+                for (i = 0, ii = graphicStatesKeys.length; i < ii; i++) {
+                  key = graphicStatesKeys[i];
+                  var graphicState = graphicStates.get(key);
+                  var bm = graphicState.get('BM');
+                  if (isName(bm) && bm.name !== 'Normal') {
+                    return true;
+                  }
+                }
+              }
+              // Descend into the XObjects to look for more resources and blend modes.
+              var xObjects = node.get('XObject');
+              if (!isDict(xObjects)) {
+                continue;
+              }
+              var xObjectsKeys = xObjects.getKeys();
+              for (i = 0, ii = xObjectsKeys.length; i < ii; i++) {
+                key = xObjectsKeys[i];
+                var xObject = xObjects.getRaw(key);
+                if (isRef(xObject)) {
+                  if (processed[xObject.toString()]) {
+                    // The XObject has already been processed, and by avoiding a
+                    // redundant `xref.fetch` we can *significantly* reduce the load
+                    // time for badly generated PDF files (fixes issue6961.pdf).
+                    continue;
+                  }
+                  xObject = xref.fetch(xObject);
+                }
+                if (!isStream(xObject)) {
+                  continue;
+                }
+                if (xObject.dict.objId) {
+                  if (processed[xObject.dict.objId]) {
+                    // stream has objId and is processed already
+                    continue;
+                  }
+                  processed[xObject.dict.objId] = true;
+                }
+                var xResources = xObject.dict.get('Resources');
+                // Checking objId to detect an infinite loop.
+                if (isDict(xResources) && (!xResources.objId || !processed[xResources.objId])) {
+                  nodes.push(xResources);
+                  if (xResources.objId) {
+                    processed[xResources.objId] = true;
+                  }
+                }
+              }
+            }
+            return false;
+          },
+          buildFormXObject: function PartialEvaluator_buildFormXObject(resources, xobj, smask, operatorList, task, initialState) {
+            var matrix = xobj.dict.getArray('Matrix');
+            var bbox = xobj.dict.getArray('BBox');
+            var group = xobj.dict.get('Group');
+            if (group) {
+              var groupOptions = {
+                matrix: matrix,
+                bbox: bbox,
+                smask: smask,
+                isolated: false,
+                knockout: false
+              };
+              var groupSubtype = group.get('S');
+              var colorSpace;
+              if (isName(groupSubtype, 'Transparency')) {
+                groupOptions.isolated = group.get('I') || false;
+                groupOptions.knockout = group.get('K') || false;
+                colorSpace = group.has('CS') ? ColorSpace.parse(group.get('CS'), this.xref, resources) : null;
+              }
+              if (smask && smask.backdrop) {
+                colorSpace = colorSpace || ColorSpace.singletons.rgb;
+                smask.backdrop = colorSpace.getRgb(smask.backdrop, 0);
+              }
+              operatorList.addOp(OPS.beginGroup, [groupOptions]);
+            }
+            operatorList.addOp(OPS.paintFormXObjectBegin, [
+              matrix,
+              bbox
+            ]);
+            return this.getOperatorList(xobj, task, xobj.dict.get('Resources') || resources, operatorList, initialState).then(function () {
+              operatorList.addOp(OPS.paintFormXObjectEnd, []);
+              if (group) {
+                operatorList.addOp(OPS.endGroup, [groupOptions]);
+              }
+            });
+          },
+          buildPaintImageXObject: function PartialEvaluator_buildPaintImageXObject(resources, image, inline, operatorList, cacheKey, imageCache) {
+            var self = this;
+            var dict = image.dict;
+            var w = dict.get('Width', 'W');
+            var h = dict.get('Height', 'H');
+            if (!(w && isNum(w)) || !(h && isNum(h))) {
+              warn('Image dimensions are missing, or not numbers.');
+              return;
+            }
+            var maxImageSize = this.options.maxImageSize;
+            if (maxImageSize !== -1 && w * h > maxImageSize) {
+              warn('Image exceeded maximum allowed size and was removed.');
+              return;
+            }
+            var imageMask = dict.get('ImageMask', 'IM') || false;
+            var imgData, args;
+            if (imageMask) {
+              // This depends on a tmpCanvas being filled with the
+              // current fillStyle, such that processing the pixel
+              // data can't be done here. Instead of creating a
+              // complete PDFImage, only read the information needed
+              // for later.
+              var width = dict.get('Width', 'W');
+              var height = dict.get('Height', 'H');
+              var bitStrideLength = width + 7 >> 3;
+              var imgArray = image.getBytes(bitStrideLength * height);
+              var decode = dict.getArray('Decode', 'D');
+              var inverseDecode = !!decode && decode[0] > 0;
+              imgData = PDFImage.createMask(imgArray, width, height, image instanceof DecodeStream, inverseDecode);
+              imgData.cached = true;
+              args = [imgData];
+              operatorList.addOp(OPS.paintImageMaskXObject, args);
+              if (cacheKey) {
+                imageCache[cacheKey] = {
+                  fn: OPS.paintImageMaskXObject,
+                  args: args
+                };
+              }
+              return;
+            }
+            var softMask = dict.get('SMask', 'SM') || false;
+            var mask = dict.get('Mask') || false;
+            var SMALL_IMAGE_DIMENSIONS = 200;
+            // Inlining small images into the queue as RGB data
+            if (inline && !softMask && !mask && !(image instanceof JpegStream) && w + h < SMALL_IMAGE_DIMENSIONS) {
+              var imageObj = new PDFImage(this.xref, resources, image, inline, null, null);
+              // We force the use of RGBA_32BPP images here, because we can't handle
+              // any other kind.
+              imgData = imageObj.createImageData(/* forceRGBA = */
+              true);
+              operatorList.addOp(OPS.paintInlineImageXObject, [imgData]);
+              return;
+            }
+            // If there is no imageMask, create the PDFImage and a lot
+            // of image processing can be done here.
+            var uniquePrefix = this.uniquePrefix || '';
+            var objId = 'img_' + uniquePrefix + ++this.idCounters.obj;
+            operatorList.addDependency(objId);
+            args = [
+              objId,
+              w,
+              h
+            ];
+            if (!softMask && !mask && image instanceof JpegStream && NativeImageDecoder.isSupported(image, this.xref, resources)) {
+              // These JPEGs don't need any more processing so we can just send it.
+              operatorList.addOp(OPS.paintJpegXObject, args);
+              this.handler.send('obj', [
+                objId,
+                this.pageIndex,
+                'JpegStream',
+                image.getIR(this.options.forceDataSchema)
+              ]);
+              return;
+            }
+            // Creates native image decoder only if a JPEG image or mask is present.
+            var nativeImageDecoder = null;
+            if (image instanceof JpegStream || mask instanceof JpegStream || softMask instanceof JpegStream) {
+              nativeImageDecoder = new NativeImageDecoder(self.xref, resources, self.handler, self.options.forceDataSchema);
+            }
+            PDFImage.buildImage(self.handler, self.xref, resources, image, inline, nativeImageDecoder).then(function (imageObj) {
+              var imgData = imageObj.createImageData(/* forceRGBA = */
+              false);
+              self.handler.send('obj', [
+                objId,
+                self.pageIndex,
+                'Image',
+                imgData
+              ], [imgData.data.buffer]);
+            }).then(undefined, function (reason) {
+              warn('Unable to decode image: ' + reason);
+              self.handler.send('obj', [
+                objId,
+                self.pageIndex,
+                'Image',
+                null
+              ]);
+            });
+            operatorList.addOp(OPS.paintImageXObject, args);
+            if (cacheKey) {
+              imageCache[cacheKey] = {
+                fn: OPS.paintImageXObject,
+                args: args
+              };
+            }
+          },
+          handleSMask: function PartialEvaluator_handleSmask(smask, resources, operatorList, task, stateManager) {
+            var smaskContent = smask.get('G');
+            var smaskOptions = {
+              subtype: smask.get('S').name,
+              backdrop: smask.get('BC')
+            };
+            // The SMask might have a alpha/luminosity value transfer function --
+            // we will build a map of integer values in range 0..255 to be fast.
+            var transferObj = smask.get('TR');
+            if (isPDFFunction(transferObj)) {
+              var transferFn = PDFFunction.parse(this.xref, transferObj);
+              var transferMap = new Uint8Array(256);
+              var tmp = new Float32Array(1);
+              for (var i = 0; i < 256; i++) {
+                tmp[0] = i / 255;
+                transferFn(tmp, 0, tmp, 0);
+                transferMap[i] = tmp[0] * 255 | 0;
+              }
+              smaskOptions.transferMap = transferMap;
+            }
+            return this.buildFormXObject(resources, smaskContent, smaskOptions, operatorList, task, stateManager.state.clone());
+          },
+          handleTilingType: function PartialEvaluator_handleTilingType(fn, args, resources, pattern, patternDict, operatorList, task) {
+            // Create an IR of the pattern code.
+            var tilingOpList = new OperatorList();
+            // Merge the available resources, to prevent issues when the patternDict
+            // is missing some /Resources entries (fixes issue6541.pdf).
+            var resourcesArray = [
+              patternDict.get('Resources'),
+              resources
+            ];
+            var patternResources = Dict.merge(this.xref, resourcesArray);
+            return this.getOperatorList(pattern, task, patternResources, tilingOpList).then(function () {
+              // Add the dependencies to the parent operator list so they are
+              // resolved before sub operator list is executed synchronously.
+              operatorList.addDependencies(tilingOpList.dependencies);
+              operatorList.addOp(fn, getTilingPatternIR({
+                fnArray: tilingOpList.fnArray,
+                argsArray: tilingOpList.argsArray
+              }, patternDict, args));
+            });
+          },
+          handleSetFont: function PartialEvaluator_handleSetFont(resources, fontArgs, fontRef, operatorList, task, state) {
+            // TODO(mack): Not needed?
+            var fontName;
+            if (fontArgs) {
+              fontArgs = fontArgs.slice();
+              fontName = fontArgs[0].name;
+            }
+            var self = this;
+            return this.loadFont(fontName, fontRef, this.xref, resources).then(function (translated) {
+              if (!translated.font.isType3Font) {
+                return translated;
+              }
+              return translated.loadType3Data(self, resources, operatorList, task).then(function () {
+                return translated;
+              }, function (reason) {
+                // Error in the font data -- sending unsupported feature notification.
+                self.handler.send('UnsupportedFeature', { featureId: UNSUPPORTED_FEATURES.font });
+                return new TranslatedFont('g_font_error', new ErrorFont('Type3 font load error: ' + reason), translated.font);
+              });
+            }).then(function (translated) {
+              state.font = translated.font;
+              translated.send(self.handler);
+              return translated.loadedName;
+            });
+          },
+          handleText: function PartialEvaluator_handleText(chars, state) {
+            var font = state.font;
+            var glyphs = font.charsToGlyphs(chars);
+            var isAddToPathSet = !!(state.textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG);
+            if (font.data && (isAddToPathSet || this.options.disableFontFace)) {
+              var buildPath = function (fontChar) {
+                if (!font.renderer.hasBuiltPath(fontChar)) {
+                  var path = font.renderer.getPathJs(fontChar);
+                  this.handler.send('commonobj', [
+                    font.loadedName + '_path_' + fontChar,
+                    'FontPath',
+                    path
+                  ]);
+                }
+              }.bind(this);
+              for (var i = 0, ii = glyphs.length; i < ii; i++) {
+                var glyph = glyphs[i];
+                buildPath(glyph.fontChar);
+                // If the glyph has an accent we need to build a path for its
+                // fontChar too, otherwise CanvasGraphics_paintChar will fail.
+                var accent = glyph.accent;
+                if (accent && accent.fontChar) {
+                  buildPath(accent.fontChar);
+                }
+              }
+            }
+            return glyphs;
+          },
+          setGState: function PartialEvaluator_setGState(resources, gState, operatorList, task, xref, stateManager) {
+            // This array holds the converted/processed state data.
+            var gStateObj = [];
+            var gStateKeys = gState.getKeys();
+            var self = this;
+            var promise = Promise.resolve();
+            for (var i = 0, ii = gStateKeys.length; i < ii; i++) {
+              var key = gStateKeys[i];
+              var value = gState.get(key);
+              switch (key) {
+              case 'Type':
+                break;
+              case 'LW':
+              case 'LC':
+              case 'LJ':
+              case 'ML':
+              case 'D':
+              case 'RI':
+              case 'FL':
+              case 'CA':
+              case 'ca':
+                gStateObj.push([
+                  key,
+                  value
+                ]);
+                break;
+              case 'Font':
+                promise = promise.then(function () {
+                  return self.handleSetFont(resources, null, value[0], operatorList, task, stateManager.state).then(function (loadedName) {
+                    operatorList.addDependency(loadedName);
+                    gStateObj.push([
+                      key,
+                      [
+                        loadedName,
+                        value[1]
+                      ]
+                    ]);
+                  });
+                });
+                break;
+              case 'BM':
+                gStateObj.push([
+                  key,
+                  value
+                ]);
+                break;
+              case 'SMask':
+                if (isName(value, 'None')) {
+                  gStateObj.push([
+                    key,
+                    false
+                  ]);
+                  break;
+                }
+                if (isDict(value)) {
+                  promise = promise.then(function (dict) {
+                    return self.handleSMask(dict, resources, operatorList, task, stateManager);
+                  }.bind(this, value));
+                  gStateObj.push([
+                    key,
+                    true
+                  ]);
+                } else {
+                  warn('Unsupported SMask type');
+                }
+                break;
+              // Only generate info log messages for the following since
+              // they are unlikely to have a big impact on the rendering.
+              case 'OP':
+              case 'op':
+              case 'OPM':
+              case 'BG':
+              case 'BG2':
+              case 'UCR':
+              case 'UCR2':
+              case 'TR':
+              case 'TR2':
+              case 'HT':
+              case 'SM':
+              case 'SA':
+              case 'AIS':
+              case 'TK':
+                // TODO implement these operators.
+                info('graphic state operator ' + key);
+                break;
+              default:
+                info('Unknown graphic state operator ' + key);
+                break;
+              }
+            }
+            return promise.then(function () {
+              if (gStateObj.length > 0) {
+                operatorList.addOp(OPS.setGState, [gStateObj]);
+              }
+            });
+          },
+          loadFont: function PartialEvaluator_loadFont(fontName, font, xref, resources) {
+            function errorFont() {
+              return Promise.resolve(new TranslatedFont('g_font_error', new ErrorFont('Font ' + fontName + ' is not available'), font));
+            }
+            var fontRef;
+            if (font) {
+              // Loading by ref.
+              assert(isRef(font));
+              fontRef = font;
+            } else {
+              // Loading by name.
+              var fontRes = resources.get('Font');
+              if (fontRes) {
+                fontRef = fontRes.getRaw(fontName);
+              } else {
+                warn('fontRes not available');
+                return errorFont();
+              }
+            }
+            if (!fontRef) {
+              warn('fontRef not available');
+              return errorFont();
+            }
+            if (this.fontCache.has(fontRef)) {
+              return this.fontCache.get(fontRef);
+            }
+            font = xref.fetchIfRef(fontRef);
+            if (!isDict(font)) {
+              return errorFont();
+            }
+            // We are holding `font.translated` references just for `fontRef`s that
+            // are not actually `Ref`s, but rather `Dict`s. See explanation below.
+            if (font.translated) {
+              return font.translated;
+            }
+            var fontCapability = createPromiseCapability();
+            var preEvaluatedFont = this.preEvaluateFont(font, xref);
+            var descriptor = preEvaluatedFont.descriptor;
+            var fontRefIsRef = isRef(fontRef), fontID;
+            if (fontRefIsRef) {
+              fontID = fontRef.toString();
+            }
+            if (isDict(descriptor)) {
+              if (!descriptor.fontAliases) {
+                descriptor.fontAliases = Object.create(null);
+              }
+              var fontAliases = descriptor.fontAliases;
+              var hash = preEvaluatedFont.hash;
+              if (fontAliases[hash]) {
+                var aliasFontRef = fontAliases[hash].aliasRef;
+                if (fontRefIsRef && aliasFontRef && this.fontCache.has(aliasFontRef)) {
+                  this.fontCache.putAlias(fontRef, aliasFontRef);
+                  return this.fontCache.get(fontRef);
+                }
+              } else {
+                fontAliases[hash] = { fontID: Font.getFontID() };
+              }
+              if (fontRefIsRef) {
+                fontAliases[hash].aliasRef = fontRef;
+              }
+              fontID = fontAliases[hash].fontID;
+            }
+            // Workaround for bad PDF generators that reference fonts incorrectly,
+            // where `fontRef` is a `Dict` rather than a `Ref` (fixes bug946506.pdf).
+            // In this case we should not put the font into `this.fontCache` (which is
+            // a `RefSetCache`), since it's not meaningful to use a `Dict` as a key.
+            //
+            // However, if we don't cache the font it's not possible to remove it
+            // when `cleanup` is triggered from the API, which causes issues on
+            // subsequent rendering operations (see issue7403.pdf).
+            // A simple workaround would be to just not hold `font.translated`
+            // references in this case, but this would force us to unnecessarily load
+            // the same fonts over and over.
+            //
+            // Instead, we cheat a bit by attempting to use a modified `fontID` as a
+            // key in `this.fontCache`, to allow the font to be cached.
+            // NOTE: This works because `RefSetCache` calls `toString()` on provided
+            //       keys. Also, since `fontRef` is used when getting cached fonts,
+            //       we'll not accidentally match fonts cached with the `fontID`.
+            if (fontRefIsRef) {
+              this.fontCache.put(fontRef, fontCapability.promise);
+            } else {
+              if (!fontID) {
+                fontID = (this.uniquePrefix || 'F_') + ++this.idCounters.obj;
+              }
+              this.fontCache.put('id_' + fontID, fontCapability.promise);
+            }
+            assert(fontID, 'The "fontID" must be defined.');
+            // Keep track of each font we translated so the caller can
+            // load them asynchronously before calling display on a page.
+            font.loadedName = 'g_' + this.pdfManager.docId + '_f' + fontID;
+            font.translated = fontCapability.promise;
+            // TODO move promises into translate font
+            var translatedPromise;
+            try {
+              translatedPromise = this.translateFont(preEvaluatedFont, xref);
+            } catch (e) {
+              translatedPromise = Promise.reject(e);
+            }
+            var self = this;
+            translatedPromise.then(function (translatedFont) {
+              if (translatedFont.fontType !== undefined) {
+                var xrefFontStats = xref.stats.fontTypes;
+                xrefFontStats[translatedFont.fontType] = true;
+              }
+              fontCapability.resolve(new TranslatedFont(font.loadedName, translatedFont, font));
+            }, function (reason) {
+              // TODO fontCapability.reject?
+              // Error in the font data -- sending unsupported feature notification.
+              self.handler.send('UnsupportedFeature', { featureId: UNSUPPORTED_FEATURES.font });
+              try {
+                // error, but it's still nice to have font type reported
+                var descriptor = preEvaluatedFont.descriptor;
+                var fontFile3 = descriptor && descriptor.get('FontFile3');
+                var subtype = fontFile3 && fontFile3.get('Subtype');
+                var fontType = getFontType(preEvaluatedFont.type, subtype && subtype.name);
+                var xrefFontStats = xref.stats.fontTypes;
+                xrefFontStats[fontType] = true;
+              } catch (ex) {
+              }
+              fontCapability.resolve(new TranslatedFont(font.loadedName, new ErrorFont(reason instanceof Error ? reason.message : reason), font));
+            });
+            return fontCapability.promise;
+          },
+          buildPath: function PartialEvaluator_buildPath(operatorList, fn, args) {
+            var lastIndex = operatorList.length - 1;
+            if (!args) {
+              args = [];
+            }
+            if (lastIndex < 0 || operatorList.fnArray[lastIndex] !== OPS.constructPath) {
+              operatorList.addOp(OPS.constructPath, [
+                [fn],
+                args
+              ]);
+            } else {
+              var opArgs = operatorList.argsArray[lastIndex];
+              opArgs[0].push(fn);
+              Array.prototype.push.apply(opArgs[1], args);
+            }
+          },
+          handleColorN: function PartialEvaluator_handleColorN(operatorList, fn, args, cs, patterns, resources, task, xref) {
+            // compile tiling patterns
+            var patternName = args[args.length - 1];
+            // SCN/scn applies patterns along with normal colors
+            var pattern;
+            if (isName(patternName) && (pattern = patterns.get(patternName.name))) {
+              var dict = isStream(pattern) ? pattern.dict : pattern;
+              var typeNum = dict.get('PatternType');
+              if (typeNum === TILING_PATTERN) {
+                var color = cs.base ? cs.base.getRgb(args, 0) : null;
+                return this.handleTilingType(fn, color, resources, pattern, dict, operatorList, task);
+              } else if (typeNum === SHADING_PATTERN) {
+                var shading = dict.get('Shading');
+                var matrix = dict.getArray('Matrix');
+                pattern = Pattern.parseShading(shading, matrix, xref, resources, this.handler);
+                operatorList.addOp(fn, pattern.getIR());
+                return Promise.resolve();
+              } else {
+                return Promise.reject('Unknown PatternType: ' + typeNum);
+              }
+            }
+            // TODO shall we fail here?
+            operatorList.addOp(fn, args);
+            return Promise.resolve();
+          },
+          getOperatorList: function PartialEvaluator_getOperatorList(stream, task, resources, operatorList, initialState) {
+            var self = this;
+            var xref = this.xref;
+            var imageCache = Object.create(null);
+            assert(operatorList);
+            resources = resources || Dict.empty;
+            var xobjs = resources.get('XObject') || Dict.empty;
+            var patterns = resources.get('Pattern') || Dict.empty;
+            var stateManager = new StateManager(initialState || new EvalState());
+            var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
+            var timeSlotManager = new TimeSlotManager();
+            return new Promise(function promiseBody(resolve, reject) {
+              var next = function (promise) {
+                promise.then(function () {
+                  try {
+                    promiseBody(resolve, reject);
+                  } catch (ex) {
+                    reject(ex);
+                  }
+                }, reject);
+              };
+              task.ensureNotTerminated();
+              timeSlotManager.reset();
+              var stop, operation = {}, i, ii, cs;
+              while (!(stop = timeSlotManager.check())) {
+                // The arguments parsed by read() are used beyond this loop, so we
+                // cannot reuse the same array on each iteration. Therefore we pass
+                // in |null| as the initial value (see the comment on
+                // EvaluatorPreprocessor_read() for why).
+                operation.args = null;
+                if (!preprocessor.read(operation)) {
+                  break;
+                }
+                var args = operation.args;
+                var fn = operation.fn;
+                switch (fn | 0) {
+                case OPS.paintXObject:
+                  if (args[0].code) {
+                    break;
+                  }
+                  // eagerly compile XForm objects
+                  var name = args[0].name;
+                  if (!name) {
+                    warn('XObject must be referred to by name.');
+                    continue;
+                  }
+                  if (imageCache[name] !== undefined) {
+                    operatorList.addOp(imageCache[name].fn, imageCache[name].args);
+                    args = null;
+                    continue;
+                  }
+                  var xobj = xobjs.get(name);
+                  if (xobj) {
+                    assert(isStream(xobj), 'XObject should be a stream');
+                    var type = xobj.dict.get('Subtype');
+                    assert(isName(type), 'XObject should have a Name subtype');
+                    if (type.name === 'Form') {
+                      stateManager.save();
+                      next(self.buildFormXObject(resources, xobj, null, operatorList, task, stateManager.state.clone()).then(function () {
+                        stateManager.restore();
+                      }));
+                      return;
+                    } else if (type.name === 'Image') {
+                      self.buildPaintImageXObject(resources, xobj, false, operatorList, name, imageCache);
+                      args = null;
+                      continue;
+                    } else if (type.name === 'PS') {
+                      // PostScript XObjects are unused when viewing documents.
+                      // See section 4.7.1 of Adobe's PDF reference.
+                      info('Ignored XObject subtype PS');
+                      continue;
+                    } else {
+                      error('Unhandled XObject subtype ' + type.name);
+                    }
+                  }
+                  break;
+                case OPS.setFont:
+                  var fontSize = args[1];
+                  // eagerly collect all fonts
+                  next(self.handleSetFont(resources, args, null, operatorList, task, stateManager.state).then(function (loadedName) {
+                    operatorList.addDependency(loadedName);
+                    operatorList.addOp(OPS.setFont, [
+                      loadedName,
+                      fontSize
+                    ]);
+                  }));
+                  return;
+                case OPS.endInlineImage:
+                  var cacheKey = args[0].cacheKey;
+                  if (cacheKey) {
+                    var cacheEntry = imageCache[cacheKey];
+                    if (cacheEntry !== undefined) {
+                      operatorList.addOp(cacheEntry.fn, cacheEntry.args);
+                      args = null;
+                      continue;
+                    }
+                  }
+                  self.buildPaintImageXObject(resources, args[0], true, operatorList, cacheKey, imageCache);
+                  args = null;
+                  continue;
+                case OPS.showText:
+                  args[0] = self.handleText(args[0], stateManager.state);
+                  break;
+                case OPS.showSpacedText:
+                  var arr = args[0];
+                  var combinedGlyphs = [];
+                  var arrLength = arr.length;
+                  var state = stateManager.state;
+                  for (i = 0; i < arrLength; ++i) {
+                    var arrItem = arr[i];
+                    if (isString(arrItem)) {
+                      Array.prototype.push.apply(combinedGlyphs, self.handleText(arrItem, state));
+                    } else if (isNum(arrItem)) {
+                      combinedGlyphs.push(arrItem);
+                    }
+                  }
+                  args[0] = combinedGlyphs;
+                  fn = OPS.showText;
+                  break;
+                case OPS.nextLineShowText:
+                  operatorList.addOp(OPS.nextLine);
+                  args[0] = self.handleText(args[0], stateManager.state);
+                  fn = OPS.showText;
+                  break;
+                case OPS.nextLineSetSpacingShowText:
+                  operatorList.addOp(OPS.nextLine);
+                  operatorList.addOp(OPS.setWordSpacing, [args.shift()]);
+                  operatorList.addOp(OPS.setCharSpacing, [args.shift()]);
+                  args[0] = self.handleText(args[0], stateManager.state);
+                  fn = OPS.showText;
+                  break;
+                case OPS.setTextRenderingMode:
+                  stateManager.state.textRenderingMode = args[0];
+                  break;
+                case OPS.setFillColorSpace:
+                  stateManager.state.fillColorSpace = ColorSpace.parse(args[0], xref, resources);
+                  continue;
+                case OPS.setStrokeColorSpace:
+                  stateManager.state.strokeColorSpace = ColorSpace.parse(args[0], xref, resources);
+                  continue;
+                case OPS.setFillColor:
+                  cs = stateManager.state.fillColorSpace;
+                  args = cs.getRgb(args, 0);
+                  fn = OPS.setFillRGBColor;
+                  break;
+                case OPS.setStrokeColor:
+                  cs = stateManager.state.strokeColorSpace;
+                  args = cs.getRgb(args, 0);
+                  fn = OPS.setStrokeRGBColor;
+                  break;
+                case OPS.setFillGray:
+                  stateManager.state.fillColorSpace = ColorSpace.singletons.gray;
+                  args = ColorSpace.singletons.gray.getRgb(args, 0);
+                  fn = OPS.setFillRGBColor;
+                  break;
+                case OPS.setStrokeGray:
+                  stateManager.state.strokeColorSpace = ColorSpace.singletons.gray;
+                  args = ColorSpace.singletons.gray.getRgb(args, 0);
+                  fn = OPS.setStrokeRGBColor;
+                  break;
+                case OPS.setFillCMYKColor:
+                  stateManager.state.fillColorSpace = ColorSpace.singletons.cmyk;
+                  args = ColorSpace.singletons.cmyk.getRgb(args, 0);
+                  fn = OPS.setFillRGBColor;
+                  break;
+                case OPS.setStrokeCMYKColor:
+                  stateManager.state.strokeColorSpace = ColorSpace.singletons.cmyk;
+                  args = ColorSpace.singletons.cmyk.getRgb(args, 0);
+                  fn = OPS.setStrokeRGBColor;
+                  break;
+                case OPS.setFillRGBColor:
+                  stateManager.state.fillColorSpace = ColorSpace.singletons.rgb;
+                  args = ColorSpace.singletons.rgb.getRgb(args, 0);
+                  break;
+                case OPS.setStrokeRGBColor:
+                  stateManager.state.strokeColorSpace = ColorSpace.singletons.rgb;
+                  args = ColorSpace.singletons.rgb.getRgb(args, 0);
+                  break;
+                case OPS.setFillColorN:
+                  cs = stateManager.state.fillColorSpace;
+                  if (cs.name === 'Pattern') {
+                    next(self.handleColorN(operatorList, OPS.setFillColorN, args, cs, patterns, resources, task, xref));
+                    return;
+                  }
+                  args = cs.getRgb(args, 0);
+                  fn = OPS.setFillRGBColor;
+                  break;
+                case OPS.setStrokeColorN:
+                  cs = stateManager.state.strokeColorSpace;
+                  if (cs.name === 'Pattern') {
+                    next(self.handleColorN(operatorList, OPS.setStrokeColorN, args, cs, patterns, resources, task, xref));
+                    return;
+                  }
+                  args = cs.getRgb(args, 0);
+                  fn = OPS.setStrokeRGBColor;
+                  break;
+                case OPS.shadingFill:
+                  var shadingRes = resources.get('Shading');
+                  if (!shadingRes) {
+                    error('No shading resource found');
+                  }
+                  var shading = shadingRes.get(args[0].name);
+                  if (!shading) {
+                    error('No shading object found');
+                  }
+                  var shadingFill = Pattern.parseShading(shading, null, xref, resources, self.handler);
+                  var patternIR = shadingFill.getIR();
+                  args = [patternIR];
+                  fn = OPS.shadingFill;
+                  break;
+                case OPS.setGState:
+                  var dictName = args[0];
+                  var extGState = resources.get('ExtGState');
+                  if (!isDict(extGState) || !extGState.has(dictName.name)) {
+                    break;
+                  }
+                  var gState = extGState.get(dictName.name);
+                  next(self.setGState(resources, gState, operatorList, task, xref, stateManager));
+                  return;
+                case OPS.moveTo:
+                case OPS.lineTo:
+                case OPS.curveTo:
+                case OPS.curveTo2:
+                case OPS.curveTo3:
+                case OPS.closePath:
+                  self.buildPath(operatorList, fn, args);
+                  continue;
+                case OPS.rectangle:
+                  self.buildPath(operatorList, fn, args);
+                  continue;
+                case OPS.markPoint:
+                case OPS.markPointProps:
+                case OPS.beginMarkedContent:
+                case OPS.beginMarkedContentProps:
+                case OPS.endMarkedContent:
+                case OPS.beginCompat:
+                case OPS.endCompat:
+                  // Ignore operators where the corresponding handlers are known to
+                  // be no-op in CanvasGraphics (display/canvas.js). This prevents
+                  // serialization errors and is also a bit more efficient.
+                  // We could also try to serialize all objects in a general way,
+                  // e.g. as done in https://github.com/mozilla/pdf.js/pull/6266,
+                  // but doing so is meaningless without knowing the semantics.
+                  continue;
+                default:
+                  // Note: Ignore the operator if it has `Dict` arguments, since
+                  // those are non-serializable, otherwise postMessage will throw
+                  // "An object could not be cloned.".
+                  if (args !== null) {
+                    for (i = 0, ii = args.length; i < ii; i++) {
+                      if (args[i] instanceof Dict) {
+                        break;
+                      }
+                    }
+                    if (i < ii) {
+                      warn('getOperatorList - ignoring operator: ' + fn);
+                      continue;
+                    }
+                  }
+                }
+                operatorList.addOp(fn, args);
+              }
+              if (stop) {
+                next(deferred);
+                return;
+              }
+              // Some PDFs don't close all restores inside object/form.
+              // Closing those for them.
+              for (i = 0, ii = preprocessor.savedStatesDepth; i < ii; i++) {
+                operatorList.addOp(OPS.restore, []);
+              }
+              resolve();
+            });
+          },
+          getTextContent: function PartialEvaluator_getTextContent(stream, task, resources, stateManager, normalizeWhitespace, combineTextItems) {
+            stateManager = stateManager || new StateManager(new TextState());
+            var WhitespaceRegexp = /\s/g;
+            var textContent = {
+              items: [],
+              styles: Object.create(null)
+            };
+            var textContentItem = {
+              initialized: false,
+              str: [],
+              width: 0,
+              height: 0,
+              vertical: false,
+              lastAdvanceWidth: 0,
+              lastAdvanceHeight: 0,
+              textAdvanceScale: 0,
+              spaceWidth: 0,
+              fakeSpaceMin: Infinity,
+              fakeMultiSpaceMin: Infinity,
+              fakeMultiSpaceMax: -0,
+              textRunBreakAllowed: false,
+              transform: null,
+              fontName: null
+            };
+            var SPACE_FACTOR = 0.3;
+            var MULTI_SPACE_FACTOR = 1.5;
+            var MULTI_SPACE_FACTOR_MAX = 4;
+            var self = this;
+            var xref = this.xref;
+            resources = xref.fetchIfRef(resources) || Dict.empty;
+            // The xobj is parsed iff it's needed, e.g. if there is a `DO` cmd.
+            var xobjs = null;
+            var xobjsCache = Object.create(null);
+            var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
+            var textState;
+            function ensureTextContentItem() {
+              if (textContentItem.initialized) {
+                return textContentItem;
+              }
+              var font = textState.font;
+              if (!(font.loadedName in textContent.styles)) {
+                textContent.styles[font.loadedName] = {
+                  fontFamily: font.fallbackName,
+                  ascent: font.ascent,
+                  descent: font.descent,
+                  vertical: font.vertical
+                };
+              }
+              textContentItem.fontName = font.loadedName;
+              // 9.4.4 Text Space Details
+              var tsm = [
+                textState.fontSize * textState.textHScale,
+                0,
+                0,
+                textState.fontSize,
+                0,
+                textState.textRise
+              ];
+              if (font.isType3Font && textState.fontMatrix !== FONT_IDENTITY_MATRIX && textState.fontSize === 1) {
+                var glyphHeight = font.bbox[3] - font.bbox[1];
+                if (glyphHeight > 0) {
+                  glyphHeight = glyphHeight * textState.fontMatrix[3];
+                  tsm[3] *= glyphHeight;
+                }
+              }
+              var trm = Util.transform(textState.ctm, Util.transform(textState.textMatrix, tsm));
+              textContentItem.transform = trm;
+              if (!font.vertical) {
+                textContentItem.width = 0;
+                textContentItem.height = Math.sqrt(trm[2] * trm[2] + trm[3] * trm[3]);
+                textContentItem.vertical = false;
+              } else {
+                textContentItem.width = Math.sqrt(trm[0] * trm[0] + trm[1] * trm[1]);
+                textContentItem.height = 0;
+                textContentItem.vertical = true;
+              }
+              var a = textState.textLineMatrix[0];
+              var b = textState.textLineMatrix[1];
+              var scaleLineX = Math.sqrt(a * a + b * b);
+              a = textState.ctm[0];
+              b = textState.ctm[1];
+              var scaleCtmX = Math.sqrt(a * a + b * b);
+              textContentItem.textAdvanceScale = scaleCtmX * scaleLineX;
+              textContentItem.lastAdvanceWidth = 0;
+              textContentItem.lastAdvanceHeight = 0;
+              var spaceWidth = font.spaceWidth / 1000 * textState.fontSize;
+              if (spaceWidth) {
+                textContentItem.spaceWidth = spaceWidth;
+                textContentItem.fakeSpaceMin = spaceWidth * SPACE_FACTOR;
+                textContentItem.fakeMultiSpaceMin = spaceWidth * MULTI_SPACE_FACTOR;
+                textContentItem.fakeMultiSpaceMax = spaceWidth * MULTI_SPACE_FACTOR_MAX;
+                // It's okay for monospace fonts to fake as much space as needed.
+                textContentItem.textRunBreakAllowed = !font.isMonospace;
+              } else {
+                textContentItem.spaceWidth = 0;
+                textContentItem.fakeSpaceMin = Infinity;
+                textContentItem.fakeMultiSpaceMin = Infinity;
+                textContentItem.fakeMultiSpaceMax = 0;
+                textContentItem.textRunBreakAllowed = false;
+              }
+              textContentItem.initialized = true;
+              return textContentItem;
+            }
+            function replaceWhitespace(str) {
+              // Replaces all whitespaces with standard spaces (0x20), to avoid
+              // alignment issues between the textLayer and the canvas if the text
+              // contains e.g. tabs (fixes issue6612.pdf).
+              var i = 0, ii = str.length, code;
+              while (i < ii && (code = str.charCodeAt(i)) >= 0x20 && code <= 0x7F) {
+                i++;
+              }
+              return i < ii ? str.replace(WhitespaceRegexp, ' ') : str;
+            }
+            function runBidiTransform(textChunk) {
+              var str = textChunk.str.join('');
+              var bidiResult = bidi(str, -1, textChunk.vertical);
+              return {
+                str: normalizeWhitespace ? replaceWhitespace(bidiResult.str) : bidiResult.str,
+                dir: bidiResult.dir,
+                width: textChunk.width,
+                height: textChunk.height,
+                transform: textChunk.transform,
+                fontName: textChunk.fontName
+              };
+            }
+            function handleSetFont(fontName, fontRef) {
+              return self.loadFont(fontName, fontRef, xref, resources).then(function (translated) {
+                textState.font = translated.font;
+                textState.fontMatrix = translated.font.fontMatrix || FONT_IDENTITY_MATRIX;
+              });
+            }
+            function buildTextContentItem(chars) {
+              var font = textState.font;
+              var textChunk = ensureTextContentItem();
+              var width = 0;
+              var height = 0;
+              var glyphs = font.charsToGlyphs(chars);
+              var defaultVMetrics = font.defaultVMetrics;
+              for (var i = 0; i < glyphs.length; i++) {
+                var glyph = glyphs[i];
+                var vMetricX = null;
+                var vMetricY = null;
+                var glyphWidth = null;
+                if (font.vertical) {
+                  if (glyph.vmetric) {
+                    glyphWidth = glyph.vmetric[0];
+                    vMetricX = glyph.vmetric[1];
+                    vMetricY = glyph.vmetric[2];
+                  } else {
+                    glyphWidth = glyph.width;
+                    vMetricX = glyph.width * 0.5;
+                    vMetricY = defaultVMetrics[2];
+                  }
+                } else {
+                  glyphWidth = glyph.width;
+                }
+                var glyphUnicode = glyph.unicode;
+                var NormalizedUnicodes = getNormalizedUnicodes();
+                if (NormalizedUnicodes[glyphUnicode] !== undefined) {
+                  glyphUnicode = NormalizedUnicodes[glyphUnicode];
+                }
+                glyphUnicode = reverseIfRtl(glyphUnicode);
+                // The following will calculate the x and y of the individual glyphs.
+                // if (font.vertical) {
+                //   tsm[4] -= vMetricX * Math.abs(textState.fontSize) *
+                //             textState.fontMatrix[0];
+                //   tsm[5] -= vMetricY * textState.fontSize *
+                //             textState.fontMatrix[0];
+                // }
+                // var trm = Util.transform(textState.textMatrix, tsm);
+                // var pt = Util.applyTransform([trm[4], trm[5]], textState.ctm);
+                // var x = pt[0];
+                // var y = pt[1];
+                var charSpacing = textState.charSpacing;
+                if (glyph.isSpace) {
+                  var wordSpacing = textState.wordSpacing;
+                  charSpacing += wordSpacing;
+                  if (wordSpacing > 0) {
+                    addFakeSpaces(wordSpacing, textChunk.str);
+                  }
+                }
+                var tx = 0;
+                var ty = 0;
+                if (!font.vertical) {
+                  var w0 = glyphWidth * textState.fontMatrix[0];
+                  tx = (w0 * textState.fontSize + charSpacing) * textState.textHScale;
+                  width += tx;
+                } else {
+                  var w1 = glyphWidth * textState.fontMatrix[0];
+                  ty = w1 * textState.fontSize + charSpacing;
+                  height += ty;
+                }
+                textState.translateTextMatrix(tx, ty);
+                textChunk.str.push(glyphUnicode);
+              }
+              if (!font.vertical) {
+                textChunk.lastAdvanceWidth = width;
+                textChunk.width += width * textChunk.textAdvanceScale;
+              } else {
+                textChunk.lastAdvanceHeight = height;
+                textChunk.height += Math.abs(height * textChunk.textAdvanceScale);
+              }
+              return textChunk;
+            }
+            function addFakeSpaces(width, strBuf) {
+              if (width < textContentItem.fakeSpaceMin) {
+                return;
+              }
+              if (width < textContentItem.fakeMultiSpaceMin) {
+                strBuf.push(' ');
+                return;
+              }
+              var fakeSpaces = Math.round(width / textContentItem.spaceWidth);
+              while (fakeSpaces-- > 0) {
+                strBuf.push(' ');
+              }
+            }
+            function flushTextContentItem() {
+              if (!textContentItem.initialized) {
+                return;
+              }
+              textContent.items.push(runBidiTransform(textContentItem));
+              textContentItem.initialized = false;
+              textContentItem.str.length = 0;
+            }
+            var timeSlotManager = new TimeSlotManager();
+            return new Promise(function promiseBody(resolve, reject) {
+              var next = function (promise) {
+                promise.then(function () {
+                  try {
+                    promiseBody(resolve, reject);
+                  } catch (ex) {
+                    reject(ex);
+                  }
+                }, reject);
+              };
+              task.ensureNotTerminated();
+              timeSlotManager.reset();
+              var stop, operation = {}, args = [];
+              while (!(stop = timeSlotManager.check())) {
+                // The arguments parsed by read() are not used beyond this loop, so
+                // we can reuse the same array on every iteration, thus avoiding
+                // unnecessary allocations.
+                args.length = 0;
+                operation.args = args;
+                if (!preprocessor.read(operation)) {
+                  break;
+                }
+                textState = stateManager.state;
+                var fn = operation.fn;
+                args = operation.args;
+                var advance, diff;
+                switch (fn | 0) {
+                case OPS.setFont:
+                  // Optimization to ignore multiple identical Tf commands.
+                  var fontNameArg = args[0].name, fontSizeArg = args[1];
+                  if (textState.font && fontNameArg === textState.fontName && fontSizeArg === textState.fontSize) {
+                    break;
+                  }
+                  flushTextContentItem();
+                  textState.fontName = fontNameArg;
+                  textState.fontSize = fontSizeArg;
+                  next(handleSetFont(fontNameArg, null));
+                  return;
+                case OPS.setTextRise:
+                  flushTextContentItem();
+                  textState.textRise = args[0];
+                  break;
+                case OPS.setHScale:
+                  flushTextContentItem();
+                  textState.textHScale = args[0] / 100;
+                  break;
+                case OPS.setLeading:
+                  flushTextContentItem();
+                  textState.leading = args[0];
+                  break;
+                case OPS.moveText:
+                  // Optimization to treat same line movement as advance
+                  var isSameTextLine = !textState.font ? false : (textState.font.vertical ? args[0] : args[1]) === 0;
+                  advance = args[0] - args[1];
+                  if (combineTextItems && isSameTextLine && textContentItem.initialized && advance > 0 && advance <= textContentItem.fakeMultiSpaceMax) {
+                    textState.translateTextLineMatrix(args[0], args[1]);
+                    textContentItem.width += args[0] - textContentItem.lastAdvanceWidth;
+                    textContentItem.height += args[1] - textContentItem.lastAdvanceHeight;
+                    diff = args[0] - textContentItem.lastAdvanceWidth - (args[1] - textContentItem.lastAdvanceHeight);
+                    addFakeSpaces(diff, textContentItem.str);
+                    break;
+                  }
+                  flushTextContentItem();
+                  textState.translateTextLineMatrix(args[0], args[1]);
+                  textState.textMatrix = textState.textLineMatrix.slice();
+                  break;
+                case OPS.setLeadingMoveText:
+                  flushTextContentItem();
+                  textState.leading = -args[1];
+                  textState.translateTextLineMatrix(args[0], args[1]);
+                  textState.textMatrix = textState.textLineMatrix.slice();
+                  break;
+                case OPS.nextLine:
+                  flushTextContentItem();
+                  textState.carriageReturn();
+                  break;
+                case OPS.setTextMatrix:
+                  // Optimization to treat same line movement as advance.
+                  advance = textState.calcTextLineMatrixAdvance(args[0], args[1], args[2], args[3], args[4], args[5]);
+                  if (combineTextItems && advance !== null && textContentItem.initialized && advance.value > 0 && advance.value <= textContentItem.fakeMultiSpaceMax) {
+                    textState.translateTextLineMatrix(advance.width, advance.height);
+                    textContentItem.width += advance.width - textContentItem.lastAdvanceWidth;
+                    textContentItem.height += advance.height - textContentItem.lastAdvanceHeight;
+                    diff = advance.width - textContentItem.lastAdvanceWidth - (advance.height - textContentItem.lastAdvanceHeight);
+                    addFakeSpaces(diff, textContentItem.str);
+                    break;
+                  }
+                  flushTextContentItem();
+                  textState.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
+                  textState.setTextLineMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
+                  break;
+                case OPS.setCharSpacing:
+                  textState.charSpacing = args[0];
+                  break;
+                case OPS.setWordSpacing:
+                  textState.wordSpacing = args[0];
+                  break;
+                case OPS.beginText:
+                  flushTextContentItem();
+                  textState.textMatrix = IDENTITY_MATRIX.slice();
+                  textState.textLineMatrix = IDENTITY_MATRIX.slice();
+                  break;
+                case OPS.showSpacedText:
+                  var items = args[0];
+                  var offset;
+                  for (var j = 0, jj = items.length; j < jj; j++) {
+                    if (typeof items[j] === 'string') {
+                      buildTextContentItem(items[j]);
+                    } else if (isNum(items[j])) {
+                      ensureTextContentItem();
+                      // PDF Specification 5.3.2 states:
+                      // The number is expressed in thousandths of a unit of text
+                      // space.
+                      // This amount is subtracted from the current horizontal or
+                      // vertical coordinate, depending on the writing mode.
+                      // In the default coordinate system, a positive adjustment
+                      // has the effect of moving the next glyph painted either to
+                      // the left or down by the given amount.
+                      advance = items[j] * textState.fontSize / 1000;
+                      var breakTextRun = false;
+                      if (textState.font.vertical) {
+                        offset = advance * (textState.textHScale * textState.textMatrix[2] + textState.textMatrix[3]);
+                        textState.translateTextMatrix(0, advance);
+                        breakTextRun = textContentItem.textRunBreakAllowed && advance > textContentItem.fakeMultiSpaceMax;
+                        if (!breakTextRun) {
+                          // Value needs to be added to height to paint down.
+                          textContentItem.height += offset;
+                        }
+                      } else {
+                        advance = -advance;
+                        offset = advance * (textState.textHScale * textState.textMatrix[0] + textState.textMatrix[1]);
+                        textState.translateTextMatrix(advance, 0);
+                        breakTextRun = textContentItem.textRunBreakAllowed && advance > textContentItem.fakeMultiSpaceMax;
+                        if (!breakTextRun) {
+                          // Value needs to be subtracted from width to paint left.
+                          textContentItem.width += offset;
+                        }
+                      }
+                      if (breakTextRun) {
+                        flushTextContentItem();
+                      } else if (advance > 0) {
+                        addFakeSpaces(advance, textContentItem.str);
+                      }
+                    }
+                  }
+                  break;
+                case OPS.showText:
+                  buildTextContentItem(args[0]);
+                  break;
+                case OPS.nextLineShowText:
+                  flushTextContentItem();
+                  textState.carriageReturn();
+                  buildTextContentItem(args[0]);
+                  break;
+                case OPS.nextLineSetSpacingShowText:
+                  flushTextContentItem();
+                  textState.wordSpacing = args[0];
+                  textState.charSpacing = args[1];
+                  textState.carriageReturn();
+                  buildTextContentItem(args[2]);
+                  break;
+                case OPS.paintXObject:
+                  flushTextContentItem();
+                  if (args[0].code) {
+                    break;
+                  }
+                  if (!xobjs) {
+                    xobjs = resources.get('XObject') || Dict.empty;
+                  }
+                  var name = args[0].name;
+                  if (xobjsCache.key === name) {
+                    if (xobjsCache.texts) {
+                      Util.appendToArray(textContent.items, xobjsCache.texts.items);
+                      Util.extendObj(textContent.styles, xobjsCache.texts.styles);
+                    }
+                    break;
+                  }
+                  var xobj = xobjs.get(name);
+                  if (!xobj) {
+                    break;
+                  }
+                  assert(isStream(xobj), 'XObject should be a stream');
+                  var type = xobj.dict.get('Subtype');
+                  assert(isName(type), 'XObject should have a Name subtype');
+                  if ('Form' !== type.name) {
+                    xobjsCache.key = name;
+                    xobjsCache.texts = null;
+                    break;
+                  }
+                  stateManager.save();
+                  var matrix = xobj.dict.getArray('Matrix');
+                  if (isArray(matrix) && matrix.length === 6) {
+                    stateManager.transform(matrix);
+                  }
+                  next(self.getTextContent(xobj, task, xobj.dict.get('Resources') || resources, stateManager, normalizeWhitespace, combineTextItems).then(function (formTextContent) {
+                    Util.appendToArray(textContent.items, formTextContent.items);
+                    Util.extendObj(textContent.styles, formTextContent.styles);
+                    stateManager.restore();
+                    xobjsCache.key = name;
+                    xobjsCache.texts = formTextContent;
+                  }));
+                  return;
+                case OPS.setGState:
+                  flushTextContentItem();
+                  var dictName = args[0];
+                  var extGState = resources.get('ExtGState');
+                  if (!isDict(extGState) || !isName(dictName)) {
+                    break;
+                  }
+                  var gState = extGState.get(dictName.name);
+                  if (!isDict(gState)) {
+                    break;
+                  }
+                  var gStateFont = gState.get('Font');
+                  if (gStateFont) {
+                    textState.fontName = null;
+                    textState.fontSize = gStateFont[1];
+                    next(handleSetFont(null, gStateFont[0]));
+                    return;
+                  }
+                  break;
+                }
+              }
+              // switch
+              // while
+              if (stop) {
+                next(deferred);
+                return;
+              }
+              flushTextContentItem();
+              resolve(textContent);
+            });
+          },
+          extractDataStructures: function PartialEvaluator_extractDataStructures(dict, baseDict, xref, properties) {
+            // 9.10.2
+            var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode');
+            var toUnicodePromise = toUnicode ? this.readToUnicode(toUnicode) : Promise.resolve(undefined);
+            if (properties.composite) {
+              // CIDSystemInfo helps to match CID to glyphs
+              var cidSystemInfo = dict.get('CIDSystemInfo');
+              if (isDict(cidSystemInfo)) {
+                properties.cidSystemInfo = {
+                  registry: cidSystemInfo.get('Registry'),
+                  ordering: cidSystemInfo.get('Ordering'),
+                  supplement: cidSystemInfo.get('Supplement')
+                };
+              }
+              var cidToGidMap = dict.get('CIDToGIDMap');
+              if (isStream(cidToGidMap)) {
+                properties.cidToGidMap = this.readCidToGidMap(cidToGidMap);
+              }
+            }
+            // Based on 9.6.6 of the spec the encoding can come from multiple places
+            // and depends on the font type. The base encoding and differences are
+            // read here, but the encoding that is actually used is chosen during
+            // glyph mapping in the font.
+            // TODO: Loading the built in encoding in the font would allow the
+            // differences to be merged in here not require us to hold on to it.
+            var differences = [];
+            var baseEncodingName = null;
+            var encoding;
+            if (dict.has('Encoding')) {
+              encoding = dict.get('Encoding');
+              if (isDict(encoding)) {
+                baseEncodingName = encoding.get('BaseEncoding');
+                baseEncodingName = isName(baseEncodingName) ? baseEncodingName.name : null;
+                // Load the differences between the base and original
+                if (encoding.has('Differences')) {
+                  var diffEncoding = encoding.get('Differences');
+                  var index = 0;
+                  for (var j = 0, jj = diffEncoding.length; j < jj; j++) {
+                    var data = xref.fetchIfRef(diffEncoding[j]);
+                    if (isNum(data)) {
+                      index = data;
+                    } else if (isName(data)) {
+                      differences[index++] = data.name;
+                    } else {
+                      error('Invalid entry in \'Differences\' array: ' + data);
+                    }
+                  }
+                }
+              } else if (isName(encoding)) {
+                baseEncodingName = encoding.name;
+              } else {
+                error('Encoding is not a Name nor a Dict');
+              }
+              // According to table 114 if the encoding is a named encoding it must be
+              // one of these predefined encodings.
+              if (baseEncodingName !== 'MacRomanEncoding' && baseEncodingName !== 'MacExpertEncoding' && baseEncodingName !== 'WinAnsiEncoding') {
+                baseEncodingName = null;
+              }
+            }
+            if (baseEncodingName) {
+              properties.defaultEncoding = getEncoding(baseEncodingName).slice();
+            } else {
+              encoding = properties.type === 'TrueType' ? WinAnsiEncoding : StandardEncoding;
+              // The Symbolic attribute can be misused for regular fonts
+              // Heuristic: we have to check if the font is a standard one also
+              if (!!(properties.flags & FontFlags.Symbolic)) {
+                encoding = MacRomanEncoding;
+                if (!properties.file) {
+                  if (/Symbol/i.test(properties.name)) {
+                    encoding = SymbolSetEncoding;
+                  } else if (/Dingbats/i.test(properties.name)) {
+                    encoding = ZapfDingbatsEncoding;
+                  }
+                }
+              }
+              properties.defaultEncoding = encoding;
+            }
+            properties.differences = differences;
+            properties.baseEncodingName = baseEncodingName;
+            properties.hasEncoding = !!baseEncodingName || differences.length > 0;
+            properties.dict = dict;
+            return toUnicodePromise.then(function (toUnicode) {
+              properties.toUnicode = toUnicode;
+              return this.buildToUnicode(properties);
+            }.bind(this)).then(function (toUnicode) {
+              properties.toUnicode = toUnicode;
+              return properties;
+            });
+          },
+          /**
+           * Builds a char code to unicode map based on section 9.10 of the spec.
+           * @param {Object} properties Font properties object.
+           * @return {Promise} A Promise that is resolved with a
+           *   {ToUnicodeMap|IdentityToUnicodeMap} object.
+           */
+          buildToUnicode: function PartialEvaluator_buildToUnicode(properties) {
+            properties.hasIncludedToUnicodeMap = !!properties.toUnicode && properties.toUnicode.length > 0;
+            // Section 9.10.2 Mapping Character Codes to Unicode Values
+            if (properties.hasIncludedToUnicodeMap) {
+              return Promise.resolve(properties.toUnicode);
+            }
+            // According to the spec if the font is a simple font we should only map
+            // to unicode if the base encoding is MacRoman, MacExpert, or WinAnsi or
+            // the differences array only contains adobe standard or symbol set names,
+            // in pratice it seems better to always try to create a toUnicode
+            // map based of the default encoding.
+            var toUnicode, charcode, glyphName;
+            if (!properties.composite)
+              /* is simple font */
+              {
+                toUnicode = [];
+                var encoding = properties.defaultEncoding.slice();
+                var baseEncodingName = properties.baseEncodingName;
+                // Merge in the differences array.
+                var differences = properties.differences;
+                for (charcode in differences) {
+                  glyphName = differences[charcode];
+                  if (glyphName === '.notdef') {
+                    // Skip .notdef to prevent rendering errors, e.g. boxes appearing
+                    // where there should be spaces (fixes issue5256.pdf).
+                    continue;
+                  }
+                  encoding[charcode] = glyphName;
+                }
+                var glyphsUnicodeMap = getGlyphsUnicode();
+                for (charcode in encoding) {
+                  // a) Map the character code to a character name.
+                  glyphName = encoding[charcode];
+                  // b) Look up the character name in the Adobe Glyph List (see the
+                  //    Bibliography) to obtain the corresponding Unicode value.
+                  if (glyphName === '') {
+                    continue;
+                  } else if (glyphsUnicodeMap[glyphName] === undefined) {
+                    // (undocumented) c) Few heuristics to recognize unknown glyphs
+                    // NOTE: Adobe Reader does not do this step, but OSX Preview does
+                    var code = 0;
+                    switch (glyphName[0]) {
+                    case 'G':
+                      // Gxx glyph
+                      if (glyphName.length === 3) {
+                        code = parseInt(glyphName.substr(1), 16);
+                      }
+                      break;
+                    case 'g':
+                      // g00xx glyph
+                      if (glyphName.length === 5) {
+                        code = parseInt(glyphName.substr(1), 16);
+                      }
+                      break;
+                    case 'C':
+                    // Cddd glyph
+                    case 'c':
+                      // cddd glyph
+                      if (glyphName.length >= 3) {
+                        code = +glyphName.substr(1);
+                      }
+                      break;
+                    default:
+                      // 'uniXXXX'/'uXXXX{XX}' glyphs
+                      var unicode = getUnicodeForGlyph(glyphName, glyphsUnicodeMap);
+                      if (unicode !== -1) {
+                        code = unicode;
+                      }
+                    }
+                    if (code) {
+                      // If |baseEncodingName| is one the predefined encodings,
+                      // and |code| equals |charcode|, using the glyph defined in the
+                      // baseEncoding seems to yield a better |toUnicode| mapping
+                      // (fixes issue 5070).
+                      if (baseEncodingName && code === +charcode) {
+                        var baseEncoding = getEncoding(baseEncodingName);
+                        if (baseEncoding && (glyphName = baseEncoding[charcode])) {
+                          toUnicode[charcode] = String.fromCharCode(glyphsUnicodeMap[glyphName]);
+                          continue;
+                        }
+                      }
+                      toUnicode[charcode] = String.fromCharCode(code);
+                    }
+                    continue;
+                  }
+                  toUnicode[charcode] = String.fromCharCode(glyphsUnicodeMap[glyphName]);
+                }
+                return Promise.resolve(new ToUnicodeMap(toUnicode));
+              }
+            // If the font is a composite font that uses one of the predefined CMaps
+            // listed in Table 118 (except Identity–H and Identity–V) or whose
+            // descendant CIDFont uses the Adobe-GB1, Adobe-CNS1, Adobe-Japan1, or
+            // Adobe-Korea1 character collection:
+            if (properties.composite && (properties.cMap.builtInCMap && !(properties.cMap instanceof IdentityCMap) || properties.cidSystemInfo.registry === 'Adobe' && (properties.cidSystemInfo.ordering === 'GB1' || properties.cidSystemInfo.ordering === 'CNS1' || properties.cidSystemInfo.ordering === 'Japan1' || properties.cidSystemInfo.ordering === 'Korea1'))) {
+              // Then:
+              // a) Map the character code to a character identifier (CID) according
+              // to the font’s CMap.
+              // b) Obtain the registry and ordering of the character collection used
+              // by the font’s CMap (for example, Adobe and Japan1) from its
+              // CIDSystemInfo dictionary.
+              var registry = properties.cidSystemInfo.registry;
+              var ordering = properties.cidSystemInfo.ordering;
+              // c) Construct a second CMap name by concatenating the registry and
+              // ordering obtained in step (b) in the format registry–ordering–UCS2
+              // (for example, Adobe–Japan1–UCS2).
+              var ucs2CMapName = Name.get(registry + '-' + ordering + '-UCS2');
+              // d) Obtain the CMap with the name constructed in step (c) (available
+              // from the ASN Web site; see the Bibliography).
+              return CMapFactory.create(ucs2CMapName, this.options.cMapOptions, null).then(function (ucs2CMap) {
+                var cMap = properties.cMap;
+                toUnicode = [];
+                cMap.forEach(function (charcode, cid) {
+                  assert(cid <= 0xffff, 'Max size of CID is 65,535');
+                  // e) Map the CID obtained in step (a) according to the CMap
+                  // obtained in step (d), producing a Unicode value.
+                  var ucs2 = ucs2CMap.lookup(cid);
+                  if (ucs2) {
+                    toUnicode[charcode] = String.fromCharCode((ucs2.charCodeAt(0) << 8) + ucs2.charCodeAt(1));
+                  }
+                });
+                return new ToUnicodeMap(toUnicode);
+              });
+            }
+            // The viewer's choice, just use an identity map.
+            return Promise.resolve(new IdentityToUnicodeMap(properties.firstChar, properties.lastChar));
+          },
+          readToUnicode: function PartialEvaluator_readToUnicode(toUnicode) {
+            var cmapObj = toUnicode;
+            if (isName(cmapObj)) {
+              return CMapFactory.create(cmapObj, this.options.cMapOptions, null).then(function (cmap) {
+                if (cmap instanceof IdentityCMap) {
+                  return new IdentityToUnicodeMap(0, 0xFFFF);
+                }
+                return new ToUnicodeMap(cmap.getMap());
+              });
+            } else if (isStream(cmapObj)) {
+              return CMapFactory.create(cmapObj, this.options.cMapOptions, null).then(function (cmap) {
+                if (cmap instanceof IdentityCMap) {
+                  return new IdentityToUnicodeMap(0, 0xFFFF);
+                }
+                var map = new Array(cmap.length);
+                // Convert UTF-16BE
+                // NOTE: cmap can be a sparse array, so use forEach instead of for(;;)
+                // to iterate over all keys.
+                cmap.forEach(function (charCode, token) {
+                  var str = [];
+                  for (var k = 0; k < token.length; k += 2) {
+                    var w1 = token.charCodeAt(k) << 8 | token.charCodeAt(k + 1);
+                    if ((w1 & 0xF800) !== 0xD800) {
+                      // w1 < 0xD800 || w1 > 0xDFFF
+                      str.push(w1);
+                      continue;
+                    }
+                    k += 2;
+                    var w2 = token.charCodeAt(k) << 8 | token.charCodeAt(k + 1);
+                    str.push(((w1 & 0x3ff) << 10) + (w2 & 0x3ff) + 0x10000);
+                  }
+                  map[charCode] = String.fromCharCode.apply(String, str);
+                });
+                return new ToUnicodeMap(map);
+              });
+            }
+            return Promise.resolve(null);
+          },
+          readCidToGidMap: function PartialEvaluator_readCidToGidMap(cidToGidStream) {
+            // Extract the encoding from the CIDToGIDMap
+            var glyphsData = cidToGidStream.getBytes();
+            // Set encoding 0 to later verify the font has an encoding
+            var result = [];
+            for (var j = 0, jj = glyphsData.length; j < jj; j++) {
+              var glyphID = glyphsData[j++] << 8 | glyphsData[j];
+              if (glyphID === 0) {
+                continue;
+              }
+              var code = j >> 1;
+              result[code] = glyphID;
+            }
+            return result;
+          },
+          extractWidths: function PartialEvaluator_extractWidths(dict, xref, descriptor, properties) {
+            var glyphsWidths = [];
+            var defaultWidth = 0;
+            var glyphsVMetrics = [];
+            var defaultVMetrics;
+            var i, ii, j, jj, start, code, widths;
+            if (properties.composite) {
+              defaultWidth = dict.get('DW') || 1000;
+              widths = dict.get('W');
+              if (widths) {
+                for (i = 0, ii = widths.length; i < ii; i++) {
+                  start = widths[i++];
+                  code = xref.fetchIfRef(widths[i]);
+                  if (isArray(code)) {
+                    for (j = 0, jj = code.length; j < jj; j++) {
+                      glyphsWidths[start++] = code[j];
+                    }
+                  } else {
+                    var width = widths[++i];
+                    for (j = start; j <= code; j++) {
+                      glyphsWidths[j] = width;
+                    }
+                  }
+                }
+              }
+              if (properties.vertical) {
+                var vmetrics = dict.get('DW2') || [
+                  880,
+                  -1000
+                ];
+                defaultVMetrics = [
+                  vmetrics[1],
+                  defaultWidth * 0.5,
+                  vmetrics[0]
+                ];
+                vmetrics = dict.get('W2');
+                if (vmetrics) {
+                  for (i = 0, ii = vmetrics.length; i < ii; i++) {
+                    start = vmetrics[i++];
+                    code = xref.fetchIfRef(vmetrics[i]);
+                    if (isArray(code)) {
+                      for (j = 0, jj = code.length; j < jj; j++) {
+                        glyphsVMetrics[start++] = [
+                          code[j++],
+                          code[j++],
+                          code[j]
+                        ];
+                      }
+                    } else {
+                      var vmetric = [
+                        vmetrics[++i],
+                        vmetrics[++i],
+                        vmetrics[++i]
+                      ];
+                      for (j = start; j <= code; j++) {
+                        glyphsVMetrics[j] = vmetric;
+                      }
+                    }
+                  }
+                }
+              }
+            } else {
+              var firstChar = properties.firstChar;
+              widths = dict.get('Widths');
+              if (widths) {
+                j = firstChar;
+                for (i = 0, ii = widths.length; i < ii; i++) {
+                  glyphsWidths[j++] = widths[i];
+                }
+                defaultWidth = parseFloat(descriptor.get('MissingWidth')) || 0;
+              } else {
+                // Trying get the BaseFont metrics (see comment above).
+                var baseFontName = dict.get('BaseFont');
+                if (isName(baseFontName)) {
+                  var metrics = this.getBaseFontMetrics(baseFontName.name);
+                  glyphsWidths = this.buildCharCodeToWidth(metrics.widths, properties);
+                  defaultWidth = metrics.defaultWidth;
+                }
+              }
+            }
+            // Heuristic: detection of monospace font by checking all non-zero widths
+            var isMonospace = true;
+            var firstWidth = defaultWidth;
+            for (var glyph in glyphsWidths) {
+              var glyphWidth = glyphsWidths[glyph];
+              if (!glyphWidth) {
+                continue;
+              }
+              if (!firstWidth) {
+                firstWidth = glyphWidth;
+                continue;
+              }
+              if (firstWidth !== glyphWidth) {
+                isMonospace = false;
+                break;
+              }
+            }
+            if (isMonospace) {
+              properties.flags |= FontFlags.FixedPitch;
+            }
+            properties.defaultWidth = defaultWidth;
+            properties.widths = glyphsWidths;
+            properties.defaultVMetrics = defaultVMetrics;
+            properties.vmetrics = glyphsVMetrics;
+          },
+          isSerifFont: function PartialEvaluator_isSerifFont(baseFontName) {
+            // Simulating descriptor flags attribute
+            var fontNameWoStyle = baseFontName.split('-')[0];
+            return fontNameWoStyle in getSerifFonts() || fontNameWoStyle.search(/serif/gi) !== -1;
+          },
+          getBaseFontMetrics: function PartialEvaluator_getBaseFontMetrics(name) {
+            var defaultWidth = 0;
+            var widths = [];
+            var monospace = false;
+            var stdFontMap = getStdFontMap();
+            var lookupName = stdFontMap[name] || name;
+            var Metrics = getMetrics();
+            if (!(lookupName in Metrics)) {
+              // Use default fonts for looking up font metrics if the passed
+              // font is not a base font
+              if (this.isSerifFont(name)) {
+                lookupName = 'Times-Roman';
+              } else {
+                lookupName = 'Helvetica';
+              }
+            }
+            var glyphWidths = Metrics[lookupName];
+            if (isNum(glyphWidths)) {
+              defaultWidth = glyphWidths;
+              monospace = true;
+            } else {
+              widths = glyphWidths();
+            }
+            // expand lazy widths array
+            return {
+              defaultWidth: defaultWidth,
+              monospace: monospace,
+              widths: widths
+            };
+          },
+          buildCharCodeToWidth: function PartialEvaluator_bulildCharCodeToWidth(widthsByGlyphName, properties) {
+            var widths = Object.create(null);
+            var differences = properties.differences;
+            var encoding = properties.defaultEncoding;
+            for (var charCode = 0; charCode < 256; charCode++) {
+              if (charCode in differences && widthsByGlyphName[differences[charCode]]) {
+                widths[charCode] = widthsByGlyphName[differences[charCode]];
+                continue;
+              }
+              if (charCode in encoding && widthsByGlyphName[encoding[charCode]]) {
+                widths[charCode] = widthsByGlyphName[encoding[charCode]];
+                continue;
+              }
+            }
+            return widths;
+          },
+          preEvaluateFont: function PartialEvaluator_preEvaluateFont(dict, xref) {
+            var baseDict = dict;
+            var type = dict.get('Subtype');
+            assert(isName(type), 'invalid font Subtype');
+            var composite = false;
+            var uint8array;
+            if (type.name === 'Type0') {
+              // If font is a composite
+              //  - get the descendant font
+              //  - set the type according to the descendant font
+              //  - get the FontDescriptor from the descendant font
+              var df = dict.get('DescendantFonts');
+              if (!df) {
+                error('Descendant fonts are not specified');
+              }
+              dict = isArray(df) ? xref.fetchIfRef(df[0]) : df;
+              type = dict.get('Subtype');
+              assert(isName(type), 'invalid font Subtype');
+              composite = true;
+            }
+            var descriptor = dict.get('FontDescriptor');
+            if (descriptor) {
+              var hash = new MurmurHash3_64();
+              var encoding = baseDict.getRaw('Encoding');
+              if (isName(encoding)) {
+                hash.update(encoding.name);
+              } else if (isRef(encoding)) {
+                hash.update(encoding.toString());
+              } else if (isDict(encoding)) {
+                var keys = encoding.getKeys();
+                for (var i = 0, ii = keys.length; i < ii; i++) {
+                  var entry = encoding.getRaw(keys[i]);
+                  if (isName(entry)) {
+                    hash.update(entry.name);
+                  } else if (isRef(entry)) {
+                    hash.update(entry.toString());
+                  } else if (isArray(entry)) {
+                    // 'Differences' entry.
+                    // Ideally we should check the contents of the array, but to avoid
+                    // parsing it here and then again in |extractDataStructures|,
+                    // we only use the array length for now (fixes bug1157493.pdf).
+                    hash.update(entry.length.toString());
+                  }
+                }
+              }
+              var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode');
+              if (isStream(toUnicode)) {
+                var stream = toUnicode.str || toUnicode;
+                uint8array = stream.buffer ? new Uint8Array(stream.buffer.buffer, 0, stream.bufferLength) : new Uint8Array(stream.bytes.buffer, stream.start, stream.end - stream.start);
+                hash.update(uint8array);
+              } else if (isName(toUnicode)) {
+                hash.update(toUnicode.name);
+              }
+              var widths = dict.get('Widths') || baseDict.get('Widths');
+              if (widths) {
+                uint8array = new Uint8Array(new Uint32Array(widths).buffer);
+                hash.update(uint8array);
+              }
+            }
+            return {
+              descriptor: descriptor,
+              dict: dict,
+              baseDict: baseDict,
+              composite: composite,
+              type: type.name,
+              hash: hash ? hash.hexdigest() : ''
+            };
+          },
+          translateFont: function PartialEvaluator_translateFont(preEvaluatedFont, xref) {
+            var baseDict = preEvaluatedFont.baseDict;
+            var dict = preEvaluatedFont.dict;
+            var composite = preEvaluatedFont.composite;
+            var descriptor = preEvaluatedFont.descriptor;
+            var type = preEvaluatedFont.type;
+            var maxCharIndex = composite ? 0xFFFF : 0xFF;
+            var cMapOptions = this.options.cMapOptions;
+            var properties;
+            if (!descriptor) {
+              if (type === 'Type3') {
+                // FontDescriptor is only required for Type3 fonts when the document
+                // is a tagged pdf. Create a barbebones one to get by.
+                descriptor = new Dict(null);
+                descriptor.set('FontName', Name.get(type));
+                descriptor.set('FontBBox', dict.getArray('FontBBox'));
+              } else {
+                // Before PDF 1.5 if the font was one of the base 14 fonts, having a
+                // FontDescriptor was not required.
+                // This case is here for compatibility.
+                var baseFontName = dict.get('BaseFont');
+                if (!isName(baseFontName)) {
+                  error('Base font is not specified');
+                }
+                // Using base font name as a font name.
+                baseFontName = baseFontName.name.replace(/[,_]/g, '-');
+                var metrics = this.getBaseFontMetrics(baseFontName);
+                // Simulating descriptor flags attribute
+                var fontNameWoStyle = baseFontName.split('-')[0];
+                var flags = (this.isSerifFont(fontNameWoStyle) ? FontFlags.Serif : 0) | (metrics.monospace ? FontFlags.FixedPitch : 0) | (getSymbolsFonts()[fontNameWoStyle] ? FontFlags.Symbolic : FontFlags.Nonsymbolic);
+                properties = {
+                  type: type,
+                  name: baseFontName,
+                  widths: metrics.widths,
+                  defaultWidth: metrics.defaultWidth,
+                  flags: flags,
+                  firstChar: 0,
+                  lastChar: maxCharIndex
+                };
+                return this.extractDataStructures(dict, dict, xref, properties).then(function (properties) {
+                  properties.widths = this.buildCharCodeToWidth(metrics.widths, properties);
+                  return new Font(baseFontName, null, properties);
+                }.bind(this));
+              }
+            }
+            // According to the spec if 'FontDescriptor' is declared, 'FirstChar',
+            // 'LastChar' and 'Widths' should exist too, but some PDF encoders seem
+            // to ignore this rule when a variant of a standard font is used.
+            // TODO Fill the width array depending on which of the base font this is
+            // a variant.
+            var firstChar = dict.get('FirstChar') || 0;
+            var lastChar = dict.get('LastChar') || maxCharIndex;
+            var fontName = descriptor.get('FontName');
+            var baseFont = dict.get('BaseFont');
+            // Some bad PDFs have a string as the font name.
+            if (isString(fontName)) {
+              fontName = Name.get(fontName);
+            }
+            if (isString(baseFont)) {
+              baseFont = Name.get(baseFont);
+            }
+            if (type !== 'Type3') {
+              var fontNameStr = fontName && fontName.name;
+              var baseFontStr = baseFont && baseFont.name;
+              if (fontNameStr !== baseFontStr) {
+                info('The FontDescriptor\'s FontName is "' + fontNameStr + '" but should be the same as the Font\'s BaseFont "' + baseFontStr + '"');
+                // Workaround for cases where e.g. fontNameStr = 'Arial' and
+                // baseFontStr = 'Arial,Bold' (needed when no font file is embedded).
+                if (fontNameStr && baseFontStr && baseFontStr.indexOf(fontNameStr) === 0) {
+                  fontName = baseFont;
+                }
+              }
+            }
+            fontName = fontName || baseFont;
+            assert(isName(fontName), 'invalid font name');
+            var fontFile = descriptor.get('FontFile', 'FontFile2', 'FontFile3');
+            if (fontFile) {
+              if (fontFile.dict) {
+                var subtype = fontFile.dict.get('Subtype');
+                if (subtype) {
+                  subtype = subtype.name;
+                }
+                var length1 = fontFile.dict.get('Length1');
+                var length2 = fontFile.dict.get('Length2');
+                var length3 = fontFile.dict.get('Length3');
+              }
+            }
+            properties = {
+              type: type,
+              name: fontName.name,
+              subtype: subtype,
+              file: fontFile,
+              length1: length1,
+              length2: length2,
+              length3: length3,
+              loadedName: baseDict.loadedName,
+              composite: composite,
+              wideChars: composite,
+              fixedPitch: false,
+              fontMatrix: dict.getArray('FontMatrix') || FONT_IDENTITY_MATRIX,
+              firstChar: firstChar || 0,
+              lastChar: lastChar || maxCharIndex,
+              bbox: descriptor.getArray('FontBBox'),
+              ascent: descriptor.get('Ascent'),
+              descent: descriptor.get('Descent'),
+              xHeight: descriptor.get('XHeight'),
+              capHeight: descriptor.get('CapHeight'),
+              flags: descriptor.get('Flags'),
+              italicAngle: descriptor.get('ItalicAngle'),
+              coded: false
+            };
+            var cMapPromise;
+            if (composite) {
+              var cidEncoding = baseDict.get('Encoding');
+              if (isName(cidEncoding)) {
+                properties.cidEncoding = cidEncoding.name;
+              }
+              cMapPromise = CMapFactory.create(cidEncoding, cMapOptions, null).then(function (cMap) {
+                properties.cMap = cMap;
+                properties.vertical = properties.cMap.vertical;
+              });
+            } else {
+              cMapPromise = Promise.resolve(undefined);
+            }
+            return cMapPromise.then(function () {
+              return this.extractDataStructures(dict, baseDict, xref, properties);
+            }.bind(this)).then(function (properties) {
+              this.extractWidths(dict, xref, descriptor, properties);
+              if (type === 'Type3') {
+                properties.isType3Font = true;
+              }
+              return new Font(fontName.name, fontFile, properties);
+            }.bind(this));
+          }
+        };
+        return PartialEvaluator;
+      }();
+      var TranslatedFont = function TranslatedFontClosure() {
+        function TranslatedFont(loadedName, font, dict) {
+          this.loadedName = loadedName;
+          this.font = font;
+          this.dict = dict;
+          this.type3Loaded = null;
+          this.sent = false;
+        }
+        TranslatedFont.prototype = {
+          send: function (handler) {
+            if (this.sent) {
+              return;
+            }
+            var fontData = this.font.exportData();
+            handler.send('commonobj', [
+              this.loadedName,
+              'Font',
+              fontData
+            ]);
+            this.sent = true;
+          },
+          loadType3Data: function (evaluator, resources, parentOperatorList, task) {
+            assert(this.font.isType3Font);
+            if (this.type3Loaded) {
+              return this.type3Loaded;
+            }
+            var translatedFont = this.font;
+            var loadCharProcsPromise = Promise.resolve();
+            var charProcs = this.dict.get('CharProcs');
+            var fontResources = this.dict.get('Resources') || resources;
+            var charProcKeys = charProcs.getKeys();
+            var charProcOperatorList = Object.create(null);
+            for (var i = 0, n = charProcKeys.length; i < n; ++i) {
+              loadCharProcsPromise = loadCharProcsPromise.then(function (key) {
+                var glyphStream = charProcs.get(key);
+                var operatorList = new OperatorList();
+                return evaluator.getOperatorList(glyphStream, task, fontResources, operatorList).then(function () {
+                  charProcOperatorList[key] = operatorList.getIR();
+                  // Add the dependencies to the parent operator list so they are
+                  // resolved before sub operator list is executed synchronously.
+                  parentOperatorList.addDependencies(operatorList.dependencies);
+                }, function (reason) {
+                  warn('Type3 font resource \"' + key + '\" is not available');
+                  var operatorList = new OperatorList();
+                  charProcOperatorList[key] = operatorList.getIR();
+                });
+              }.bind(this, charProcKeys[i]));
+            }
+            this.type3Loaded = loadCharProcsPromise.then(function () {
+              translatedFont.charProcOperatorList = charProcOperatorList;
+            });
+            return this.type3Loaded;
+          }
+        };
+        return TranslatedFont;
+      }();
+      var OperatorList = function OperatorListClosure() {
+        var CHUNK_SIZE = 1000;
+        var CHUNK_SIZE_ABOUT = CHUNK_SIZE - 5;
+        // close to chunk size
+        function getTransfers(queue) {
+          var transfers = [];
+          var fnArray = queue.fnArray, argsArray = queue.argsArray;
+          for (var i = 0, ii = queue.length; i < ii; i++) {
+            switch (fnArray[i]) {
+            case OPS.paintInlineImageXObject:
+            case OPS.paintInlineImageXObjectGroup:
+            case OPS.paintImageMaskXObject:
+              var arg = argsArray[i][0];
+              // first param in imgData
+              if (!arg.cached) {
+                transfers.push(arg.data.buffer);
+              }
+              break;
+            }
+          }
+          return transfers;
+        }
+        function OperatorList(intent, messageHandler, pageIndex) {
+          this.messageHandler = messageHandler;
+          this.fnArray = [];
+          this.argsArray = [];
+          this.dependencies = Object.create(null);
+          this._totalLength = 0;
+          this.pageIndex = pageIndex;
+          this.intent = intent;
+        }
+        OperatorList.prototype = {
+          get length() {
+            return this.argsArray.length;
+          },
+          /**
+           * @returns {number} The total length of the entire operator list,
+           *                   since `this.length === 0` after flushing.
+           */
+          get totalLength() {
+            return this._totalLength + this.length;
+          },
+          addOp: function (fn, args) {
+            this.fnArray.push(fn);
+            this.argsArray.push(args);
+            if (this.messageHandler) {
+              if (this.fnArray.length >= CHUNK_SIZE) {
+                this.flush();
+              } else if (this.fnArray.length >= CHUNK_SIZE_ABOUT && (fn === OPS.restore || fn === OPS.endText)) {
+                // heuristic to flush on boundary of restore or endText
+                this.flush();
+              }
+            }
+          },
+          addDependency: function (dependency) {
+            if (dependency in this.dependencies) {
+              return;
+            }
+            this.dependencies[dependency] = true;
+            this.addOp(OPS.dependency, [dependency]);
+          },
+          addDependencies: function (dependencies) {
+            for (var key in dependencies) {
+              this.addDependency(key);
+            }
+          },
+          addOpList: function (opList) {
+            Util.extendObj(this.dependencies, opList.dependencies);
+            for (var i = 0, ii = opList.length; i < ii; i++) {
+              this.addOp(opList.fnArray[i], opList.argsArray[i]);
+            }
+          },
+          getIR: function () {
+            return {
+              fnArray: this.fnArray,
+              argsArray: this.argsArray,
+              length: this.length
+            };
+          },
+          flush: function (lastChunk) {
+            if (this.intent !== 'oplist') {
+              new QueueOptimizer().optimize(this);
+            }
+            var transfers = getTransfers(this);
+            var length = this.length;
+            this._totalLength += length;
+            this.messageHandler.send('RenderPageChunk', {
+              operatorList: {
+                fnArray: this.fnArray,
+                argsArray: this.argsArray,
+                lastChunk: lastChunk,
+                length: length
+              },
+              pageIndex: this.pageIndex,
+              intent: this.intent
+            }, transfers);
+            this.dependencies = Object.create(null);
+            this.fnArray.length = 0;
+            this.argsArray.length = 0;
+          }
+        };
+        return OperatorList;
+      }();
+      var StateManager = function StateManagerClosure() {
+        function StateManager(initialState) {
+          this.state = initialState;
+          this.stateStack = [];
+        }
+        StateManager.prototype = {
+          save: function () {
+            var old = this.state;
+            this.stateStack.push(this.state);
+            this.state = old.clone();
+          },
+          restore: function () {
+            var prev = this.stateStack.pop();
+            if (prev) {
+              this.state = prev;
+            }
+          },
+          transform: function (args) {
+            this.state.ctm = Util.transform(this.state.ctm, args);
+          }
+        };
+        return StateManager;
+      }();
+      var TextState = function TextStateClosure() {
+        function TextState() {
+          this.ctm = new Float32Array(IDENTITY_MATRIX);
+          this.fontName = null;
+          this.fontSize = 0;
+          this.font = null;
+          this.fontMatrix = FONT_IDENTITY_MATRIX;
+          this.textMatrix = IDENTITY_MATRIX.slice();
+          this.textLineMatrix = IDENTITY_MATRIX.slice();
+          this.charSpacing = 0;
+          this.wordSpacing = 0;
+          this.leading = 0;
+          this.textHScale = 1;
+          this.textRise = 0;
+        }
+        TextState.prototype = {
+          setTextMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) {
+            var m = this.textMatrix;
+            m[0] = a;
+            m[1] = b;
+            m[2] = c;
+            m[3] = d;
+            m[4] = e;
+            m[5] = f;
+          },
+          setTextLineMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) {
+            var m = this.textLineMatrix;
+            m[0] = a;
+            m[1] = b;
+            m[2] = c;
+            m[3] = d;
+            m[4] = e;
+            m[5] = f;
+          },
+          translateTextMatrix: function TextState_translateTextMatrix(x, y) {
+            var m = this.textMatrix;
+            m[4] = m[0] * x + m[2] * y + m[4];
+            m[5] = m[1] * x + m[3] * y + m[5];
+          },
+          translateTextLineMatrix: function TextState_translateTextMatrix(x, y) {
+            var m = this.textLineMatrix;
+            m[4] = m[0] * x + m[2] * y + m[4];
+            m[5] = m[1] * x + m[3] * y + m[5];
+          },
+          calcTextLineMatrixAdvance: function TextState_calcTextLineMatrixAdvance(a, b, c, d, e, f) {
+            var font = this.font;
+            if (!font) {
+              return null;
+            }
+            var m = this.textLineMatrix;
+            if (!(a === m[0] && b === m[1] && c === m[2] && d === m[3])) {
+              return null;
+            }
+            var txDiff = e - m[4], tyDiff = f - m[5];
+            if (font.vertical && txDiff !== 0 || !font.vertical && tyDiff !== 0) {
+              return null;
+            }
+            var tx, ty, denominator = a * d - b * c;
+            if (font.vertical) {
+              tx = -tyDiff * c / denominator;
+              ty = tyDiff * a / denominator;
+            } else {
+              tx = txDiff * d / denominator;
+              ty = -txDiff * b / denominator;
+            }
+            return {
+              width: tx,
+              height: ty,
+              value: font.vertical ? ty : tx
+            };
+          },
+          calcRenderMatrix: function TextState_calcRendeMatrix(ctm) {
+            // 9.4.4 Text Space Details
+            var tsm = [
+              this.fontSize * this.textHScale,
+              0,
+              0,
+              this.fontSize,
+              0,
+              this.textRise
+            ];
+            return Util.transform(ctm, Util.transform(this.textMatrix, tsm));
+          },
+          carriageReturn: function TextState_carriageReturn() {
+            this.translateTextLineMatrix(0, -this.leading);
+            this.textMatrix = this.textLineMatrix.slice();
+          },
+          clone: function TextState_clone() {
+            var clone = Object.create(this);
+            clone.textMatrix = this.textMatrix.slice();
+            clone.textLineMatrix = this.textLineMatrix.slice();
+            clone.fontMatrix = this.fontMatrix.slice();
+            return clone;
+          }
+        };
+        return TextState;
+      }();
+      var EvalState = function EvalStateClosure() {
+        function EvalState() {
+          this.ctm = new Float32Array(IDENTITY_MATRIX);
+          this.font = null;
+          this.textRenderingMode = TextRenderingMode.FILL;
+          this.fillColorSpace = ColorSpace.singletons.gray;
+          this.strokeColorSpace = ColorSpace.singletons.gray;
+        }
+        EvalState.prototype = {
+          clone: function CanvasExtraState_clone() {
+            return Object.create(this);
+          }
+        };
+        return EvalState;
+      }();
+      var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
+        // Specifies properties for each command
+        //
+        // If variableArgs === true: [0, `numArgs`] expected
+        // If variableArgs === false: exactly `numArgs` expected
+        var getOPMap = getLookupTableFactory(function (t) {
+          // Graphic state
+          t['w'] = {
+            id: OPS.setLineWidth,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['J'] = {
+            id: OPS.setLineCap,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['j'] = {
+            id: OPS.setLineJoin,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['M'] = {
+            id: OPS.setMiterLimit,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['d'] = {
+            id: OPS.setDash,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['ri'] = {
+            id: OPS.setRenderingIntent,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['i'] = {
+            id: OPS.setFlatness,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['gs'] = {
+            id: OPS.setGState,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['q'] = {
+            id: OPS.save,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['Q'] = {
+            id: OPS.restore,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['cm'] = {
+            id: OPS.transform,
+            numArgs: 6,
+            variableArgs: false
+          };
+          // Path
+          t['m'] = {
+            id: OPS.moveTo,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['l'] = {
+            id: OPS.lineTo,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['c'] = {
+            id: OPS.curveTo,
+            numArgs: 6,
+            variableArgs: false
+          };
+          t['v'] = {
+            id: OPS.curveTo2,
+            numArgs: 4,
+            variableArgs: false
+          };
+          t['y'] = {
+            id: OPS.curveTo3,
+            numArgs: 4,
+            variableArgs: false
+          };
+          t['h'] = {
+            id: OPS.closePath,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['re'] = {
+            id: OPS.rectangle,
+            numArgs: 4,
+            variableArgs: false
+          };
+          t['S'] = {
+            id: OPS.stroke,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['s'] = {
+            id: OPS.closeStroke,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['f'] = {
+            id: OPS.fill,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['F'] = {
+            id: OPS.fill,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['f*'] = {
+            id: OPS.eoFill,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['B'] = {
+            id: OPS.fillStroke,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['B*'] = {
+            id: OPS.eoFillStroke,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['b'] = {
+            id: OPS.closeFillStroke,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['b*'] = {
+            id: OPS.closeEOFillStroke,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['n'] = {
+            id: OPS.endPath,
+            numArgs: 0,
+            variableArgs: false
+          };
+          // Clipping
+          t['W'] = {
+            id: OPS.clip,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['W*'] = {
+            id: OPS.eoClip,
+            numArgs: 0,
+            variableArgs: false
+          };
+          // Text
+          t['BT'] = {
+            id: OPS.beginText,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['ET'] = {
+            id: OPS.endText,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['Tc'] = {
+            id: OPS.setCharSpacing,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['Tw'] = {
+            id: OPS.setWordSpacing,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['Tz'] = {
+            id: OPS.setHScale,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['TL'] = {
+            id: OPS.setLeading,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['Tf'] = {
+            id: OPS.setFont,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['Tr'] = {
+            id: OPS.setTextRenderingMode,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['Ts'] = {
+            id: OPS.setTextRise,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['Td'] = {
+            id: OPS.moveText,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['TD'] = {
+            id: OPS.setLeadingMoveText,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['Tm'] = {
+            id: OPS.setTextMatrix,
+            numArgs: 6,
+            variableArgs: false
+          };
+          t['T*'] = {
+            id: OPS.nextLine,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['Tj'] = {
+            id: OPS.showText,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['TJ'] = {
+            id: OPS.showSpacedText,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['\''] = {
+            id: OPS.nextLineShowText,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['"'] = {
+            id: OPS.nextLineSetSpacingShowText,
+            numArgs: 3,
+            variableArgs: false
+          };
+          // Type3 fonts
+          t['d0'] = {
+            id: OPS.setCharWidth,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['d1'] = {
+            id: OPS.setCharWidthAndBounds,
+            numArgs: 6,
+            variableArgs: false
+          };
+          // Color
+          t['CS'] = {
+            id: OPS.setStrokeColorSpace,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['cs'] = {
+            id: OPS.setFillColorSpace,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['SC'] = {
+            id: OPS.setStrokeColor,
+            numArgs: 4,
+            variableArgs: true
+          };
+          t['SCN'] = {
+            id: OPS.setStrokeColorN,
+            numArgs: 33,
+            variableArgs: true
+          };
+          t['sc'] = {
+            id: OPS.setFillColor,
+            numArgs: 4,
+            variableArgs: true
+          };
+          t['scn'] = {
+            id: OPS.setFillColorN,
+            numArgs: 33,
+            variableArgs: true
+          };
+          t['G'] = {
+            id: OPS.setStrokeGray,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['g'] = {
+            id: OPS.setFillGray,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['RG'] = {
+            id: OPS.setStrokeRGBColor,
+            numArgs: 3,
+            variableArgs: false
+          };
+          t['rg'] = {
+            id: OPS.setFillRGBColor,
+            numArgs: 3,
+            variableArgs: false
+          };
+          t['K'] = {
+            id: OPS.setStrokeCMYKColor,
+            numArgs: 4,
+            variableArgs: false
+          };
+          t['k'] = {
+            id: OPS.setFillCMYKColor,
+            numArgs: 4,
+            variableArgs: false
+          };
+          // Shading
+          t['sh'] = {
+            id: OPS.shadingFill,
+            numArgs: 1,
+            variableArgs: false
+          };
+          // Images
+          t['BI'] = {
+            id: OPS.beginInlineImage,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['ID'] = {
+            id: OPS.beginImageData,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['EI'] = {
+            id: OPS.endInlineImage,
+            numArgs: 1,
+            variableArgs: false
+          };
+          // XObjects
+          t['Do'] = {
+            id: OPS.paintXObject,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['MP'] = {
+            id: OPS.markPoint,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['DP'] = {
+            id: OPS.markPointProps,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['BMC'] = {
+            id: OPS.beginMarkedContent,
+            numArgs: 1,
+            variableArgs: false
+          };
+          t['BDC'] = {
+            id: OPS.beginMarkedContentProps,
+            numArgs: 2,
+            variableArgs: false
+          };
+          t['EMC'] = {
+            id: OPS.endMarkedContent,
+            numArgs: 0,
+            variableArgs: false
+          };
+          // Compatibility
+          t['BX'] = {
+            id: OPS.beginCompat,
+            numArgs: 0,
+            variableArgs: false
+          };
+          t['EX'] = {
+            id: OPS.endCompat,
+            numArgs: 0,
+            variableArgs: false
+          };
+          // (reserved partial commands for the lexer)
+          t['BM'] = null;
+          t['BD'] = null;
+          t['true'] = null;
+          t['fa'] = null;
+          t['fal'] = null;
+          t['fals'] = null;
+          t['false'] = null;
+          t['nu'] = null;
+          t['nul'] = null;
+          t['null'] = null;
+        });
+        function EvaluatorPreprocessor(stream, xref, stateManager) {
+          this.opMap = getOPMap();
+          // TODO(mduan): pass array of knownCommands rather than this.opMap
+          // dictionary
+          this.parser = new Parser(new Lexer(stream, this.opMap), false, xref);
+          this.stateManager = stateManager;
+          this.nonProcessedArgs = [];
+        }
+        EvaluatorPreprocessor.prototype = {
+          get savedStatesDepth() {
+            return this.stateManager.stateStack.length;
+          },
+          // |operation| is an object with two fields:
+          //
+          // - |fn| is an out param.
+          //
+          // - |args| is an inout param. On entry, it should have one of two values.
+          //
+          //   - An empty array. This indicates that the caller is providing the
+          //     array in which the args will be stored in. The caller should use
+          //     this value if it can reuse a single array for each call to read().
+          //
+          //   - |null|. This indicates that the caller needs this function to create
+          //     the array in which any args are stored in. If there are zero args,
+          //     this function will leave |operation.args| as |null| (thus avoiding
+          //     allocations that would occur if we used an empty array to represent
+          //     zero arguments). Otherwise, it will replace |null| with a new array
+          //     containing the arguments. The caller should use this value if it
+          //     cannot reuse an array for each call to read().
+          //
+          // These two modes are present because this function is very hot and so
+          // avoiding allocations where possible is worthwhile.
+          //
+          read: function EvaluatorPreprocessor_read(operation) {
+            var args = operation.args;
+            while (true) {
+              var obj = this.parser.getObj();
+              if (isCmd(obj)) {
+                var cmd = obj.cmd;
+                // Check that the command is valid
+                var opSpec = this.opMap[cmd];
+                if (!opSpec) {
+                  warn('Unknown command "' + cmd + '"');
+                  continue;
+                }
+                var fn = opSpec.id;
+                var numArgs = opSpec.numArgs;
+                var argsLength = args !== null ? args.length : 0;
+                if (!opSpec.variableArgs) {
+                  // Postscript commands can be nested, e.g. /F2 /GS2 gs 5.711 Tf
+                  if (argsLength !== numArgs) {
+                    var nonProcessedArgs = this.nonProcessedArgs;
+                    while (argsLength > numArgs) {
+                      nonProcessedArgs.push(args.shift());
+                      argsLength--;
+                    }
+                    while (argsLength < numArgs && nonProcessedArgs.length !== 0) {
+                      if (!args) {
+                        args = [];
+                      }
+                      args.unshift(nonProcessedArgs.pop());
+                      argsLength++;
+                    }
+                  }
+                  if (argsLength < numArgs) {
+                    // If we receive too few args, it's not possible to possible
+                    // to execute the command, so skip the command
+                    info('Command ' + fn + ': because expected ' + numArgs + ' args, but received ' + argsLength + ' args; skipping');
+                    args = null;
+                    continue;
+                  }
+                } else if (argsLength > numArgs) {
+                  info('Command ' + fn + ': expected [0,' + numArgs + '] args, but received ' + argsLength + ' args');
+                }
+                // TODO figure out how to type-check vararg functions
+                this.preprocessCommand(fn, args);
+                operation.fn = fn;
+                operation.args = args;
+                return true;
+              } else {
+                if (isEOF(obj)) {
+                  return false;
+                }
+                // no more commands
+                // argument
+                if (obj !== null) {
+                  if (!args) {
+                    args = [];
+                  }
+                  args.push(obj);
+                  assert(args.length <= 33, 'Too many arguments');
+                }
+              }
+            }
+          },
+          preprocessCommand: function EvaluatorPreprocessor_preprocessCommand(fn, args) {
+            switch (fn | 0) {
+            case OPS.save:
+              this.stateManager.save();
+              break;
+            case OPS.restore:
+              this.stateManager.restore();
+              break;
+            case OPS.transform:
+              this.stateManager.transform(args);
+              break;
+            }
+          }
+        };
+        return EvaluatorPreprocessor;
+      }();
+      var QueueOptimizer = function QueueOptimizerClosure() {
+        function addState(parentState, pattern, fn) {
+          var state = parentState;
+          for (var i = 0, ii = pattern.length - 1; i < ii; i++) {
+            var item = pattern[i];
+            state = state[item] || (state[item] = []);
+          }
+          state[pattern[pattern.length - 1]] = fn;
+        }
+        function handlePaintSolidColorImageMask(iFirstSave, count, fnArray, argsArray) {
+          // Handles special case of mainly LaTeX documents which use image masks to
+          // draw lines with the current fill style.
+          // 'count' groups of (save, transform, paintImageMaskXObject, restore)+
+          // have been found at iFirstSave.
+          var iFirstPIMXO = iFirstSave + 2;
+          for (var i = 0; i < count; i++) {
+            var arg = argsArray[iFirstPIMXO + 4 * i];
+            var imageMask = arg.length === 1 && arg[0];
+            if (imageMask && imageMask.width === 1 && imageMask.height === 1 && (!imageMask.data.length || imageMask.data.length === 1 && imageMask.data[0] === 0)) {
+              fnArray[iFirstPIMXO + 4 * i] = OPS.paintSolidColorImageMask;
+              continue;
+            }
+            break;
+          }
+          return count - i;
+        }
+        var InitialState = [];
+        // This replaces (save, transform, paintInlineImageXObject, restore)+
+        // sequences with one |paintInlineImageXObjectGroup| operation.
+        addState(InitialState, [
+          OPS.save,
+          OPS.transform,
+          OPS.paintInlineImageXObject,
+          OPS.restore
+        ], function foundInlineImageGroup(context) {
+          var MIN_IMAGES_IN_INLINE_IMAGES_BLOCK = 10;
+          var MAX_IMAGES_IN_INLINE_IMAGES_BLOCK = 200;
+          var MAX_WIDTH = 1000;
+          var IMAGE_PADDING = 1;
+          var fnArray = context.fnArray, argsArray = context.argsArray;
+          var curr = context.iCurr;
+          var iFirstSave = curr - 3;
+          var iFirstTransform = curr - 2;
+          var iFirstPIIXO = curr - 1;
+          // Look for the quartets.
+          var i = iFirstSave + 4;
+          var ii = fnArray.length;
+          while (i + 3 < ii) {
+            if (fnArray[i] !== OPS.save || fnArray[i + 1] !== OPS.transform || fnArray[i + 2] !== OPS.paintInlineImageXObject || fnArray[i + 3] !== OPS.restore) {
+              break;
+            }
+            // ops don't match
+            i += 4;
+          }
+          // At this point, i is the index of the first op past the last valid
+          // quartet.
+          var count = Math.min((i - iFirstSave) / 4, MAX_IMAGES_IN_INLINE_IMAGES_BLOCK);
+          if (count < MIN_IMAGES_IN_INLINE_IMAGES_BLOCK) {
+            return i;
+          }
+          // assuming that heights of those image is too small (~1 pixel)
+          // packing as much as possible by lines
+          var maxX = 0;
+          var map = [], maxLineHeight = 0;
+          var currentX = IMAGE_PADDING, currentY = IMAGE_PADDING;
+          var q;
+          for (q = 0; q < count; q++) {
+            var transform = argsArray[iFirstTransform + (q << 2)];
+            var img = argsArray[iFirstPIIXO + (q << 2)][0];
+            if (currentX + img.width > MAX_WIDTH) {
+              // starting new line
+              maxX = Math.max(maxX, currentX);
+              currentY += maxLineHeight + 2 * IMAGE_PADDING;
+              currentX = 0;
+              maxLineHeight = 0;
+            }
+            map.push({
+              transform: transform,
+              x: currentX,
+              y: currentY,
+              w: img.width,
+              h: img.height
+            });
+            currentX += img.width + 2 * IMAGE_PADDING;
+            maxLineHeight = Math.max(maxLineHeight, img.height);
+          }
+          var imgWidth = Math.max(maxX, currentX) + IMAGE_PADDING;
+          var imgHeight = currentY + maxLineHeight + IMAGE_PADDING;
+          var imgData = new Uint8Array(imgWidth * imgHeight * 4);
+          var imgRowSize = imgWidth << 2;
+          for (q = 0; q < count; q++) {
+            var data = argsArray[iFirstPIIXO + (q << 2)][0].data;
+            // Copy image by lines and extends pixels into padding.
+            var rowSize = map[q].w << 2;
+            var dataOffset = 0;
+            var offset = map[q].x + map[q].y * imgWidth << 2;
+            imgData.set(data.subarray(0, rowSize), offset - imgRowSize);
+            for (var k = 0, kk = map[q].h; k < kk; k++) {
+              imgData.set(data.subarray(dataOffset, dataOffset + rowSize), offset);
+              dataOffset += rowSize;
+              offset += imgRowSize;
+            }
+            imgData.set(data.subarray(dataOffset - rowSize, dataOffset), offset);
+            while (offset >= 0) {
+              data[offset - 4] = data[offset];
+              data[offset - 3] = data[offset + 1];
+              data[offset - 2] = data[offset + 2];
+              data[offset - 1] = data[offset + 3];
+              data[offset + rowSize] = data[offset + rowSize - 4];
+              data[offset + rowSize + 1] = data[offset + rowSize - 3];
+              data[offset + rowSize + 2] = data[offset + rowSize - 2];
+              data[offset + rowSize + 3] = data[offset + rowSize - 1];
+              offset -= imgRowSize;
+            }
+          }
+          // Replace queue items.
+          fnArray.splice(iFirstSave, count * 4, OPS.paintInlineImageXObjectGroup);
+          argsArray.splice(iFirstSave, count * 4, [
+            {
+              width: imgWidth,
+              height: imgHeight,
+              kind: ImageKind.RGBA_32BPP,
+              data: imgData
+            },
+            map
+          ]);
+          return iFirstSave + 1;
+        });
+        // This replaces (save, transform, paintImageMaskXObject, restore)+
+        // sequences with one |paintImageMaskXObjectGroup| or one
+        // |paintImageMaskXObjectRepeat| operation.
+        addState(InitialState, [
+          OPS.save,
+          OPS.transform,
+          OPS.paintImageMaskXObject,
+          OPS.restore
+        ], function foundImageMaskGroup(context) {
+          var MIN_IMAGES_IN_MASKS_BLOCK = 10;
+          var MAX_IMAGES_IN_MASKS_BLOCK = 100;
+          var MAX_SAME_IMAGES_IN_MASKS_BLOCK = 1000;
+          var fnArray = context.fnArray, argsArray = context.argsArray;
+          var curr = context.iCurr;
+          var iFirstSave = curr - 3;
+          var iFirstTransform = curr - 2;
+          var iFirstPIMXO = curr - 1;
+          // Look for the quartets.
+          var i = iFirstSave + 4;
+          var ii = fnArray.length;
+          while (i + 3 < ii) {
+            if (fnArray[i] !== OPS.save || fnArray[i + 1] !== OPS.transform || fnArray[i + 2] !== OPS.paintImageMaskXObject || fnArray[i + 3] !== OPS.restore) {
+              break;
+            }
+            // ops don't match
+            i += 4;
+          }
+          // At this point, i is the index of the first op past the last valid
+          // quartet.
+          var count = (i - iFirstSave) / 4;
+          count = handlePaintSolidColorImageMask(iFirstSave, count, fnArray, argsArray);
+          if (count < MIN_IMAGES_IN_MASKS_BLOCK) {
+            return i;
+          }
+          var q;
+          var isSameImage = false;
+          var iTransform, transformArgs;
+          var firstPIMXOArg0 = argsArray[iFirstPIMXO][0];
+          if (argsArray[iFirstTransform][1] === 0 && argsArray[iFirstTransform][2] === 0) {
+            isSameImage = true;
+            var firstTransformArg0 = argsArray[iFirstTransform][0];
+            var firstTransformArg3 = argsArray[iFirstTransform][3];
+            iTransform = iFirstTransform + 4;
+            var iPIMXO = iFirstPIMXO + 4;
+            for (q = 1; q < count; q++, iTransform += 4, iPIMXO += 4) {
+              transformArgs = argsArray[iTransform];
+              if (argsArray[iPIMXO][0] !== firstPIMXOArg0 || transformArgs[0] !== firstTransformArg0 || transformArgs[1] !== 0 || transformArgs[2] !== 0 || transformArgs[3] !== firstTransformArg3) {
+                if (q < MIN_IMAGES_IN_MASKS_BLOCK) {
+                  isSameImage = false;
+                } else {
+                  count = q;
+                }
+                break;
+              }
+            }
+          }
+          // different image or transform
+          if (isSameImage) {
+            count = Math.min(count, MAX_SAME_IMAGES_IN_MASKS_BLOCK);
+            var positions = new Float32Array(count * 2);
+            iTransform = iFirstTransform;
+            for (q = 0; q < count; q++, iTransform += 4) {
+              transformArgs = argsArray[iTransform];
+              positions[q << 1] = transformArgs[4];
+              positions[(q << 1) + 1] = transformArgs[5];
+            }
+            // Replace queue items.
+            fnArray.splice(iFirstSave, count * 4, OPS.paintImageMaskXObjectRepeat);
+            argsArray.splice(iFirstSave, count * 4, [
+              firstPIMXOArg0,
+              firstTransformArg0,
+              firstTransformArg3,
+              positions
+            ]);
+          } else {
+            count = Math.min(count, MAX_IMAGES_IN_MASKS_BLOCK);
+            var images = [];
+            for (q = 0; q < count; q++) {
+              transformArgs = argsArray[iFirstTransform + (q << 2)];
+              var maskParams = argsArray[iFirstPIMXO + (q << 2)][0];
+              images.push({
+                data: maskParams.data,
+                width: maskParams.width,
+                height: maskParams.height,
+                transform: transformArgs
+              });
+            }
+            // Replace queue items.
+            fnArray.splice(iFirstSave, count * 4, OPS.paintImageMaskXObjectGroup);
+            argsArray.splice(iFirstSave, count * 4, [images]);
+          }
+          return iFirstSave + 1;
+        });
+        // This replaces (save, transform, paintImageXObject, restore)+ sequences
+        // with one paintImageXObjectRepeat operation, if the |transform| and
+        // |paintImageXObjectRepeat| ops are appropriate.
+        addState(InitialState, [
+          OPS.save,
+          OPS.transform,
+          OPS.paintImageXObject,
+          OPS.restore
+        ], function (context) {
+          var MIN_IMAGES_IN_BLOCK = 3;
+          var MAX_IMAGES_IN_BLOCK = 1000;
+          var fnArray = context.fnArray, argsArray = context.argsArray;
+          var curr = context.iCurr;
+          var iFirstSave = curr - 3;
+          var iFirstTransform = curr - 2;
+          var iFirstPIXO = curr - 1;
+          var iFirstRestore = curr;
+          if (argsArray[iFirstTransform][1] !== 0 || argsArray[iFirstTransform][2] !== 0) {
+            return iFirstRestore + 1;
+          }
+          // transform has the wrong form
+          // Look for the quartets.
+          var firstPIXOArg0 = argsArray[iFirstPIXO][0];
+          var firstTransformArg0 = argsArray[iFirstTransform][0];
+          var firstTransformArg3 = argsArray[iFirstTransform][3];
+          var i = iFirstSave + 4;
+          var ii = fnArray.length;
+          while (i + 3 < ii) {
+            if (fnArray[i] !== OPS.save || fnArray[i + 1] !== OPS.transform || fnArray[i + 2] !== OPS.paintImageXObject || fnArray[i + 3] !== OPS.restore) {
+              break;
+            }
+            // ops don't match
+            if (argsArray[i + 1][0] !== firstTransformArg0 || argsArray[i + 1][1] !== 0 || argsArray[i + 1][2] !== 0 || argsArray[i + 1][3] !== firstTransformArg3) {
+              break;
+            }
+            // transforms don't match
+            if (argsArray[i + 2][0] !== firstPIXOArg0) {
+              break;
+            }
+            // images don't match
+            i += 4;
+          }
+          // At this point, i is the index of the first op past the last valid
+          // quartet.
+          var count = Math.min((i - iFirstSave) / 4, MAX_IMAGES_IN_BLOCK);
+          if (count < MIN_IMAGES_IN_BLOCK) {
+            return i;
+          }
+          // Extract the (x,y) positions from all of the matching transforms.
+          var positions = new Float32Array(count * 2);
+          var iTransform = iFirstTransform;
+          for (var q = 0; q < count; q++, iTransform += 4) {
+            var transformArgs = argsArray[iTransform];
+            positions[q << 1] = transformArgs[4];
+            positions[(q << 1) + 1] = transformArgs[5];
+          }
+          // Replace queue items.
+          var args = [
+            firstPIXOArg0,
+            firstTransformArg0,
+            firstTransformArg3,
+            positions
+          ];
+          fnArray.splice(iFirstSave, count * 4, OPS.paintImageXObjectRepeat);
+          argsArray.splice(iFirstSave, count * 4, args);
+          return iFirstSave + 1;
+        });
+        // This replaces (beginText, setFont, setTextMatrix, showText, endText)+
+        // sequences with (beginText, setFont, (setTextMatrix, showText)+, endText)+
+        // sequences, if the font for each one is the same.
+        addState(InitialState, [
+          OPS.beginText,
+          OPS.setFont,
+          OPS.setTextMatrix,
+          OPS.showText,
+          OPS.endText
+        ], function (context) {
+          var MIN_CHARS_IN_BLOCK = 3;
+          var MAX_CHARS_IN_BLOCK = 1000;
+          var fnArray = context.fnArray, argsArray = context.argsArray;
+          var curr = context.iCurr;
+          var iFirstBeginText = curr - 4;
+          var iFirstSetFont = curr - 3;
+          var iFirstSetTextMatrix = curr - 2;
+          var iFirstShowText = curr - 1;
+          var iFirstEndText = curr;
+          // Look for the quintets.
+          var firstSetFontArg0 = argsArray[iFirstSetFont][0];
+          var firstSetFontArg1 = argsArray[iFirstSetFont][1];
+          var i = iFirstBeginText + 5;
+          var ii = fnArray.length;
+          while (i + 4 < ii) {
+            if (fnArray[i] !== OPS.beginText || fnArray[i + 1] !== OPS.setFont || fnArray[i + 2] !== OPS.setTextMatrix || fnArray[i + 3] !== OPS.showText || fnArray[i + 4] !== OPS.endText) {
+              break;
+            }
+            // ops don't match
+            if (argsArray[i + 1][0] !== firstSetFontArg0 || argsArray[i + 1][1] !== firstSetFontArg1) {
+              break;
+            }
+            // fonts don't match
+            i += 5;
+          }
+          // At this point, i is the index of the first op past the last valid
+          // quintet.
+          var count = Math.min((i - iFirstBeginText) / 5, MAX_CHARS_IN_BLOCK);
+          if (count < MIN_CHARS_IN_BLOCK) {
+            return i;
+          }
+          // If the preceding quintet is (<something>, setFont, setTextMatrix,
+          // showText, endText), include that as well. (E.g. <something> might be
+          // |dependency|.)
+          var iFirst = iFirstBeginText;
+          if (iFirstBeginText >= 4 && fnArray[iFirstBeginText - 4] === fnArray[iFirstSetFont] && fnArray[iFirstBeginText - 3] === fnArray[iFirstSetTextMatrix] && fnArray[iFirstBeginText - 2] === fnArray[iFirstShowText] && fnArray[iFirstBeginText - 1] === fnArray[iFirstEndText] && argsArray[iFirstBeginText - 4][0] === firstSetFontArg0 && argsArray[iFirstBeginText - 4][1] === firstSetFontArg1) {
+            count++;
+            iFirst -= 5;
+          }
+          // Remove (endText, beginText, setFont) trios.
+          var iEndText = iFirst + 4;
+          for (var q = 1; q < count; q++) {
+            fnArray.splice(iEndText, 3);
+            argsArray.splice(iEndText, 3);
+            iEndText += 2;
+          }
+          return iEndText + 1;
+        });
+        function QueueOptimizer() {
+        }
+        QueueOptimizer.prototype = {
+          optimize: function QueueOptimizer_optimize(queue) {
+            var fnArray = queue.fnArray, argsArray = queue.argsArray;
+            var context = {
+              iCurr: 0,
+              fnArray: fnArray,
+              argsArray: argsArray
+            };
+            var state;
+            var i = 0, ii = fnArray.length;
+            while (i < ii) {
+              state = (state || InitialState)[fnArray[i]];
+              if (typeof state === 'function') {
+                // we found some handler
+                context.iCurr = i;
+                // state() returns the index of the first non-matching op (if we
+                // didn't match) or the first op past the modified ops (if we did
+                // match and replace).
+                i = state(context);
+                state = undefined;
+                // reset the state machine
+                ii = context.fnArray.length;
+              } else {
+                i++;
+              }
+            }
+          }
+        };
+        return QueueOptimizer;
+      }();
+      exports.OperatorList = OperatorList;
+      exports.PartialEvaluator = PartialEvaluator;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreAnnotation = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreColorSpace, root.pdfjsCoreObj, root.pdfjsCoreEvaluator);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream, coreColorSpace, coreObj, coreEvaluator) {
+      var AnnotationBorderStyleType = sharedUtil.AnnotationBorderStyleType;
+      var AnnotationFieldFlag = sharedUtil.AnnotationFieldFlag;
+      var AnnotationFlag = sharedUtil.AnnotationFlag;
+      var AnnotationType = sharedUtil.AnnotationType;
+      var OPS = sharedUtil.OPS;
+      var Util = sharedUtil.Util;
+      var isString = sharedUtil.isString;
+      var isArray = sharedUtil.isArray;
+      var isInt = sharedUtil.isInt;
+      var stringToBytes = sharedUtil.stringToBytes;
+      var stringToPDFString = sharedUtil.stringToPDFString;
+      var warn = sharedUtil.warn;
+      var Dict = corePrimitives.Dict;
+      var isDict = corePrimitives.isDict;
+      var isName = corePrimitives.isName;
+      var isRef = corePrimitives.isRef;
+      var Stream = coreStream.Stream;
+      var ColorSpace = coreColorSpace.ColorSpace;
+      var Catalog = coreObj.Catalog;
+      var ObjectLoader = coreObj.ObjectLoader;
+      var FileSpec = coreObj.FileSpec;
+      var OperatorList = coreEvaluator.OperatorList;
+      /**
+       * @class
+       * @alias AnnotationFactory
+       */
+      function AnnotationFactory() {
+      }
+      AnnotationFactory.prototype = /** @lends AnnotationFactory.prototype */
+      {
+        /**
+         * @param {XRef} xref
+         * @param {Object} ref
+         * @param {PDFManager} pdfManager
+         * @param {string} uniquePrefix
+         * @param {Object} idCounters
+         * @returns {Annotation}
+         */
+        create: function AnnotationFactory_create(xref, ref, pdfManager, uniquePrefix, idCounters) {
+          var dict = xref.fetchIfRef(ref);
+          if (!isDict(dict)) {
+            return;
+          }
+          var id = isRef(ref) ? ref.toString() : 'annot_' + (uniquePrefix || '') + ++idCounters.obj;
+          // Determine the annotation's subtype.
+          var subtype = dict.get('Subtype');
+          subtype = isName(subtype) ? subtype.name : null;
+          // Return the right annotation object based on the subtype and field type.
+          var parameters = {
+            xref: xref,
+            dict: dict,
+            ref: isRef(ref) ? ref : null,
+            subtype: subtype,
+            id: id,
+            pdfManager: pdfManager
+          };
+          switch (subtype) {
+          case 'Link':
+            return new LinkAnnotation(parameters);
+          case 'Text':
+            return new TextAnnotation(parameters);
+          case 'Widget':
+            var fieldType = Util.getInheritableProperty(dict, 'FT');
+            fieldType = isName(fieldType) ? fieldType.name : null;
+            switch (fieldType) {
+            case 'Tx':
+              return new TextWidgetAnnotation(parameters);
+            case 'Ch':
+              return new ChoiceWidgetAnnotation(parameters);
+            }
+            warn('Unimplemented widget field type "' + fieldType + '", ' + 'falling back to base field type.');
+            return new WidgetAnnotation(parameters);
+          case 'Popup':
+            return new PopupAnnotation(parameters);
+          case 'Highlight':
+            return new HighlightAnnotation(parameters);
+          case 'Underline':
+            return new UnderlineAnnotation(parameters);
+          case 'Squiggly':
+            return new SquigglyAnnotation(parameters);
+          case 'StrikeOut':
+            return new StrikeOutAnnotation(parameters);
+          case 'FileAttachment':
+            return new FileAttachmentAnnotation(parameters);
+          default:
+            if (!subtype) {
+              warn('Annotation is missing the required /Subtype.');
+            } else {
+              warn('Unimplemented annotation type "' + subtype + '", ' + 'falling back to base annotation.');
+            }
+            return new Annotation(parameters);
+          }
+        }
+      };
+      var Annotation = function AnnotationClosure() {
+        // 12.5.5: Algorithm: Appearance streams
+        function getTransformMatrix(rect, bbox, matrix) {
+          var bounds = Util.getAxialAlignedBoundingBox(bbox, matrix);
+          var minX = bounds[0];
+          var minY = bounds[1];
+          var maxX = bounds[2];
+          var maxY = bounds[3];
+          if (minX === maxX || minY === maxY) {
+            // From real-life file, bbox was [0, 0, 0, 0]. In this case,
+            // just apply the transform for rect
+            return [
+              1,
+              0,
+              0,
+              1,
+              rect[0],
+              rect[1]
+            ];
+          }
+          var xRatio = (rect[2] - rect[0]) / (maxX - minX);
+          var yRatio = (rect[3] - rect[1]) / (maxY - minY);
+          return [
+            xRatio,
+            0,
+            0,
+            yRatio,
+            rect[0] - minX * xRatio,
+            rect[1] - minY * yRatio
+          ];
+        }
+        function getDefaultAppearance(dict) {
+          var appearanceState = dict.get('AP');
+          if (!isDict(appearanceState)) {
+            return;
+          }
+          var appearance;
+          var appearances = appearanceState.get('N');
+          if (isDict(appearances)) {
+            var as = dict.get('AS');
+            if (as && appearances.has(as.name)) {
+              appearance = appearances.get(as.name);
+            }
+          } else {
+            appearance = appearances;
+          }
+          return appearance;
+        }
+        function Annotation(params) {
+          var dict = params.dict;
+          this.setFlags(dict.get('F'));
+          this.setRectangle(dict.getArray('Rect'));
+          this.setColor(dict.getArray('C'));
+          this.setBorderStyle(dict);
+          this.appearance = getDefaultAppearance(dict);
+          // Expose public properties using a data object.
+          this.data = {};
+          this.data.id = params.id;
+          this.data.subtype = params.subtype;
+          this.data.annotationFlags = this.flags;
+          this.data.rect = this.rectangle;
+          this.data.color = this.color;
+          this.data.borderStyle = this.borderStyle;
+          this.data.hasAppearance = !!this.appearance;
+        }
+        Annotation.prototype = {
+          /**
+           * @private
+           */
+          _hasFlag: function Annotation_hasFlag(flags, flag) {
+            return !!(flags & flag);
+          },
+          /**
+           * @private
+           */
+          _isViewable: function Annotation_isViewable(flags) {
+            return !this._hasFlag(flags, AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, AnnotationFlag.HIDDEN) && !this._hasFlag(flags, AnnotationFlag.NOVIEW);
+          },
+          /**
+           * @private
+           */
+          _isPrintable: function AnnotationFlag_isPrintable(flags) {
+            return this._hasFlag(flags, AnnotationFlag.PRINT) && !this._hasFlag(flags, AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, AnnotationFlag.HIDDEN);
+          },
+          /**
+           * @return {boolean}
+           */
+          get viewable() {
+            if (this.flags === 0) {
+              return true;
+            }
+            return this._isViewable(this.flags);
+          },
+          /**
+           * @return {boolean}
+           */
+          get printable() {
+            if (this.flags === 0) {
+              return false;
+            }
+            return this._isPrintable(this.flags);
+          },
+          /**
+           * Set the flags.
+           *
+           * @public
+           * @memberof Annotation
+           * @param {number} flags - Unsigned 32-bit integer specifying annotation
+           *                         characteristics
+           * @see {@link shared/util.js}
+           */
+          setFlags: function Annotation_setFlags(flags) {
+            this.flags = isInt(flags) && flags > 0 ? flags : 0;
+          },
+          /**
+           * Check if a provided flag is set.
+           *
+           * @public
+           * @memberof Annotation
+           * @param {number} flag - Hexadecimal representation for an annotation
+           *                        characteristic
+           * @return {boolean}
+           * @see {@link shared/util.js}
+           */
+          hasFlag: function Annotation_hasFlag(flag) {
+            return this._hasFlag(this.flags, flag);
+          },
+          /**
+           * Set the rectangle.
+           *
+           * @public
+           * @memberof Annotation
+           * @param {Array} rectangle - The rectangle array with exactly four entries
+           */
+          setRectangle: function Annotation_setRectangle(rectangle) {
+            if (isArray(rectangle) && rectangle.length === 4) {
+              this.rectangle = Util.normalizeRect(rectangle);
+            } else {
+              this.rectangle = [
+                0,
+                0,
+                0,
+                0
+              ];
+            }
+          },
+          /**
+           * Set the color and take care of color space conversion.
+           *
+           * @public
+           * @memberof Annotation
+           * @param {Array} color - The color array containing either 0
+           *                        (transparent), 1 (grayscale), 3 (RGB) or
+           *                        4 (CMYK) elements
+           */
+          setColor: function Annotation_setColor(color) {
+            var rgbColor = new Uint8Array(3);
+            // Black in RGB color space (default)
+            if (!isArray(color)) {
+              this.color = rgbColor;
+              return;
+            }
+            switch (color.length) {
+            case 0:
+              // Transparent, which we indicate with a null value
+              this.color = null;
+              break;
+            case 1:
+              // Convert grayscale to RGB
+              ColorSpace.singletons.gray.getRgbItem(color, 0, rgbColor, 0);
+              this.color = rgbColor;
+              break;
+            case 3:
+              // Convert RGB percentages to RGB
+              ColorSpace.singletons.rgb.getRgbItem(color, 0, rgbColor, 0);
+              this.color = rgbColor;
+              break;
+            case 4:
+              // Convert CMYK to RGB
+              ColorSpace.singletons.cmyk.getRgbItem(color, 0, rgbColor, 0);
+              this.color = rgbColor;
+              break;
+            default:
+              this.color = rgbColor;
+              break;
+            }
+          },
+          /**
+           * Set the border style (as AnnotationBorderStyle object).
+           *
+           * @public
+           * @memberof Annotation
+           * @param {Dict} borderStyle - The border style dictionary
+           */
+          setBorderStyle: function Annotation_setBorderStyle(borderStyle) {
+            this.borderStyle = new AnnotationBorderStyle();
+            if (!isDict(borderStyle)) {
+              return;
+            }
+            if (borderStyle.has('BS')) {
+              var dict = borderStyle.get('BS');
+              var dictType = dict.get('Type');
+              if (!dictType || isName(dictType, 'Border')) {
+                this.borderStyle.setWidth(dict.get('W'));
+                this.borderStyle.setStyle(dict.get('S'));
+                this.borderStyle.setDashArray(dict.getArray('D'));
+              }
+            } else if (borderStyle.has('Border')) {
+              var array = borderStyle.getArray('Border');
+              if (isArray(array) && array.length >= 3) {
+                this.borderStyle.setHorizontalCornerRadius(array[0]);
+                this.borderStyle.setVerticalCornerRadius(array[1]);
+                this.borderStyle.setWidth(array[2]);
+                if (array.length === 4) {
+                  // Dash array available
+                  this.borderStyle.setDashArray(array[3]);
+                }
+              }
+            } else {
+              // There are no border entries in the dictionary. According to the
+              // specification, we should draw a solid border of width 1 in that
+              // case, but Adobe Reader did not implement that part of the
+              // specification and instead draws no border at all, so we do the same.
+              // See also https://github.com/mozilla/pdf.js/issues/6179.
+              this.borderStyle.setWidth(0);
+            }
+          },
+          /**
+           * Prepare the annotation for working with a popup in the display layer.
+           *
+           * @private
+           * @memberof Annotation
+           * @param {Dict} dict - The annotation's data dictionary
+           */
+          _preparePopup: function Annotation_preparePopup(dict) {
+            if (!dict.has('C')) {
+              // Fall back to the default background color.
+              this.data.color = null;
+            }
+            this.data.hasPopup = dict.has('Popup');
+            this.data.title = stringToPDFString(dict.get('T') || '');
+            this.data.contents = stringToPDFString(dict.get('Contents') || '');
+          },
+          loadResources: function Annotation_loadResources(keys) {
+            return new Promise(function (resolve, reject) {
+              this.appearance.dict.getAsync('Resources').then(function (resources) {
+                if (!resources) {
+                  resolve();
+                  return;
+                }
+                var objectLoader = new ObjectLoader(resources.map, keys, resources.xref);
+                objectLoader.load().then(function () {
+                  resolve(resources);
+                }, reject);
+              }, reject);
+            }.bind(this));
+          },
+          getOperatorList: function Annotation_getOperatorList(evaluator, task, renderForms) {
+            if (!this.appearance) {
+              return Promise.resolve(new OperatorList());
+            }
+            var data = this.data;
+            var appearanceDict = this.appearance.dict;
+            var resourcesPromise = this.loadResources([
+              'ExtGState',
+              'ColorSpace',
+              'Pattern',
+              'Shading',
+              'XObject',
+              'Font'
+            ]);
+            // ProcSet
+            // Properties
+            var bbox = appearanceDict.getArray('BBox') || [
+              0,
+              0,
+              1,
+              1
+            ];
+            var matrix = appearanceDict.getArray('Matrix') || [
+              1,
+              0,
+              0,
+              1,
+              0,
+              0
+            ];
+            var transform = getTransformMatrix(data.rect, bbox, matrix);
+            var self = this;
+            return resourcesPromise.then(function (resources) {
+              var opList = new OperatorList();
+              opList.addOp(OPS.beginAnnotation, [
+                data.rect,
+                transform,
+                matrix
+              ]);
+              return evaluator.getOperatorList(self.appearance, task, resources, opList).then(function () {
+                opList.addOp(OPS.endAnnotation, []);
+                self.appearance.reset();
+                return opList;
+              });
+            });
+          }
+        };
+        Annotation.appendToOperatorList = function Annotation_appendToOperatorList(annotations, opList, partialEvaluator, task, intent, renderForms) {
+          var annotationPromises = [];
+          for (var i = 0, n = annotations.length; i < n; ++i) {
+            if (intent === 'display' && annotations[i].viewable || intent === 'print' && annotations[i].printable) {
+              annotationPromises.push(annotations[i].getOperatorList(partialEvaluator, task, renderForms));
+            }
+          }
+          return Promise.all(annotationPromises).then(function (operatorLists) {
+            opList.addOp(OPS.beginAnnotations, []);
+            for (var i = 0, n = operatorLists.length; i < n; ++i) {
+              opList.addOpList(operatorLists[i]);
+            }
+            opList.addOp(OPS.endAnnotations, []);
+          });
+        };
+        return Annotation;
+      }();
+      /**
+       * Contains all data regarding an annotation's border style.
+       *
+       * @class
+       */
+      var AnnotationBorderStyle = function AnnotationBorderStyleClosure() {
+        /**
+         * @constructor
+         * @private
+         */
+        function AnnotationBorderStyle() {
+          this.width = 1;
+          this.style = AnnotationBorderStyleType.SOLID;
+          this.dashArray = [3];
+          this.horizontalCornerRadius = 0;
+          this.verticalCornerRadius = 0;
+        }
+        AnnotationBorderStyle.prototype = {
+          /**
+           * Set the width.
+           *
+           * @public
+           * @memberof AnnotationBorderStyle
+           * @param {integer} width - The width
+           */
+          setWidth: function AnnotationBorderStyle_setWidth(width) {
+            if (width === (width | 0)) {
+              this.width = width;
+            }
+          },
+          /**
+           * Set the style.
+           *
+           * @public
+           * @memberof AnnotationBorderStyle
+           * @param {Object} style - The style object
+           * @see {@link shared/util.js}
+           */
+          setStyle: function AnnotationBorderStyle_setStyle(style) {
+            if (!style) {
+              return;
+            }
+            switch (style.name) {
+            case 'S':
+              this.style = AnnotationBorderStyleType.SOLID;
+              break;
+            case 'D':
+              this.style = AnnotationBorderStyleType.DASHED;
+              break;
+            case 'B':
+              this.style = AnnotationBorderStyleType.BEVELED;
+              break;
+            case 'I':
+              this.style = AnnotationBorderStyleType.INSET;
+              break;
+            case 'U':
+              this.style = AnnotationBorderStyleType.UNDERLINE;
+              break;
+            default:
+              break;
+            }
+          },
+          /**
+           * Set the dash array.
+           *
+           * @public
+           * @memberof AnnotationBorderStyle
+           * @param {Array} dashArray - The dash array with at least one element
+           */
+          setDashArray: function AnnotationBorderStyle_setDashArray(dashArray) {
+            // We validate the dash array, but we do not use it because CSS does not
+            // allow us to change spacing of dashes. For more information, visit
+            // http://www.w3.org/TR/css3-background/#the-border-style.
+            if (isArray(dashArray) && dashArray.length > 0) {
+              // According to the PDF specification: the elements in a dashArray
+              // shall be numbers that are nonnegative and not all equal to zero.
+              var isValid = true;
+              var allZeros = true;
+              for (var i = 0, len = dashArray.length; i < len; i++) {
+                var element = dashArray[i];
+                var validNumber = +element >= 0;
+                if (!validNumber) {
+                  isValid = false;
+                  break;
+                } else if (element > 0) {
+                  allZeros = false;
+                }
+              }
+              if (isValid && !allZeros) {
+                this.dashArray = dashArray;
+              } else {
+                this.width = 0;
+              }
+            } else // Adobe behavior when the array is invalid.
+            if (dashArray) {
+              this.width = 0;
+            }
+          },
+          // Adobe behavior when the array is invalid.
+          /**
+           * Set the horizontal corner radius (from a Border dictionary).
+           *
+           * @public
+           * @memberof AnnotationBorderStyle
+           * @param {integer} radius - The horizontal corner radius
+           */
+          setHorizontalCornerRadius: function AnnotationBorderStyle_setHorizontalCornerRadius(radius) {
+            if (radius === (radius | 0)) {
+              this.horizontalCornerRadius = radius;
+            }
+          },
+          /**
+           * Set the vertical corner radius (from a Border dictionary).
+           *
+           * @public
+           * @memberof AnnotationBorderStyle
+           * @param {integer} radius - The vertical corner radius
+           */
+          setVerticalCornerRadius: function AnnotationBorderStyle_setVerticalCornerRadius(radius) {
+            if (radius === (radius | 0)) {
+              this.verticalCornerRadius = radius;
+            }
+          }
+        };
+        return AnnotationBorderStyle;
+      }();
+      var WidgetAnnotation = function WidgetAnnotationClosure() {
+        function WidgetAnnotation(params) {
+          Annotation.call(this, params);
+          var dict = params.dict;
+          var data = this.data;
+          data.annotationType = AnnotationType.WIDGET;
+          data.fieldName = this._constructFieldName(dict);
+          data.fieldValue = Util.getInheritableProperty(dict, 'V', /* getArray = */
+          true);
+          data.alternativeText = stringToPDFString(dict.get('TU') || '');
+          data.defaultAppearance = Util.getInheritableProperty(dict, 'DA') || '';
+          var fieldType = Util.getInheritableProperty(dict, 'FT');
+          data.fieldType = isName(fieldType) ? fieldType.name : null;
+          this.fieldResources = Util.getInheritableProperty(dict, 'DR') || Dict.empty;
+          data.fieldFlags = Util.getInheritableProperty(dict, 'Ff');
+          if (!isInt(data.fieldFlags) || data.fieldFlags < 0) {
+            data.fieldFlags = 0;
+          }
+          data.readOnly = this.hasFieldFlag(AnnotationFieldFlag.READONLY);
+          // Hide signatures because we cannot validate them.
+          if (data.fieldType === 'Sig') {
+            this.setFlags(AnnotationFlag.HIDDEN);
+          }
+        }
+        Util.inherit(WidgetAnnotation, Annotation, {
+          /**
+           * Construct the (fully qualified) field name from the (partial) field
+           * names of the field and its ancestors.
+           *
+           * @private
+           * @memberof WidgetAnnotation
+           * @param {Dict} dict - Complete widget annotation dictionary
+           * @return {string}
+           */
+          _constructFieldName: function WidgetAnnotation_constructFieldName(dict) {
+            // Both the `Parent` and `T` fields are optional. While at least one of
+            // them should be provided, bad PDF generators may fail to do so.
+            if (!dict.has('T') && !dict.has('Parent')) {
+              warn('Unknown field name, falling back to empty field name.');
+              return '';
+            }
+            // If no parent exists, the partial and fully qualified names are equal.
+            if (!dict.has('Parent')) {
+              return stringToPDFString(dict.get('T'));
+            }
+            // Form the fully qualified field name by appending the partial name to
+            // the parent's fully qualified name, separated by a period.
+            var fieldName = [];
+            if (dict.has('T')) {
+              fieldName.unshift(stringToPDFString(dict.get('T')));
+            }
+            var loopDict = dict;
+            while (loopDict.has('Parent')) {
+              loopDict = loopDict.get('Parent');
+              if (loopDict.has('T')) {
+                fieldName.unshift(stringToPDFString(loopDict.get('T')));
+              }
+            }
+            return fieldName.join('.');
+          },
+          /**
+           * Check if a provided field flag is set.
+           *
+           * @public
+           * @memberof WidgetAnnotation
+           * @param {number} flag - Hexadecimal representation for an annotation
+           *                        field characteristic
+           * @return {boolean}
+           * @see {@link shared/util.js}
+           */
+          hasFieldFlag: function WidgetAnnotation_hasFieldFlag(flag) {
+            return !!(this.data.fieldFlags & flag);
+          }
+        });
+        return WidgetAnnotation;
+      }();
+      var TextWidgetAnnotation = function TextWidgetAnnotationClosure() {
+        function TextWidgetAnnotation(params) {
+          WidgetAnnotation.call(this, params);
+          // The field value is always a string.
+          this.data.fieldValue = stringToPDFString(this.data.fieldValue || '');
+          // Determine the alignment of text in the field.
+          var alignment = Util.getInheritableProperty(params.dict, 'Q');
+          if (!isInt(alignment) || alignment < 0 || alignment > 2) {
+            alignment = null;
+          }
+          this.data.textAlignment = alignment;
+          // Determine the maximum length of text in the field.
+          var maximumLength = Util.getInheritableProperty(params.dict, 'MaxLen');
+          if (!isInt(maximumLength) || maximumLength < 0) {
+            maximumLength = null;
+          }
+          this.data.maxLen = maximumLength;
+          // Process field flags for the display layer.
+          this.data.multiLine = this.hasFieldFlag(AnnotationFieldFlag.MULTILINE);
+          this.data.comb = this.hasFieldFlag(AnnotationFieldFlag.COMB) && !this.hasFieldFlag(AnnotationFieldFlag.MULTILINE) && !this.hasFieldFlag(AnnotationFieldFlag.PASSWORD) && !this.hasFieldFlag(AnnotationFieldFlag.FILESELECT) && this.data.maxLen !== null;
+        }
+        Util.inherit(TextWidgetAnnotation, WidgetAnnotation, {
+          getOperatorList: function TextWidgetAnnotation_getOperatorList(evaluator, task, renderForms) {
+            var operatorList = new OperatorList();
+            // Do not render form elements on the canvas when interactive forms are
+            // enabled. The display layer is responsible for rendering them instead.
+            if (renderForms) {
+              return Promise.resolve(operatorList);
+            }
+            if (this.appearance) {
+              return Annotation.prototype.getOperatorList.call(this, evaluator, task, renderForms);
+            }
+            // Even if there is an appearance stream, ignore it. This is the
+            // behaviour used by Adobe Reader.
+            if (!this.data.defaultAppearance) {
+              return Promise.resolve(operatorList);
+            }
+            var stream = new Stream(stringToBytes(this.data.defaultAppearance));
+            return evaluator.getOperatorList(stream, task, this.fieldResources, operatorList).then(function () {
+              return operatorList;
+            });
+          }
+        });
+        return TextWidgetAnnotation;
+      }();
+      var ChoiceWidgetAnnotation = function ChoiceWidgetAnnotationClosure() {
+        function ChoiceWidgetAnnotation(params) {
+          WidgetAnnotation.call(this, params);
+          // Determine the options. The options array may consist of strings or
+          // arrays. If the array consists of arrays, then the first element of
+          // each array is the export value and the second element of each array is
+          // the display value. If the array consists of strings, then these
+          // represent both the export and display value. In this case, we convert
+          // it to an array of arrays as well for convenience in the display layer.
+          this.data.options = [];
+          var options = params.dict.getArray('Opt');
+          if (isArray(options)) {
+            for (var i = 0, ii = options.length; i < ii; i++) {
+              var option = options[i];
+              this.data.options[i] = {
+                exportValue: isArray(option) ? option[0] : option,
+                displayValue: isArray(option) ? option[1] : option
+              };
+            }
+          }
+          // Determine the field value. In this case, it may be a string or an
+          // array of strings. For convenience in the display layer, convert the
+          // string to an array of one string as well.
+          if (!isArray(this.data.fieldValue)) {
+            this.data.fieldValue = [this.data.fieldValue];
+          }
+          // Process field flags for the display layer.
+          this.data.combo = this.hasFieldFlag(AnnotationFieldFlag.COMBO);
+          this.data.multiSelect = this.hasFieldFlag(AnnotationFieldFlag.MULTISELECT);
+        }
+        Util.inherit(ChoiceWidgetAnnotation, WidgetAnnotation, {
+          getOperatorList: function ChoiceWidgetAnnotation_getOperatorList(evaluator, task, renderForms) {
+            var operatorList = new OperatorList();
+            // Do not render form elements on the canvas when interactive forms are
+            // enabled. The display layer is responsible for rendering them instead.
+            if (renderForms) {
+              return Promise.resolve(operatorList);
+            }
+            return Annotation.prototype.getOperatorList.call(this, evaluator, task, renderForms);
+          }
+        });
+        return ChoiceWidgetAnnotation;
+      }();
+      var TextAnnotation = function TextAnnotationClosure() {
+        var DEFAULT_ICON_SIZE = 22;
+        // px
+        function TextAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          this.data.annotationType = AnnotationType.TEXT;
+          if (this.data.hasAppearance) {
+            this.data.name = 'NoIcon';
+          } else {
+            this.data.rect[1] = this.data.rect[3] - DEFAULT_ICON_SIZE;
+            this.data.rect[2] = this.data.rect[0] + DEFAULT_ICON_SIZE;
+            this.data.name = parameters.dict.has('Name') ? parameters.dict.get('Name').name : 'Note';
+          }
+          this._preparePopup(parameters.dict);
+        }
+        Util.inherit(TextAnnotation, Annotation, {});
+        return TextAnnotation;
+      }();
+      var LinkAnnotation = function LinkAnnotationClosure() {
+        function LinkAnnotation(params) {
+          Annotation.call(this, params);
+          var data = this.data;
+          data.annotationType = AnnotationType.LINK;
+          Catalog.parseDestDictionary({
+            destDict: params.dict,
+            resultObj: data,
+            docBaseUrl: params.pdfManager.docBaseUrl
+          });
+        }
+        Util.inherit(LinkAnnotation, Annotation, {});
+        return LinkAnnotation;
+      }();
+      var PopupAnnotation = function PopupAnnotationClosure() {
+        function PopupAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          this.data.annotationType = AnnotationType.POPUP;
+          var dict = parameters.dict;
+          var parentItem = dict.get('Parent');
+          if (!parentItem) {
+            warn('Popup annotation has a missing or invalid parent annotation.');
+            return;
+          }
+          this.data.parentId = dict.getRaw('Parent').toString();
+          this.data.title = stringToPDFString(parentItem.get('T') || '');
+          this.data.contents = stringToPDFString(parentItem.get('Contents') || '');
+          if (!parentItem.has('C')) {
+            // Fall back to the default background color.
+            this.data.color = null;
+          } else {
+            this.setColor(parentItem.getArray('C'));
+            this.data.color = this.color;
+          }
+          // If the Popup annotation is not viewable, but the parent annotation is,
+          // that is most likely a bug. Fallback to inherit the flags from the parent
+          // annotation (this is consistent with the behaviour in Adobe Reader).
+          if (!this.viewable) {
+            var parentFlags = parentItem.get('F');
+            if (this._isViewable(parentFlags)) {
+              this.setFlags(parentFlags);
+            }
+          }
+        }
+        Util.inherit(PopupAnnotation, Annotation, {});
+        return PopupAnnotation;
+      }();
+      var HighlightAnnotation = function HighlightAnnotationClosure() {
+        function HighlightAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          this.data.annotationType = AnnotationType.HIGHLIGHT;
+          this._preparePopup(parameters.dict);
+          // PDF viewers completely ignore any border styles.
+          this.data.borderStyle.setWidth(0);
+        }
+        Util.inherit(HighlightAnnotation, Annotation, {});
+        return HighlightAnnotation;
+      }();
+      var UnderlineAnnotation = function UnderlineAnnotationClosure() {
+        function UnderlineAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          this.data.annotationType = AnnotationType.UNDERLINE;
+          this._preparePopup(parameters.dict);
+          // PDF viewers completely ignore any border styles.
+          this.data.borderStyle.setWidth(0);
+        }
+        Util.inherit(UnderlineAnnotation, Annotation, {});
+        return UnderlineAnnotation;
+      }();
+      var SquigglyAnnotation = function SquigglyAnnotationClosure() {
+        function SquigglyAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          this.data.annotationType = AnnotationType.SQUIGGLY;
+          this._preparePopup(parameters.dict);
+          // PDF viewers completely ignore any border styles.
+          this.data.borderStyle.setWidth(0);
+        }
+        Util.inherit(SquigglyAnnotation, Annotation, {});
+        return SquigglyAnnotation;
+      }();
+      var StrikeOutAnnotation = function StrikeOutAnnotationClosure() {
+        function StrikeOutAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          this.data.annotationType = AnnotationType.STRIKEOUT;
+          this._preparePopup(parameters.dict);
+          // PDF viewers completely ignore any border styles.
+          this.data.borderStyle.setWidth(0);
+        }
+        Util.inherit(StrikeOutAnnotation, Annotation, {});
+        return StrikeOutAnnotation;
+      }();
+      var FileAttachmentAnnotation = function FileAttachmentAnnotationClosure() {
+        function FileAttachmentAnnotation(parameters) {
+          Annotation.call(this, parameters);
+          var file = new FileSpec(parameters.dict.get('FS'), parameters.xref);
+          this.data.annotationType = AnnotationType.FILEATTACHMENT;
+          this.data.file = file.serializable;
+          this._preparePopup(parameters.dict);
+        }
+        Util.inherit(FileAttachmentAnnotation, Annotation, {});
+        return FileAttachmentAnnotation;
+      }();
+      exports.Annotation = Annotation;
+      exports.AnnotationBorderStyle = AnnotationBorderStyle;
+      exports.AnnotationFactory = AnnotationFactory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreDocument = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreObj, root.pdfjsCoreParser, root.pdfjsCoreCrypto, root.pdfjsCoreEvaluator, root.pdfjsCoreAnnotation);
+    }(this, function (exports, sharedUtil, corePrimitives, coreStream, coreObj, coreParser, coreCrypto, coreEvaluator, coreAnnotation) {
+      var MissingDataException = sharedUtil.MissingDataException;
+      var Util = sharedUtil.Util;
+      var assert = sharedUtil.assert;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var isArray = sharedUtil.isArray;
+      var isArrayBuffer = sharedUtil.isArrayBuffer;
+      var isString = sharedUtil.isString;
+      var shadow = sharedUtil.shadow;
+      var stringToBytes = sharedUtil.stringToBytes;
+      var stringToPDFString = sharedUtil.stringToPDFString;
+      var warn = sharedUtil.warn;
+      var isSpace = sharedUtil.isSpace;
+      var Dict = corePrimitives.Dict;
+      var isDict = corePrimitives.isDict;
+      var isName = corePrimitives.isName;
+      var isStream = corePrimitives.isStream;
+      var NullStream = coreStream.NullStream;
+      var Stream = coreStream.Stream;
+      var StreamsSequenceStream = coreStream.StreamsSequenceStream;
+      var Catalog = coreObj.Catalog;
+      var ObjectLoader = coreObj.ObjectLoader;
+      var XRef = coreObj.XRef;
+      var Linearization = coreParser.Linearization;
+      var calculateMD5 = coreCrypto.calculateMD5;
+      var OperatorList = coreEvaluator.OperatorList;
+      var PartialEvaluator = coreEvaluator.PartialEvaluator;
+      var Annotation = coreAnnotation.Annotation;
+      var AnnotationFactory = coreAnnotation.AnnotationFactory;
+      var Page = function PageClosure() {
+        var LETTER_SIZE_MEDIABOX = [
+          0,
+          0,
+          612,
+          792
+        ];
+        function Page(pdfManager, xref, pageIndex, pageDict, ref, fontCache) {
+          this.pdfManager = pdfManager;
+          this.pageIndex = pageIndex;
+          this.pageDict = pageDict;
+          this.xref = xref;
+          this.ref = ref;
+          this.fontCache = fontCache;
+          this.uniquePrefix = 'p' + this.pageIndex + '_';
+          this.idCounters = { obj: 0 };
+          this.evaluatorOptions = pdfManager.evaluatorOptions;
+          this.resourcesPromise = null;
+        }
+        Page.prototype = {
+          getPageProp: function Page_getPageProp(key) {
+            return this.pageDict.get(key);
+          },
+          getInheritedPageProp: function Page_getInheritedPageProp(key) {
+            var dict = this.pageDict, valueArray = null, loopCount = 0;
+            var MAX_LOOP_COUNT = 100;
+            // Always walk up the entire parent chain, to be able to find
+            // e.g. \Resources placed on multiple levels of the tree.
+            while (dict) {
+              var value = dict.get(key);
+              if (value) {
+                if (!valueArray) {
+                  valueArray = [];
+                }
+                valueArray.push(value);
+              }
+              if (++loopCount > MAX_LOOP_COUNT) {
+                warn('Page_getInheritedPageProp: maximum loop count exceeded.');
+                break;
+              }
+              dict = dict.get('Parent');
+            }
+            if (!valueArray) {
+              return Dict.empty;
+            }
+            if (valueArray.length === 1 || !isDict(valueArray[0]) || loopCount > MAX_LOOP_COUNT) {
+              return valueArray[0];
+            }
+            return Dict.merge(this.xref, valueArray);
+          },
+          get content() {
+            return this.getPageProp('Contents');
+          },
+          get resources() {
+            // For robustness: The spec states that a \Resources entry has to be
+            // present, but can be empty. Some document omit it still, in this case
+            // we return an empty dictionary.
+            return shadow(this, 'resources', this.getInheritedPageProp('Resources'));
+          },
+          get mediaBox() {
+            var obj = this.getInheritedPageProp('MediaBox');
+            // Reset invalid media box to letter size.
+            if (!isArray(obj) || obj.length !== 4) {
+              obj = LETTER_SIZE_MEDIABOX;
+            }
+            return shadow(this, 'mediaBox', obj);
+          },
+          get view() {
+            var mediaBox = this.mediaBox;
+            var cropBox = this.getInheritedPageProp('CropBox');
+            if (!isArray(cropBox) || cropBox.length !== 4) {
+              return shadow(this, 'view', mediaBox);
+            }
+            // From the spec, 6th ed., p.963:
+            // "The crop, bleed, trim, and art boxes should not ordinarily
+            // extend beyond the boundaries of the media box. If they do, they are
+            // effectively reduced to their intersection with the media box."
+            cropBox = Util.intersect(cropBox, mediaBox);
+            if (!cropBox) {
+              return shadow(this, 'view', mediaBox);
+            }
+            return shadow(this, 'view', cropBox);
+          },
+          get rotate() {
+            var rotate = this.getInheritedPageProp('Rotate') || 0;
+            // Normalize rotation so it's a multiple of 90 and between 0 and 270
+            if (rotate % 90 !== 0) {
+              rotate = 0;
+            } else if (rotate >= 360) {
+              rotate = rotate % 360;
+            } else if (rotate < 0) {
+              // The spec doesn't cover negatives, assume its counterclockwise
+              // rotation. The following is the other implementation of modulo.
+              rotate = (rotate % 360 + 360) % 360;
+            }
+            return shadow(this, 'rotate', rotate);
+          },
+          getContentStream: function Page_getContentStream() {
+            var content = this.content;
+            var stream;
+            if (isArray(content)) {
+              // fetching items
+              var xref = this.xref;
+              var i, n = content.length;
+              var streams = [];
+              for (i = 0; i < n; ++i) {
+                streams.push(xref.fetchIfRef(content[i]));
+              }
+              stream = new StreamsSequenceStream(streams);
+            } else if (isStream(content)) {
+              stream = content;
+            } else {
+              // replacing non-existent page content with empty one
+              stream = new NullStream();
+            }
+            return stream;
+          },
+          loadResources: function Page_loadResources(keys) {
+            if (!this.resourcesPromise) {
+              // TODO: add async getInheritedPageProp and remove this.
+              this.resourcesPromise = this.pdfManager.ensure(this, 'resources');
+            }
+            return this.resourcesPromise.then(function resourceSuccess() {
+              var objectLoader = new ObjectLoader(this.resources.map, keys, this.xref);
+              return objectLoader.load();
+            }.bind(this));
+          },
+          getOperatorList: function Page_getOperatorList(handler, task, intent, renderInteractiveForms) {
+            var self = this;
+            var pdfManager = this.pdfManager;
+            var contentStreamPromise = pdfManager.ensure(this, 'getContentStream', []);
+            var resourcesPromise = this.loadResources([
+              'ExtGState',
+              'ColorSpace',
+              'Pattern',
+              'Shading',
+              'XObject',
+              'Font'
+            ]);
+            // ProcSet
+            // Properties
+            var partialEvaluator = new PartialEvaluator(pdfManager, this.xref, handler, this.pageIndex, this.uniquePrefix, this.idCounters, this.fontCache, this.evaluatorOptions);
+            var dataPromises = Promise.all([
+              contentStreamPromise,
+              resourcesPromise
+            ]);
+            var pageListPromise = dataPromises.then(function (data) {
+              var contentStream = data[0];
+              var opList = new OperatorList(intent, handler, self.pageIndex);
+              handler.send('StartRenderPage', {
+                transparency: partialEvaluator.hasBlendModes(self.resources),
+                pageIndex: self.pageIndex,
+                intent: intent
+              });
+              return partialEvaluator.getOperatorList(contentStream, task, self.resources, opList).then(function () {
+                return opList;
+              });
+            });
+            var annotationsPromise = pdfManager.ensure(this, 'annotations');
+            return Promise.all([
+              pageListPromise,
+              annotationsPromise
+            ]).then(function (datas) {
+              var pageOpList = datas[0];
+              var annotations = datas[1];
+              if (annotations.length === 0) {
+                pageOpList.flush(true);
+                return pageOpList;
+              }
+              var annotationsReadyPromise = Annotation.appendToOperatorList(annotations, pageOpList, partialEvaluator, task, intent, renderInteractiveForms);
+              return annotationsReadyPromise.then(function () {
+                pageOpList.flush(true);
+                return pageOpList;
+              });
+            });
+          },
+          extractTextContent: function Page_extractTextContent(task, normalizeWhitespace, combineTextItems) {
+            var handler = {
+              on: function nullHandlerOn() {
+              },
+              send: function nullHandlerSend() {
+              }
+            };
+            var self = this;
+            var pdfManager = this.pdfManager;
+            var contentStreamPromise = pdfManager.ensure(this, 'getContentStream', []);
+            var resourcesPromise = this.loadResources([
+              'ExtGState',
+              'XObject',
+              'Font'
+            ]);
+            var dataPromises = Promise.all([
+              contentStreamPromise,
+              resourcesPromise
+            ]);
+            return dataPromises.then(function (data) {
+              var contentStream = data[0];
+              var partialEvaluator = new PartialEvaluator(pdfManager, self.xref, handler, self.pageIndex, self.uniquePrefix, self.idCounters, self.fontCache, self.evaluatorOptions);
+              return partialEvaluator.getTextContent(contentStream, task, self.resources, /* stateManager = */
+              null, normalizeWhitespace, combineTextItems);
+            });
+          },
+          getAnnotationsData: function Page_getAnnotationsData(intent) {
+            var annotations = this.annotations;
+            var annotationsData = [];
+            for (var i = 0, n = annotations.length; i < n; ++i) {
+              if (intent) {
+                if (!(intent === 'display' && annotations[i].viewable) && !(intent === 'print' && annotations[i].printable)) {
+                  continue;
+                }
+              }
+              annotationsData.push(annotations[i].data);
+            }
+            return annotationsData;
+          },
+          get annotations() {
+            var annotations = [];
+            var annotationRefs = this.getInheritedPageProp('Annots') || [];
+            var annotationFactory = new AnnotationFactory();
+            for (var i = 0, n = annotationRefs.length; i < n; ++i) {
+              var annotationRef = annotationRefs[i];
+              var annotation = annotationFactory.create(this.xref, annotationRef, this.pdfManager, this.uniquePrefix, this.idCounters);
+              if (annotation) {
+                annotations.push(annotation);
+              }
+            }
+            return shadow(this, 'annotations', annotations);
+          }
+        };
+        return Page;
+      }();
+      /**
+       * The `PDFDocument` holds all the data of the PDF file. Compared to the
+       * `PDFDoc`, this one doesn't have any job management code.
+       * Right now there exists one PDFDocument on the main thread + one object
+       * for each worker. If there is no worker support enabled, there are two
+       * `PDFDocument` objects on the main thread created.
+       */
+      var PDFDocument = function PDFDocumentClosure() {
+        var FINGERPRINT_FIRST_BYTES = 1024;
+        var EMPTY_FINGERPRINT = '\x00\x00\x00\x00\x00\x00\x00' + '\x00\x00\x00\x00\x00\x00\x00\x00\x00';
+        function PDFDocument(pdfManager, arg, password) {
+          if (isStream(arg)) {
+            init.call(this, pdfManager, arg, password);
+          } else if (isArrayBuffer(arg)) {
+            init.call(this, pdfManager, new Stream(arg), password);
+          } else {
+            error('PDFDocument: Unknown argument type');
+          }
+        }
+        function init(pdfManager, stream, password) {
+          assert(stream.length > 0, 'stream must have data');
+          this.pdfManager = pdfManager;
+          this.stream = stream;
+          var xref = new XRef(this.stream, password, pdfManager);
+          this.xref = xref;
+        }
+        function find(stream, needle, limit, backwards) {
+          var pos = stream.pos;
+          var end = stream.end;
+          var strBuf = [];
+          if (pos + limit > end) {
+            limit = end - pos;
+          }
+          for (var n = 0; n < limit; ++n) {
+            strBuf.push(String.fromCharCode(stream.getByte()));
+          }
+          var str = strBuf.join('');
+          stream.pos = pos;
+          var index = backwards ? str.lastIndexOf(needle) : str.indexOf(needle);
+          if (index === -1) {
+            return false;
+          }
+          /* not found */
+          stream.pos += index;
+          return true;
+        }
+        /* found */
+        var DocumentInfoValidators = {
+          get entries() {
+            // Lazily build this since all the validation functions below are not
+            // defined until after this file loads.
+            return shadow(this, 'entries', {
+              Title: isString,
+              Author: isString,
+              Subject: isString,
+              Keywords: isString,
+              Creator: isString,
+              Producer: isString,
+              CreationDate: isString,
+              ModDate: isString,
+              Trapped: isName
+            });
+          }
+        };
+        PDFDocument.prototype = {
+          parse: function PDFDocument_parse(recoveryMode) {
+            this.setup(recoveryMode);
+            var version = this.catalog.catDict.get('Version');
+            if (isName(version)) {
+              this.pdfFormatVersion = version.name;
+            }
+            try {
+              // checking if AcroForm is present
+              this.acroForm = this.catalog.catDict.get('AcroForm');
+              if (this.acroForm) {
+                this.xfa = this.acroForm.get('XFA');
+                var fields = this.acroForm.get('Fields');
+                if ((!fields || !isArray(fields) || fields.length === 0) && !this.xfa) {
+                  // no fields and no XFA -- not a form (?)
+                  this.acroForm = null;
+                }
+              }
+            } catch (ex) {
+              info('Something wrong with AcroForm entry');
+              this.acroForm = null;
+            }
+          },
+          get linearization() {
+            var linearization = null;
+            if (this.stream.length) {
+              try {
+                linearization = Linearization.create(this.stream);
+              } catch (err) {
+                if (err instanceof MissingDataException) {
+                  throw err;
+                }
+                info(err);
+              }
+            }
+            // shadow the prototype getter with a data property
+            return shadow(this, 'linearization', linearization);
+          },
+          get startXRef() {
+            var stream = this.stream;
+            var startXRef = 0;
+            var linearization = this.linearization;
+            if (linearization) {
+              // Find end of first obj.
+              stream.reset();
+              if (find(stream, 'endobj', 1024)) {
+                startXRef = stream.pos + 6;
+              }
+            } else {
+              // Find startxref by jumping backward from the end of the file.
+              var step = 1024;
+              var found = false, pos = stream.end;
+              while (!found && pos > 0) {
+                pos -= step - 'startxref'.length;
+                if (pos < 0) {
+                  pos = 0;
+                }
+                stream.pos = pos;
+                found = find(stream, 'startxref', step, true);
+              }
+              if (found) {
+                stream.skip(9);
+                var ch;
+                do {
+                  ch = stream.getByte();
+                } while (isSpace(ch));
+                var str = '';
+                while (ch >= 0x20 && ch <= 0x39) {
+                  // < '9'
+                  str += String.fromCharCode(ch);
+                  ch = stream.getByte();
+                }
+                startXRef = parseInt(str, 10);
+                if (isNaN(startXRef)) {
+                  startXRef = 0;
+                }
+              }
+            }
+            // shadow the prototype getter with a data property
+            return shadow(this, 'startXRef', startXRef);
+          },
+          get mainXRefEntriesOffset() {
+            var mainXRefEntriesOffset = 0;
+            var linearization = this.linearization;
+            if (linearization) {
+              mainXRefEntriesOffset = linearization.mainXRefEntriesOffset;
+            }
+            // shadow the prototype getter with a data property
+            return shadow(this, 'mainXRefEntriesOffset', mainXRefEntriesOffset);
+          },
+          // Find the header, remove leading garbage and setup the stream
+          // starting from the header.
+          checkHeader: function PDFDocument_checkHeader() {
+            var stream = this.stream;
+            stream.reset();
+            if (find(stream, '%PDF-', 1024)) {
+              // Found the header, trim off any garbage before it.
+              stream.moveStart();
+              // Reading file format version
+              var MAX_VERSION_LENGTH = 12;
+              var version = '', ch;
+              while ((ch = stream.getByte()) > 0x20) {
+                // SPACE
+                if (version.length >= MAX_VERSION_LENGTH) {
+                  break;
+                }
+                version += String.fromCharCode(ch);
+              }
+              if (!this.pdfFormatVersion) {
+                // removing "%PDF-"-prefix
+                this.pdfFormatVersion = version.substring(5);
+              }
+              return;
+            }
+          },
+          // May not be a PDF file, continue anyway.
+          parseStartXRef: function PDFDocument_parseStartXRef() {
+            var startXRef = this.startXRef;
+            this.xref.setStartXRef(startXRef);
+          },
+          setup: function PDFDocument_setup(recoveryMode) {
+            this.xref.parse(recoveryMode);
+            var self = this;
+            var pageFactory = {
+              createPage: function (pageIndex, dict, ref, fontCache) {
+                return new Page(self.pdfManager, self.xref, pageIndex, dict, ref, fontCache);
+              }
+            };
+            this.catalog = new Catalog(this.pdfManager, this.xref, pageFactory);
+          },
+          get numPages() {
+            var linearization = this.linearization;
+            var num = linearization ? linearization.numPages : this.catalog.numPages;
+            // shadow the prototype getter
+            return shadow(this, 'numPages', num);
+          },
+          get documentInfo() {
+            var docInfo = {
+              PDFFormatVersion: this.pdfFormatVersion,
+              IsAcroFormPresent: !!this.acroForm,
+              IsXFAPresent: !!this.xfa
+            };
+            var infoDict;
+            try {
+              infoDict = this.xref.trailer.get('Info');
+            } catch (err) {
+              info('The document information dictionary is invalid.');
+            }
+            if (infoDict) {
+              var validEntries = DocumentInfoValidators.entries;
+              // Only fill the document info with valid entries from the spec.
+              for (var key in validEntries) {
+                if (infoDict.has(key)) {
+                  var value = infoDict.get(key);
+                  // Make sure the value conforms to the spec.
+                  if (validEntries[key](value)) {
+                    docInfo[key] = typeof value !== 'string' ? value : stringToPDFString(value);
+                  } else {
+                    info('Bad value in document info for "' + key + '"');
+                  }
+                }
+              }
+            }
+            return shadow(this, 'documentInfo', docInfo);
+          },
+          get fingerprint() {
+            var xref = this.xref, hash, fileID = '';
+            var idArray = xref.trailer.get('ID');
+            if (idArray && isArray(idArray) && idArray[0] && isString(idArray[0]) && idArray[0] !== EMPTY_FINGERPRINT) {
+              hash = stringToBytes(idArray[0]);
+            } else {
+              if (this.stream.ensureRange) {
+                this.stream.ensureRange(0, Math.min(FINGERPRINT_FIRST_BYTES, this.stream.end));
+              }
+              hash = calculateMD5(this.stream.bytes.subarray(0, FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES);
+            }
+            for (var i = 0, n = hash.length; i < n; i++) {
+              var hex = hash[i].toString(16);
+              fileID += hex.length === 1 ? '0' + hex : hex;
+            }
+            return shadow(this, 'fingerprint', fileID);
+          },
+          getPage: function PDFDocument_getPage(pageIndex) {
+            return this.catalog.getPage(pageIndex);
+          },
+          cleanup: function PDFDocument_cleanup() {
+            return this.catalog.cleanup();
+          }
+        };
+        return PDFDocument;
+      }();
+      exports.Page = Page;
+      exports.PDFDocument = PDFDocument;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCorePdfManager = {}, root.pdfjsSharedUtil, root.pdfjsCoreStream, root.pdfjsCoreChunkedStream, root.pdfjsCoreDocument);
+    }(this, function (exports, sharedUtil, coreStream, coreChunkedStream, coreDocument) {
+      var warn = sharedUtil.warn;
+      var createValidAbsoluteUrl = sharedUtil.createValidAbsoluteUrl;
+      var shadow = sharedUtil.shadow;
+      var NotImplementedException = sharedUtil.NotImplementedException;
+      var MissingDataException = sharedUtil.MissingDataException;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var Util = sharedUtil.Util;
+      var Stream = coreStream.Stream;
+      var ChunkedStreamManager = coreChunkedStream.ChunkedStreamManager;
+      var PDFDocument = coreDocument.PDFDocument;
+      var BasePdfManager = function BasePdfManagerClosure() {
+        function BasePdfManager() {
+          throw new Error('Cannot initialize BaseManagerManager');
+        }
+        BasePdfManager.prototype = {
+          get docId() {
+            return this._docId;
+          },
+          get docBaseUrl() {
+            var docBaseUrl = null;
+            if (this._docBaseUrl) {
+              var absoluteUrl = createValidAbsoluteUrl(this._docBaseUrl);
+              if (absoluteUrl) {
+                docBaseUrl = absoluteUrl.href;
+              } else {
+                warn('Invalid absolute docBaseUrl: "' + this._docBaseUrl + '".');
+              }
+            }
+            return shadow(this, 'docBaseUrl', docBaseUrl);
+          },
+          onLoadedStream: function BasePdfManager_onLoadedStream() {
+            throw new NotImplementedException();
+          },
+          ensureDoc: function BasePdfManager_ensureDoc(prop, args) {
+            return this.ensure(this.pdfDocument, prop, args);
+          },
+          ensureXRef: function BasePdfManager_ensureXRef(prop, args) {
+            return this.ensure(this.pdfDocument.xref, prop, args);
+          },
+          ensureCatalog: function BasePdfManager_ensureCatalog(prop, args) {
+            return this.ensure(this.pdfDocument.catalog, prop, args);
+          },
+          getPage: function BasePdfManager_getPage(pageIndex) {
+            return this.pdfDocument.getPage(pageIndex);
+          },
+          cleanup: function BasePdfManager_cleanup() {
+            return this.pdfDocument.cleanup();
+          },
+          ensure: function BasePdfManager_ensure(obj, prop, args) {
+            return new NotImplementedException();
+          },
+          requestRange: function BasePdfManager_requestRange(begin, end) {
+            return new NotImplementedException();
+          },
+          requestLoadedStream: function BasePdfManager_requestLoadedStream() {
+            return new NotImplementedException();
+          },
+          sendProgressiveData: function BasePdfManager_sendProgressiveData(chunk) {
+            return new NotImplementedException();
+          },
+          updatePassword: function BasePdfManager_updatePassword(password) {
+            this.pdfDocument.xref.password = this.password = password;
+            if (this._passwordChangedCapability) {
+              this._passwordChangedCapability.resolve();
+            }
+          },
+          passwordChanged: function BasePdfManager_passwordChanged() {
+            this._passwordChangedCapability = createPromiseCapability();
+            return this._passwordChangedCapability.promise;
+          },
+          terminate: function BasePdfManager_terminate() {
+            return new NotImplementedException();
+          }
+        };
+        return BasePdfManager;
+      }();
+      var LocalPdfManager = function LocalPdfManagerClosure() {
+        function LocalPdfManager(docId, data, password, evaluatorOptions, docBaseUrl) {
+          this._docId = docId;
+          this._docBaseUrl = docBaseUrl;
+          this.evaluatorOptions = evaluatorOptions;
+          var stream = new Stream(data);
+          this.pdfDocument = new PDFDocument(this, stream, password);
+          this._loadedStreamCapability = createPromiseCapability();
+          this._loadedStreamCapability.resolve(stream);
+        }
+        Util.inherit(LocalPdfManager, BasePdfManager, {
+          ensure: function LocalPdfManager_ensure(obj, prop, args) {
+            return new Promise(function (resolve, reject) {
+              try {
+                var value = obj[prop];
+                var result;
+                if (typeof value === 'function') {
+                  result = value.apply(obj, args);
+                } else {
+                  result = value;
+                }
+                resolve(result);
+              } catch (e) {
+                reject(e);
+              }
+            });
+          },
+          requestRange: function LocalPdfManager_requestRange(begin, end) {
+            return Promise.resolve();
+          },
+          requestLoadedStream: function LocalPdfManager_requestLoadedStream() {
+            return;
+          },
+          onLoadedStream: function LocalPdfManager_onLoadedStream() {
+            return this._loadedStreamCapability.promise;
+          },
+          terminate: function LocalPdfManager_terminate() {
+            return;
+          }
+        });
+        return LocalPdfManager;
+      }();
+      var NetworkPdfManager = function NetworkPdfManagerClosure() {
+        function NetworkPdfManager(docId, pdfNetworkStream, args, evaluatorOptions, docBaseUrl) {
+          this._docId = docId;
+          this._docBaseUrl = docBaseUrl;
+          this.msgHandler = args.msgHandler;
+          this.evaluatorOptions = evaluatorOptions;
+          var params = {
+            msgHandler: args.msgHandler,
+            url: args.url,
+            length: args.length,
+            disableAutoFetch: args.disableAutoFetch,
+            rangeChunkSize: args.rangeChunkSize
+          };
+          this.streamManager = new ChunkedStreamManager(pdfNetworkStream, params);
+          this.pdfDocument = new PDFDocument(this, this.streamManager.getStream(), args.password);
+        }
+        Util.inherit(NetworkPdfManager, BasePdfManager, {
+          ensure: function NetworkPdfManager_ensure(obj, prop, args) {
+            var pdfManager = this;
+            return new Promise(function (resolve, reject) {
+              function ensureHelper() {
+                try {
+                  var result;
+                  var value = obj[prop];
+                  if (typeof value === 'function') {
+                    result = value.apply(obj, args);
+                  } else {
+                    result = value;
+                  }
+                  resolve(result);
+                } catch (e) {
+                  if (!(e instanceof MissingDataException)) {
+                    reject(e);
+                    return;
+                  }
+                  pdfManager.streamManager.requestRange(e.begin, e.end).then(ensureHelper, reject);
+                }
+              }
+              ensureHelper();
+            });
+          },
+          requestRange: function NetworkPdfManager_requestRange(begin, end) {
+            return this.streamManager.requestRange(begin, end);
+          },
+          requestLoadedStream: function NetworkPdfManager_requestLoadedStream() {
+            this.streamManager.requestAllChunks();
+          },
+          sendProgressiveData: function NetworkPdfManager_sendProgressiveData(chunk) {
+            this.streamManager.onReceiveData({ chunk: chunk });
+          },
+          onLoadedStream: function NetworkPdfManager_onLoadedStream() {
+            return this.streamManager.onLoadedStream();
+          },
+          terminate: function NetworkPdfManager_terminate() {
+            this.streamManager.abort();
+          }
+        });
+        return NetworkPdfManager;
+      }();
+      exports.LocalPdfManager = LocalPdfManager;
+      exports.NetworkPdfManager = NetworkPdfManager;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsCoreWorker = {}, root.pdfjsSharedUtil, root.pdfjsCorePrimitives, root.pdfjsCorePdfManager);
+    }(this, function (exports, sharedUtil, corePrimitives, corePdfManager) {
+      var UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES;
+      var InvalidPDFException = sharedUtil.InvalidPDFException;
+      var MessageHandler = sharedUtil.MessageHandler;
+      var MissingPDFException = sharedUtil.MissingPDFException;
+      var UnexpectedResponseException = sharedUtil.UnexpectedResponseException;
+      var PasswordException = sharedUtil.PasswordException;
+      var PasswordResponses = sharedUtil.PasswordResponses;
+      var UnknownErrorException = sharedUtil.UnknownErrorException;
+      var XRefParseException = sharedUtil.XRefParseException;
+      var arrayByteLength = sharedUtil.arrayByteLength;
+      var arraysToBytes = sharedUtil.arraysToBytes;
+      var assert = sharedUtil.assert;
+      var createPromiseCapability = sharedUtil.createPromiseCapability;
+      var error = sharedUtil.error;
+      var info = sharedUtil.info;
+      var warn = sharedUtil.warn;
+      var setVerbosityLevel = sharedUtil.setVerbosityLevel;
+      var Ref = corePrimitives.Ref;
+      var LocalPdfManager = corePdfManager.LocalPdfManager;
+      var NetworkPdfManager = corePdfManager.NetworkPdfManager;
+      var globalScope = sharedUtil.globalScope;
+      var WorkerTask = function WorkerTaskClosure() {
+        function WorkerTask(name) {
+          this.name = name;
+          this.terminated = false;
+          this._capability = createPromiseCapability();
+        }
+        WorkerTask.prototype = {
+          get finished() {
+            return this._capability.promise;
+          },
+          finish: function () {
+            this._capability.resolve();
+          },
+          terminate: function () {
+            this.terminated = true;
+          },
+          ensureNotTerminated: function () {
+            if (this.terminated) {
+              throw new Error('Worker task was terminated');
+            }
+          }
+        };
+        return WorkerTask;
+      }();
+      /** @implements {IPDFStream} */
+      var PDFWorkerStream = function PDFWorkerStreamClosure() {
+        function PDFWorkerStream(params, msgHandler) {
+          this._queuedChunks = [];
+          var initialData = params.initialData;
+          if (initialData && initialData.length > 0) {
+            this._queuedChunks.push(initialData);
+          }
+          this._msgHandler = msgHandler;
+          this._isRangeSupported = !params.disableRange;
+          this._isStreamingSupported = !params.disableStream;
+          this._contentLength = params.length;
+          this._fullRequestReader = null;
+          this._rangeReaders = [];
+          msgHandler.on('OnDataRange', this._onReceiveData.bind(this));
+          msgHandler.on('OnDataProgress', this._onProgress.bind(this));
+        }
+        PDFWorkerStream.prototype = {
+          _onReceiveData: function PDFWorkerStream_onReceiveData(args) {
+            if (args.begin === undefined) {
+              if (this._fullRequestReader) {
+                this._fullRequestReader._enqueue(args.chunk);
+              } else {
+                this._queuedChunks.push(args.chunk);
+              }
+            } else {
+              var found = this._rangeReaders.some(function (rangeReader) {
+                if (rangeReader._begin !== args.begin) {
+                  return false;
+                }
+                rangeReader._enqueue(args.chunk);
+                return true;
+              });
+              assert(found);
+            }
+          },
+          _onProgress: function PDFWorkerStream_onProgress(evt) {
+            if (this._rangeReaders.length > 0) {
+              // Reporting to first range reader.
+              var firstReader = this._rangeReaders[0];
+              if (firstReader.onProgress) {
+                firstReader.onProgress({ loaded: evt.loaded });
+              }
+            }
+          },
+          _removeRangeReader: function PDFWorkerStream_removeRangeReader(reader) {
+            var i = this._rangeReaders.indexOf(reader);
+            if (i >= 0) {
+              this._rangeReaders.splice(i, 1);
+            }
+          },
+          getFullReader: function PDFWorkerStream_getFullReader() {
+            assert(!this._fullRequestReader);
+            var queuedChunks = this._queuedChunks;
+            this._queuedChunks = null;
+            return new PDFWorkerStreamReader(this, queuedChunks);
+          },
+          getRangeReader: function PDFWorkerStream_getRangeReader(begin, end) {
+            var reader = new PDFWorkerStreamRangeReader(this, begin, end);
+            this._msgHandler.send('RequestDataRange', {
+              begin: begin,
+              end: end
+            });
+            this._rangeReaders.push(reader);
+            return reader;
+          },
+          cancelAllRequests: function PDFWorkerStream_cancelAllRequests(reason) {
+            if (this._fullRequestReader) {
+              this._fullRequestReader.cancel(reason);
+            }
+            var readers = this._rangeReaders.slice(0);
+            readers.forEach(function (rangeReader) {
+              rangeReader.cancel(reason);
+            });
+          }
+        };
+        /** @implements {IPDFStreamReader} */
+        function PDFWorkerStreamReader(stream, queuedChunks) {
+          this._stream = stream;
+          this._done = false;
+          this._queuedChunks = queuedChunks || [];
+          this._requests = [];
+          this._headersReady = Promise.resolve();
+          stream._fullRequestReader = this;
+          this.onProgress = null;
+        }
+        // not used
+        PDFWorkerStreamReader.prototype = {
+          _enqueue: function PDFWorkerStreamReader_enqueue(chunk) {
+            if (this._done) {
+              return;
+            }
+            // ignore new data
+            if (this._requests.length > 0) {
+              var requestCapability = this._requests.shift();
+              requestCapability.resolve({
+                value: chunk,
+                done: false
+              });
+              return;
+            }
+            this._queuedChunks.push(chunk);
+          },
+          get headersReady() {
+            return this._headersReady;
+          },
+          get isRangeSupported() {
+            return this._stream._isRangeSupported;
+          },
+          get isStreamingSupported() {
+            return this._stream._isStreamingSupported;
+          },
+          get contentLength() {
+            return this._stream._contentLength;
+          },
+          read: function PDFWorkerStreamReader_read() {
+            if (this._queuedChunks.length > 0) {
+              var chunk = this._queuedChunks.shift();
+              return Promise.resolve({
+                value: chunk,
+                done: false
+              });
+            }
+            if (this._done) {
+              return Promise.resolve({
+                value: undefined,
+                done: true
+              });
+            }
+            var requestCapability = createPromiseCapability();
+            this._requests.push(requestCapability);
+            return requestCapability.promise;
+          },
+          cancel: function PDFWorkerStreamReader_cancel(reason) {
+            this._done = true;
+            this._requests.forEach(function (requestCapability) {
+              requestCapability.resolve({
+                value: undefined,
+                done: true
+              });
+            });
+            this._requests = [];
+          }
+        };
+        /** @implements {IPDFStreamRangeReader} */
+        function PDFWorkerStreamRangeReader(stream, begin, end) {
+          this._stream = stream;
+          this._begin = begin;
+          this._end = end;
+          this._queuedChunk = null;
+          this._requests = [];
+          this._done = false;
+          this.onProgress = null;
+        }
+        PDFWorkerStreamRangeReader.prototype = {
+          _enqueue: function PDFWorkerStreamRangeReader_enqueue(chunk) {
+            if (this._done) {
+              return;
+            }
+            // ignore new data
+            if (this._requests.length === 0) {
+              this._queuedChunk = chunk;
+            } else {
+              var requestsCapability = this._requests.shift();
+              requestsCapability.resolve({
+                value: chunk,
+                done: false
+              });
+              this._requests.forEach(function (requestCapability) {
+                requestCapability.resolve({
+                  value: undefined,
+                  done: true
+                });
+              });
+              this._requests = [];
+            }
+            this._done = true;
+            this._stream._removeRangeReader(this);
+          },
+          get isStreamingSupported() {
+            return false;
+          },
+          read: function PDFWorkerStreamRangeReader_read() {
+            if (this._queuedChunk) {
+              return Promise.resolve({
+                value: this._queuedChunk,
+                done: false
+              });
+            }
+            if (this._done) {
+              return Promise.resolve({
+                value: undefined,
+                done: true
+              });
+            }
+            var requestCapability = createPromiseCapability();
+            this._requests.push(requestCapability);
+            return requestCapability.promise;
+          },
+          cancel: function PDFWorkerStreamRangeReader_cancel(reason) {
+            this._done = true;
+            this._requests.forEach(function (requestCapability) {
+              requestCapability.resolve({
+                value: undefined,
+                done: true
+              });
+            });
+            this._requests = [];
+            this._stream._removeRangeReader(this);
+          }
+        };
+        return PDFWorkerStream;
+      }();
+      /** @type IPDFStream */
+      var PDFNetworkStream;
+      /**
+       * Sets PDFNetworkStream class to be used as alternative PDF data transport.
+       * @param {IPDFStream} cls - the PDF data transport.
+       */
+      function setPDFNetworkStreamClass(cls) {
+        PDFNetworkStream = cls;
+      }
+      var WorkerMessageHandler = {
+        setup: function wphSetup(handler, port) {
+          var testMessageProcessed = false;
+          handler.on('test', function wphSetupTest(data) {
+            if (testMessageProcessed) {
+              return;
+            }
+            // we already processed 'test' message once
+            testMessageProcessed = true;
+            // check if Uint8Array can be sent to worker
+            if (!(data instanceof Uint8Array)) {
+              handler.send('test', 'main', false);
+              return;
+            }
+            // making sure postMessage transfers are working
+            var supportTransfers = data[0] === 255;
+            handler.postMessageTransfers = supportTransfers;
+            // check if the response property is supported by xhr
+            var xhr = new XMLHttpRequest();
+            var responseExists = 'response' in xhr;
+            // check if the property is actually implemented
+            try {
+              var dummy = xhr.responseType;
+            } catch (e) {
+              responseExists = false;
+            }
+            if (!responseExists) {
+              handler.send('test', false);
+              return;
+            }
+            handler.send('test', {
+              supportTypedArray: true,
+              supportTransfers: supportTransfers
+            });
+          });
+          handler.on('configure', function wphConfigure(data) {
+            setVerbosityLevel(data.verbosity);
+          });
+          handler.on('GetDocRequest', function wphSetupDoc(data) {
+            return WorkerMessageHandler.createDocumentHandler(data, port);
+          });
+        },
+        createDocumentHandler: function wphCreateDocumentHandler(docParams, port) {
+          // This context is actually holds references on pdfManager and handler,
+          // until the latter is destroyed.
+          var pdfManager;
+          var terminated = false;
+          var cancelXHRs = null;
+          var WorkerTasks = [];
+          var docId = docParams.docId;
+          var docBaseUrl = docParams.docBaseUrl;
+          var workerHandlerName = docParams.docId + '_worker';
+          var handler = new MessageHandler(workerHandlerName, docId, port);
+          // Ensure that postMessage transfers are correctly enabled/disabled,
+          // to prevent "DataCloneError" in older versions of IE (see issue 6957).
+          handler.postMessageTransfers = docParams.postMessageTransfers;
+          function ensureNotTerminated() {
+            if (terminated) {
+              throw new Error('Worker was terminated');
+            }
+          }
+          function startWorkerTask(task) {
+            WorkerTasks.push(task);
+          }
+          function finishWorkerTask(task) {
+            task.finish();
+            var i = WorkerTasks.indexOf(task);
+            WorkerTasks.splice(i, 1);
+          }
+          function loadDocument(recoveryMode) {
+            var loadDocumentCapability = createPromiseCapability();
+            var parseSuccess = function parseSuccess() {
+              var numPagesPromise = pdfManager.ensureDoc('numPages');
+              var fingerprintPromise = pdfManager.ensureDoc('fingerprint');
+              var encryptedPromise = pdfManager.ensureXRef('encrypt');
+              Promise.all([
+                numPagesPromise,
+                fingerprintPromise,
+                encryptedPromise
+              ]).then(function onDocReady(results) {
+                var doc = {
+                  numPages: results[0],
+                  fingerprint: results[1],
+                  encrypted: !!results[2]
+                };
+                loadDocumentCapability.resolve(doc);
+              }, parseFailure);
+            };
+            var parseFailure = function parseFailure(e) {
+              loadDocumentCapability.reject(e);
+            };
+            pdfManager.ensureDoc('checkHeader', []).then(function () {
+              pdfManager.ensureDoc('parseStartXRef', []).then(function () {
+                pdfManager.ensureDoc('parse', [recoveryMode]).then(parseSuccess, parseFailure);
+              }, parseFailure);
+            }, parseFailure);
+            return loadDocumentCapability.promise;
+          }
+          function getPdfManager(data, evaluatorOptions) {
+            var pdfManagerCapability = createPromiseCapability();
+            var pdfManager;
+            var source = data.source;
+            if (source.data) {
+              try {
+                pdfManager = new LocalPdfManager(docId, source.data, source.password, evaluatorOptions, docBaseUrl);
+                pdfManagerCapability.resolve(pdfManager);
+              } catch (ex) {
+                pdfManagerCapability.reject(ex);
+              }
+              return pdfManagerCapability.promise;
+            }
+            var pdfStream;
+            try {
+              if (source.chunkedViewerLoading) {
+                pdfStream = new PDFWorkerStream(source, handler);
+              } else {
+                assert(PDFNetworkStream, 'pdfjs/core/network module is not loaded');
+                pdfStream = new PDFNetworkStream(data);
+              }
+            } catch (ex) {
+              pdfManagerCapability.reject(ex);
+              return pdfManagerCapability.promise;
+            }
+            var fullRequest = pdfStream.getFullReader();
+            fullRequest.headersReady.then(function () {
+              if (!fullRequest.isStreamingSupported || !fullRequest.isRangeSupported) {
+                // If stream or range are disabled, it's our only way to report
+                // loading progress.
+                fullRequest.onProgress = function (evt) {
+                  handler.send('DocProgress', {
+                    loaded: evt.loaded,
+                    total: evt.total
+                  });
+                };
+              }
+              if (!fullRequest.isRangeSupported) {
+                return;
+              }
+              // We don't need auto-fetch when streaming is enabled.
+              var disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
+              pdfManager = new NetworkPdfManager(docId, pdfStream, {
+                msgHandler: handler,
+                url: source.url,
+                password: source.password,
+                length: fullRequest.contentLength,
+                disableAutoFetch: disableAutoFetch,
+                rangeChunkSize: source.rangeChunkSize
+              }, evaluatorOptions, docBaseUrl);
+              pdfManagerCapability.resolve(pdfManager);
+              cancelXHRs = null;
+            }).catch(function (reason) {
+              pdfManagerCapability.reject(reason);
+              cancelXHRs = null;
+            });
+            var cachedChunks = [], loaded = 0;
+            var flushChunks = function () {
+              var pdfFile = arraysToBytes(cachedChunks);
+              if (source.length && pdfFile.length !== source.length) {
+                warn('reported HTTP length is different from actual');
+              }
+              // the data is array, instantiating directly from it
+              try {
+                pdfManager = new LocalPdfManager(docId, pdfFile, source.password, evaluatorOptions, docBaseUrl);
+                pdfManagerCapability.resolve(pdfManager);
+              } catch (ex) {
+                pdfManagerCapability.reject(ex);
+              }
+              cachedChunks = [];
+            };
+            var readPromise = new Promise(function (resolve, reject) {
+              var readChunk = function (chunk) {
+                try {
+                  ensureNotTerminated();
+                  if (chunk.done) {
+                    if (!pdfManager) {
+                      flushChunks();
+                    }
+                    cancelXHRs = null;
+                    return;
+                  }
+                  var data = chunk.value;
+                  loaded += arrayByteLength(data);
+                  if (!fullRequest.isStreamingSupported) {
+                    handler.send('DocProgress', {
+                      loaded: loaded,
+                      total: Math.max(loaded, fullRequest.contentLength || 0)
+                    });
+                  }
+                  if (pdfManager) {
+                    pdfManager.sendProgressiveData(data);
+                  } else {
+                    cachedChunks.push(data);
+                  }
+                  fullRequest.read().then(readChunk, reject);
+                } catch (e) {
+                  reject(e);
+                }
+              };
+              fullRequest.read().then(readChunk, reject);
+            });
+            readPromise.catch(function (e) {
+              pdfManagerCapability.reject(e);
+              cancelXHRs = null;
+            });
+            cancelXHRs = function () {
+              pdfStream.cancelAllRequests('abort');
+            };
+            return pdfManagerCapability.promise;
+          }
+          var setupDoc = function (data) {
+            var onSuccess = function (doc) {
+              ensureNotTerminated();
+              handler.send('GetDoc', { pdfInfo: doc });
+            };
+            var onFailure = function (e) {
+              if (e instanceof PasswordException) {
+                if (e.code === PasswordResponses.NEED_PASSWORD) {
+                  handler.send('NeedPassword', e);
+                } else if (e.code === PasswordResponses.INCORRECT_PASSWORD) {
+                  handler.send('IncorrectPassword', e);
+                }
+              } else if (e instanceof InvalidPDFException) {
+                handler.send('InvalidPDF', e);
+              } else if (e instanceof MissingPDFException) {
+                handler.send('MissingPDF', e);
+              } else if (e instanceof UnexpectedResponseException) {
+                handler.send('UnexpectedResponse', e);
+              } else {
+                handler.send('UnknownError', new UnknownErrorException(e.message, e.toString()));
+              }
+            };
+            ensureNotTerminated();
+            var cMapOptions = {
+              url: data.cMapUrl === undefined ? null : data.cMapUrl,
+              packed: data.cMapPacked === true
+            };
+            var evaluatorOptions = {
+              forceDataSchema: data.disableCreateObjectURL,
+              maxImageSize: data.maxImageSize === undefined ? -1 : data.maxImageSize,
+              disableFontFace: data.disableFontFace,
+              cMapOptions: cMapOptions
+            };
+            getPdfManager(data, evaluatorOptions).then(function (newPdfManager) {
+              if (terminated) {
+                // We were in a process of setting up the manager, but it got
+                // terminated in the middle.
+                newPdfManager.terminate();
+                throw new Error('Worker was terminated');
+              }
+              pdfManager = newPdfManager;
+              handler.send('PDFManagerReady', null);
+              pdfManager.onLoadedStream().then(function (stream) {
+                handler.send('DataLoaded', { length: stream.bytes.byteLength });
+              });
+            }).then(function pdfManagerReady() {
+              ensureNotTerminated();
+              loadDocument(false).then(onSuccess, function loadFailure(ex) {
+                ensureNotTerminated();
+                // Try again with recoveryMode == true
+                if (!(ex instanceof XRefParseException)) {
+                  if (ex instanceof PasswordException) {
+                    // after password exception prepare to receive a new password
+                    // to repeat loading
+                    pdfManager.passwordChanged().then(pdfManagerReady);
+                  }
+                  onFailure(ex);
+                  return;
+                }
+                pdfManager.requestLoadedStream();
+                pdfManager.onLoadedStream().then(function () {
+                  ensureNotTerminated();
+                  loadDocument(true).then(onSuccess, onFailure);
+                });
+              }, onFailure);
+            }, onFailure);
+          };
+          handler.on('GetPage', function wphSetupGetPage(data) {
+            return pdfManager.getPage(data.pageIndex).then(function (page) {
+              var rotatePromise = pdfManager.ensure(page, 'rotate');
+              var refPromise = pdfManager.ensure(page, 'ref');
+              var viewPromise = pdfManager.ensure(page, 'view');
+              return Promise.all([
+                rotatePromise,
+                refPromise,
+                viewPromise
+              ]).then(function (results) {
+                return {
+                  rotate: results[0],
+                  ref: results[1],
+                  view: results[2]
+                };
+              });
+            });
+          });
+          handler.on('GetPageIndex', function wphSetupGetPageIndex(data) {
+            var ref = new Ref(data.ref.num, data.ref.gen);
+            var catalog = pdfManager.pdfDocument.catalog;
+            return catalog.getPageIndex(ref);
+          });
+          handler.on('GetDestinations', function wphSetupGetDestinations(data) {
+            return pdfManager.ensureCatalog('destinations');
+          });
+          handler.on('GetDestination', function wphSetupGetDestination(data) {
+            return pdfManager.ensureCatalog('getDestination', [data.id]);
+          });
+          handler.on('GetPageLabels', function wphSetupGetPageLabels(data) {
+            return pdfManager.ensureCatalog('pageLabels');
+          });
+          handler.on('GetAttachments', function wphSetupGetAttachments(data) {
+            return pdfManager.ensureCatalog('attachments');
+          });
+          handler.on('GetJavaScript', function wphSetupGetJavaScript(data) {
+            return pdfManager.ensureCatalog('javaScript');
+          });
+          handler.on('GetOutline', function wphSetupGetOutline(data) {
+            return pdfManager.ensureCatalog('documentOutline');
+          });
+          handler.on('GetMetadata', function wphSetupGetMetadata(data) {
+            return Promise.all([
+              pdfManager.ensureDoc('documentInfo'),
+              pdfManager.ensureCatalog('metadata')
+            ]);
+          });
+          handler.on('GetData', function wphSetupGetData(data) {
+            pdfManager.requestLoadedStream();
+            return pdfManager.onLoadedStream().then(function (stream) {
+              return stream.bytes;
+            });
+          });
+          handler.on('GetStats', function wphSetupGetStats(data) {
+            return pdfManager.pdfDocument.xref.stats;
+          });
+          handler.on('UpdatePassword', function wphSetupUpdatePassword(data) {
+            pdfManager.updatePassword(data);
+          });
+          handler.on('GetAnnotations', function wphSetupGetAnnotations(data) {
+            return pdfManager.getPage(data.pageIndex).then(function (page) {
+              return pdfManager.ensure(page, 'getAnnotationsData', [data.intent]);
+            });
+          });
+          handler.on('RenderPageRequest', function wphSetupRenderPage(data) {
+            var pageIndex = data.pageIndex;
+            pdfManager.getPage(pageIndex).then(function (page) {
+              var task = new WorkerTask('RenderPageRequest: page ' + pageIndex);
+              startWorkerTask(task);
+              var pageNum = pageIndex + 1;
+              var start = Date.now();
+              // Pre compile the pdf page and fetch the fonts/images.
+              page.getOperatorList(handler, task, data.intent, data.renderInteractiveForms).then(function (operatorList) {
+                finishWorkerTask(task);
+                info('page=' + pageNum + ' - getOperatorList: time=' + (Date.now() - start) + 'ms, len=' + operatorList.totalLength);
+              }, function (e) {
+                finishWorkerTask(task);
+                if (task.terminated) {
+                  return;
+                }
+                // ignoring errors from the terminated thread
+                // For compatibility with older behavior, generating unknown
+                // unsupported feature notification on errors.
+                handler.send('UnsupportedFeature', { featureId: UNSUPPORTED_FEATURES.unknown });
+                var minimumStackMessage = 'worker.js: while trying to getPage() and getOperatorList()';
+                var wrappedException;
+                // Turn the error into an obj that can be serialized
+                if (typeof e === 'string') {
+                  wrappedException = {
+                    message: e,
+                    stack: minimumStackMessage
+                  };
+                } else if (typeof e === 'object') {
+                  wrappedException = {
+                    message: e.message || e.toString(),
+                    stack: e.stack || minimumStackMessage
+                  };
+                } else {
+                  wrappedException = {
+                    message: 'Unknown exception type: ' + typeof e,
+                    stack: minimumStackMessage
+                  };
+                }
+                handler.send('PageError', {
+                  pageNum: pageNum,
+                  error: wrappedException,
+                  intent: data.intent
+                });
+              });
+            });
+          }, this);
+          handler.on('GetTextContent', function wphExtractText(data) {
+            var pageIndex = data.pageIndex;
+            var normalizeWhitespace = data.normalizeWhitespace;
+            var combineTextItems = data.combineTextItems;
+            return pdfManager.getPage(pageIndex).then(function (page) {
+              var task = new WorkerTask('GetTextContent: page ' + pageIndex);
+              startWorkerTask(task);
+              var pageNum = pageIndex + 1;
+              var start = Date.now();
+              return page.extractTextContent(task, normalizeWhitespace, combineTextItems).then(function (textContent) {
+                finishWorkerTask(task);
+                info('text indexing: page=' + pageNum + ' - time=' + (Date.now() - start) + 'ms');
+                return textContent;
+              }, function (reason) {
+                finishWorkerTask(task);
+                if (task.terminated) {
+                  return;
+                }
+                // ignoring errors from the terminated thread
+                throw reason;
+              });
+            });
+          });
+          handler.on('Cleanup', function wphCleanup(data) {
+            return pdfManager.cleanup();
+          });
+          handler.on('Terminate', function wphTerminate(data) {
+            terminated = true;
+            if (pdfManager) {
+              pdfManager.terminate();
+              pdfManager = null;
+            }
+            if (cancelXHRs) {
+              cancelXHRs();
+            }
+            var waitOn = [];
+            WorkerTasks.forEach(function (task) {
+              waitOn.push(task.finished);
+              task.terminate();
+            });
+            return Promise.all(waitOn).then(function () {
+              // Notice that even if we destroying handler, resolved response promise
+              // must be sent back.
+              handler.destroy();
+              handler = null;
+            });
+          });
+          handler.on('Ready', function wphReady(data) {
+            setupDoc(docParams);
+            docParams = null;
+          });
+          // we don't need docParams anymore -- saving memory.
+          return workerHandlerName;
+        }
+      };
+      function initializeWorker() {
+        var handler = new MessageHandler('worker', 'main', self);
+        WorkerMessageHandler.setup(handler, self);
+        handler.send('ready', null);
+      }
+      // Worker thread (and not node.js)?
+      if (typeof window === 'undefined' && !(typeof module !== 'undefined' && module.require)) {
+        initializeWorker();
+      }
+      exports.setPDFNetworkStreamClass = setPDFNetworkStreamClass;
+      exports.WorkerTask = WorkerTask;
+      exports.WorkerMessageHandler = WorkerMessageHandler;
+    }));
+  }.call(pdfjsLibs));
+  exports.WorkerMessageHandler = pdfjsLibs.pdfjsCoreWorker.WorkerMessageHandler;
+}));
diff --git a/application/basilisk/extensions/pdfjs/content/network.js b/application/basilisk/extensions/pdfjs/content/network.js
new file mode 100644
index 000000000..68c8dd19f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/network.js
@@ -0,0 +1,614 @@
+/* Copyright 2012 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.
+ */
+
+// NOTE: Be careful what goes in this file, as it is also used from the context
+// of the addon. So using warn/error in here will break the addon.
+
+'use strict';
+
+(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define('pdfjs/core/network', ['exports', 'pdfjs/shared/util',
+      'pdfjs/core/worker'], factory);
+  } else if (typeof exports !== 'undefined') {
+    factory(exports, require('../shared/util.js'), require('./worker.js'));
+  } else {
+    factory((root.pdfjsCoreNetwork = {}), root.pdfjsSharedUtil,
+      root.pdfjsCoreWorker);
+  }
+}(this, function (exports, sharedUtil, coreWorker) {
+if (typeof PDFJSDev !== 'undefined' && PDFJSDev.test('FIREFOX || MOZCENTRAL')) {
+  throw new Error('Module "pdfjs/core/network" shall not ' +
+                  'be used with FIREFOX or MOZCENTRAL build.');
+}
+
+  var OK_RESPONSE = 200;
+  var PARTIAL_CONTENT_RESPONSE = 206;
+
+  function NetworkManager(url, args) {
+    this.url = url;
+    args = args || {};
+    this.isHttp = /^https?:/i.test(url);
+    this.httpHeaders = (this.isHttp && args.httpHeaders) || {};
+    this.withCredentials = args.withCredentials || false;
+    this.getXhr = args.getXhr ||
+      function NetworkManager_getXhr() {
+        return new XMLHttpRequest();
+      };
+
+    this.currXhrId = 0;
+    this.pendingRequests = Object.create(null);
+    this.loadedRequests = Object.create(null);
+  }
+
+  function getArrayBuffer(xhr) {
+    var data = xhr.response;
+    if (typeof data !== 'string') {
+      return data;
+    }
+    var length = data.length;
+    var array = new Uint8Array(length);
+    for (var i = 0; i < length; i++) {
+      array[i] = data.charCodeAt(i) & 0xFF;
+    }
+    return array.buffer;
+  }
+
+  var supportsMozChunked =
+    typeof PDFJSDev !== 'undefined' && PDFJSDev.test('CHROME') ? false :
+      (function supportsMozChunkedClosure() {
+    try {
+      var x = new XMLHttpRequest();
+      // Firefox 37- required .open() to be called before setting responseType.
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=707484
+      // Even though the URL is not visited, .open() could fail if the URL is
+      // blocked, e.g. via the connect-src CSP directive or the NoScript addon.
+      // When this error occurs, this feature detection method will mistakenly
+      // report that moz-chunked-arraybuffer is not supported in Firefox 37-.
+      x.open('GET', 'https://example.com');
+      x.responseType = 'moz-chunked-arraybuffer';
+      return x.responseType === 'moz-chunked-arraybuffer';
+    } catch (e) {
+      return false;
+    }
+  })();
+
+  NetworkManager.prototype = {
+    requestRange: function NetworkManager_requestRange(begin, end, listeners) {
+      var args = {
+        begin: begin,
+        end: end
+      };
+      for (var prop in listeners) {
+        args[prop] = listeners[prop];
+      }
+      return this.request(args);
+    },
+
+    requestFull: function NetworkManager_requestFull(listeners) {
+      return this.request(listeners);
+    },
+
+    request: function NetworkManager_request(args) {
+      var xhr = this.getXhr();
+      var xhrId = this.currXhrId++;
+      var pendingRequest = this.pendingRequests[xhrId] = {
+        xhr: xhr
+      };
+
+      xhr.open('GET', this.url);
+      xhr.withCredentials = this.withCredentials;
+      for (var property in this.httpHeaders) {
+        var value = this.httpHeaders[property];
+        if (typeof value === 'undefined') {
+          continue;
+        }
+        xhr.setRequestHeader(property, value);
+      }
+      if (this.isHttp && 'begin' in args && 'end' in args) {
+        var rangeStr = args.begin + '-' + (args.end - 1);
+        xhr.setRequestHeader('Range', 'bytes=' + rangeStr);
+        pendingRequest.expectedStatus = 206;
+      } else {
+        pendingRequest.expectedStatus = 200;
+      }
+
+      var useMozChunkedLoading = supportsMozChunked && !!args.onProgressiveData;
+      if (useMozChunkedLoading) {
+        xhr.responseType = 'moz-chunked-arraybuffer';
+        pendingRequest.onProgressiveData = args.onProgressiveData;
+        pendingRequest.mozChunked = true;
+      } else {
+        xhr.responseType = 'arraybuffer';
+      }
+
+      if (args.onError) {
+        xhr.onerror = function(evt) {
+          args.onError(xhr.status);
+        };
+      }
+      xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
+      xhr.onprogress = this.onProgress.bind(this, xhrId);
+
+      pendingRequest.onHeadersReceived = args.onHeadersReceived;
+      pendingRequest.onDone = args.onDone;
+      pendingRequest.onError = args.onError;
+      pendingRequest.onProgress = args.onProgress;
+
+      xhr.send(null);
+
+      return xhrId;
+    },
+
+    onProgress: function NetworkManager_onProgress(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        // Maybe abortRequest was called...
+        return;
+      }
+
+      if (pendingRequest.mozChunked) {
+        var chunk = getArrayBuffer(pendingRequest.xhr);
+        pendingRequest.onProgressiveData(chunk);
+      }
+
+      var onProgress = pendingRequest.onProgress;
+      if (onProgress) {
+        onProgress(evt);
+      }
+    },
+
+    onStateChange: function NetworkManager_onStateChange(xhrId, evt) {
+      var pendingRequest = this.pendingRequests[xhrId];
+      if (!pendingRequest) {
+        // Maybe abortRequest was called...
+        return;
+      }
+
+      var xhr = pendingRequest.xhr;
+      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
+        pendingRequest.onHeadersReceived();
+        delete pendingRequest.onHeadersReceived;
+      }
+
+      if (xhr.readyState !== 4) {
+        return;
+      }
+
+      if (!(xhrId in this.pendingRequests)) {
+        // The XHR request might have been aborted in onHeadersReceived()
+        // callback, in which case we should abort request
+        return;
+      }
+
+      delete this.pendingRequests[xhrId];
+
+      // success status == 0 can be on ftp, file and other protocols
+      if (xhr.status === 0 && this.isHttp) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
+        return;
+      }
+      var xhrStatus = xhr.status || OK_RESPONSE;
+
+      // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.2:
+      // "A server MAY ignore the Range header". This means it's possible to
+      // get a 200 rather than a 206 response from a range request.
+      var ok_response_on_range_request =
+          xhrStatus === OK_RESPONSE &&
+          pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
+
+      if (!ok_response_on_range_request &&
+          xhrStatus !== pendingRequest.expectedStatus) {
+        if (pendingRequest.onError) {
+          pendingRequest.onError(xhr.status);
+        }
+        return;
+      }
+
+      this.loadedRequests[xhrId] = true;
+
+      var chunk = getArrayBuffer(xhr);
+      if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
+        var rangeHeader = xhr.getResponseHeader('Content-Range');
+        var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
+        var begin = parseInt(matches[1], 10);
+        pendingRequest.onDone({
+          begin: begin,
+          chunk: chunk
+        });
+      } else if (pendingRequest.onProgressiveData) {
+        pendingRequest.onDone(null);
+      } else if (chunk) {
+        pendingRequest.onDone({
+          begin: 0,
+          chunk: chunk
+        });
+      } else if (pendingRequest.onError) {
+        pendingRequest.onError(xhr.status);
+      }
+    },
+
+    hasPendingRequests: function NetworkManager_hasPendingRequests() {
+      for (var xhrId in this.pendingRequests) {
+        return true;
+      }
+      return false;
+    },
+
+    getRequestXhr: function NetworkManager_getXhr(xhrId) {
+      return this.pendingRequests[xhrId].xhr;
+    },
+
+    isStreamingRequest: function NetworkManager_isStreamingRequest(xhrId) {
+      return !!(this.pendingRequests[xhrId].onProgressiveData);
+    },
+
+    isPendingRequest: function NetworkManager_isPendingRequest(xhrId) {
+      return xhrId in this.pendingRequests;
+    },
+
+    isLoadedRequest: function NetworkManager_isLoadedRequest(xhrId) {
+      return xhrId in this.loadedRequests;
+    },
+
+    abortAllRequests: function NetworkManager_abortAllRequests() {
+      for (var xhrId in this.pendingRequests) {
+        this.abortRequest(xhrId | 0);
+      }
+    },
+
+    abortRequest: function NetworkManager_abortRequest(xhrId) {
+      var xhr = this.pendingRequests[xhrId].xhr;
+      delete this.pendingRequests[xhrId];
+      xhr.abort();
+    }
+  };
+
+  var assert = sharedUtil.assert;
+  var createPromiseCapability = sharedUtil.createPromiseCapability;
+  var isInt = sharedUtil.isInt;
+  var MissingPDFException = sharedUtil.MissingPDFException;
+  var UnexpectedResponseException = sharedUtil.UnexpectedResponseException;
+
+  /** @implements {IPDFStream} */
+  function PDFNetworkStream(options) {
+    this._options = options;
+    var source = options.source;
+    this._manager = new NetworkManager(source.url, {
+      httpHeaders: source.httpHeaders,
+      withCredentials: source.withCredentials
+    });
+    this._rangeChunkSize = source.rangeChunkSize;
+    this._fullRequestReader = null;
+    this._rangeRequestReaders = [];
+  }
+
+  PDFNetworkStream.prototype = {
+    _onRangeRequestReaderClosed:
+        function PDFNetworkStream_onRangeRequestReaderClosed(reader) {
+      var i = this._rangeRequestReaders.indexOf(reader);
+      if (i >= 0) {
+        this._rangeRequestReaders.splice(i, 1);
+      }
+    },
+
+    getFullReader: function PDFNetworkStream_getFullReader() {
+      assert(!this._fullRequestReader);
+      this._fullRequestReader =
+        new PDFNetworkStreamFullRequestReader(this._manager, this._options);
+      return this._fullRequestReader;
+    },
+
+    getRangeReader: function PDFNetworkStream_getRangeReader(begin, end) {
+      var reader = new PDFNetworkStreamRangeRequestReader(this._manager,
+                                                          begin, end);
+      reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
+      this._rangeRequestReaders.push(reader);
+      return reader;
+    },
+
+    cancelAllRequests: function PDFNetworkStream_cancelAllRequests(reason) {
+      if (this._fullRequestReader) {
+        this._fullRequestReader.cancel(reason);
+      }
+      var readers = this._rangeRequestReaders.slice(0);
+      readers.forEach(function (reader) {
+        reader.cancel(reason);
+      });
+    }
+  };
+
+  /** @implements {IPDFStreamReader} */
+  function PDFNetworkStreamFullRequestReader(manager, options) {
+    this._manager = manager;
+
+    var source = options.source;
+    var args = {
+      onHeadersReceived: this._onHeadersReceived.bind(this),
+      onProgressiveData: source.disableStream ? null :
+                         this._onProgressiveData.bind(this),
+      onDone: this._onDone.bind(this),
+      onError: this._onError.bind(this),
+      onProgress: this._onProgress.bind(this)
+    };
+    this._url = source.url;
+    this._fullRequestId = manager.requestFull(args);
+    this._headersReceivedCapability = createPromiseCapability();
+    this._disableRange = options.disableRange || false;
+    this._contentLength = source.length; // optional
+    this._rangeChunkSize = source.rangeChunkSize;
+    if (!this._rangeChunkSize && !this._disableRange) {
+      this._disableRange = true;
+    }
+
+    this._isStreamingSupported = false;
+    this._isRangeSupported = false;
+
+    this._cachedChunks = [];
+    this._requests = [];
+    this._done = false;
+    this._storedError = undefined;
+
+    this.onProgress = null;
+  }
+
+  PDFNetworkStreamFullRequestReader.prototype = {
+    _validateRangeRequestCapabilities: function
+        PDFNetworkStreamFullRequestReader_validateRangeRequestCapabilities() {
+
+      if (this._disableRange) {
+        return false;
+      }
+
+      var networkManager = this._manager;
+      var fullRequestXhrId = this._fullRequestId;
+      var fullRequestXhr = networkManager.getRequestXhr(fullRequestXhrId);
+      if (fullRequestXhr.getResponseHeader('Accept-Ranges') !== 'bytes') {
+        return false;
+      }
+
+      var contentEncoding =
+        fullRequestXhr.getResponseHeader('Content-Encoding') || 'identity';
+      if (contentEncoding !== 'identity') {
+        return false;
+      }
+
+      var length = fullRequestXhr.getResponseHeader('Content-Length');
+      length = parseInt(length, 10);
+      if (!isInt(length)) {
+        return false;
+      }
+
+      this._contentLength = length; // setting right content length
+
+      if (length <= 2 * this._rangeChunkSize) {
+        // The file size is smaller than the size of two chunks, so it does
+        // not make any sense to abort the request and retry with a range
+        // request.
+        return false;
+      }
+
+      return true;
+    },
+
+    _onHeadersReceived:
+        function PDFNetworkStreamFullRequestReader_onHeadersReceived() {
+
+      if (this._validateRangeRequestCapabilities()) {
+        this._isRangeSupported = true;
+      }
+
+      var networkManager = this._manager;
+      var fullRequestXhrId = this._fullRequestId;
+      if (networkManager.isStreamingRequest(fullRequestXhrId)) {
+        // We can continue fetching when progressive loading is enabled,
+        // and we don't need the autoFetch feature.
+        this._isStreamingSupported = true;
+      } else if (this._isRangeSupported) {
+        // NOTE: by cancelling the full request, and then issuing range
+        // requests, there will be an issue for sites where you can only
+        // request the pdf once. However, if this is the case, then the
+        // server should not be returning that it can support range
+        // requests.
+        networkManager.abortRequest(fullRequestXhrId);
+      }
+
+      this._headersReceivedCapability.resolve();
+    },
+
+    _onProgressiveData:
+        function PDFNetworkStreamFullRequestReader_onProgressiveData(chunk) {
+      if (this._requests.length > 0) {
+        var requestCapability = this._requests.shift();
+        requestCapability.resolve({value: chunk, done: false});
+      } else {
+        this._cachedChunks.push(chunk);
+      }
+    },
+
+    _onDone: function PDFNetworkStreamFullRequestReader_onDone(args) {
+      if (args) {
+        this._onProgressiveData(args.chunk);
+      }
+      this._done = true;
+      if (this._cachedChunks.length > 0) {
+        return;
+      }
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({value: undefined, done: true});
+      });
+      this._requests = [];
+    },
+
+    _onError: function PDFNetworkStreamFullRequestReader_onError(status) {
+      var url = this._url;
+      var exception;
+      if (status === 404 || status === 0 && /^file:/.test(url)) {
+        exception = new MissingPDFException('Missing PDF "' + url + '".');
+      } else {
+        exception = new UnexpectedResponseException(
+          'Unexpected server response (' + status +
+          ') while retrieving PDF "' + url + '".', status);
+      }
+      this._storedError = exception;
+      this._headersReceivedCapability.reject(exception);
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.reject(exception);
+      });
+      this._requests = [];
+      this._cachedChunks = [];
+    },
+
+    _onProgress: function PDFNetworkStreamFullRequestReader_onProgress(data) {
+      if (this.onProgress) {
+        this.onProgress({
+          loaded: data.loaded,
+          total: data.lengthComputable ? data.total : this._contentLength
+        });
+      }
+    },
+
+    get isRangeSupported() {
+      return this._isRangeSupported;
+    },
+
+    get isStreamingSupported() {
+      return this._isStreamingSupported;
+    },
+
+    get contentLength() {
+      return this._contentLength;
+    },
+
+    get headersReady() {
+      return this._headersReceivedCapability.promise;
+    },
+
+    read: function PDFNetworkStreamFullRequestReader_read() {
+      if (this._storedError) {
+        return Promise.reject(this._storedError);
+      }
+      if (this._cachedChunks.length > 0) {
+        var chunk = this._cachedChunks.shift();
+        return Promise.resolve(chunk);
+      }
+      if (this._done) {
+        return Promise.resolve({value: undefined, done: true});
+      }
+      var requestCapability = createPromiseCapability();
+      this._requests.push(requestCapability);
+      return requestCapability.promise;
+    },
+
+    cancel: function PDFNetworkStreamFullRequestReader_cancel(reason) {
+      this._done = true;
+      this._headersReceivedCapability.reject(reason);
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({value: undefined, done: true});
+      });
+      this._requests = [];
+      if (this._manager.isPendingRequest(this._fullRequestId)) {
+        this._manager.abortRequest(this._fullRequestId);
+      }
+      this._fullRequestReader = null;
+    }
+  };
+
+  /** @implements {IPDFStreamRangeReader} */
+  function PDFNetworkStreamRangeRequestReader(manager, begin, end) {
+    this._manager = manager;
+    var args = {
+      onDone: this._onDone.bind(this),
+      onProgress: this._onProgress.bind(this)
+    };
+    this._requestId = manager.requestRange(begin, end, args);
+    this._requests = [];
+    this._queuedChunk = null;
+    this._done = false;
+
+    this.onProgress = null;
+    this.onClosed = null;
+  }
+
+  PDFNetworkStreamRangeRequestReader.prototype = {
+    _close: function PDFNetworkStreamRangeRequestReader_close() {
+      if (this.onClosed) {
+        this.onClosed(this);
+      }
+    },
+
+    _onDone: function PDFNetworkStreamRangeRequestReader_onDone(data) {
+      var chunk = data.chunk;
+      if (this._requests.length > 0) {
+        var requestCapability = this._requests.shift();
+        requestCapability.resolve({value: chunk, done: false});
+      } else {
+        this._queuedChunk = chunk;
+      }
+      this._done = true;
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({value: undefined, done: true});
+      });
+      this._requests = [];
+      this._close();
+    },
+
+    _onProgress: function PDFNetworkStreamRangeRequestReader_onProgress(evt) {
+      if (!this.isStreamingSupported && this.onProgress) {
+        this.onProgress({
+          loaded: evt.loaded
+        });
+      }
+    },
+
+    get isStreamingSupported() {
+      return false; // TODO allow progressive range bytes loading
+    },
+
+    read: function PDFNetworkStreamRangeRequestReader_read() {
+      if (this._queuedChunk !== null) {
+        var chunk = this._queuedChunk;
+        this._queuedChunk = null;
+        return Promise.resolve({value: chunk, done: false});
+      }
+      if (this._done) {
+        return Promise.resolve({value: undefined, done: true});
+      }
+      var requestCapability = createPromiseCapability();
+      this._requests.push(requestCapability);
+      return requestCapability.promise;
+    },
+
+    cancel: function PDFNetworkStreamRangeRequestReader_cancel(reason) {
+      this._done = true;
+      this._requests.forEach(function (requestCapability) {
+        requestCapability.resolve({value: undefined, done: true});
+      });
+      this._requests = [];
+      if (this._manager.isPendingRequest(this._requestId)) {
+        this._manager.abortRequest(this._requestId);
+      }
+      this._close();
+    }
+  };
+
+  coreWorker.setPDFNetworkStreamClass(PDFNetworkStream);
+
+  exports.PDFNetworkStream = PDFNetworkStream;
+  exports.NetworkManager = NetworkManager;
+}));
+
diff --git a/application/basilisk/extensions/pdfjs/content/pdfjschildbootstrap.js b/application/basilisk/extensions/pdfjs/content/pdfjschildbootstrap.js
new file mode 100644
index 000000000..1f44b9c2e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/pdfjschildbootstrap.js
@@ -0,0 +1,36 @@
+/* Copyright 2014 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.
+*/
+/* jshint esnext:true */
+/* globals Components, PdfjsContentUtils, PdfJs, Services */
+
+'use strict';
+
+/*
+ * pdfjschildbootstrap.js loads into the content process to take care of
+ * initializing our built-in version of pdfjs when running remote.
+ */
+
+Components.utils.import('resource://gre/modules/Services.jsm');
+Components.utils.import('resource://pdf.js/PdfJs.jsm');
+Components.utils.import('resource://pdf.js/PdfjsContentUtils.jsm');
+
+// init content utils shim pdfjs will use to access privileged apis.
+PdfjsContentUtils.init();
+
+if (Services.appinfo.processType === Services.appinfo.PROCESS_TYPE_CONTENT) {
+  // register various pdfjs factories that hook us into content loading.
+  PdfJs.updateRegistration();
+}
+
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-EUC-H.bcmap
new file mode 100644
index 000000000..2655fc70a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-EUC-V.bcmap
new file mode 100644
index 000000000..f1ed85382
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-H.bcmap
new file mode 100644
index 000000000..39e89d333
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-RKSJ-H.bcmap
new file mode 100644
index 000000000..e4167cb51
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-RKSJ-V.bcmap
new file mode 100644
index 000000000..50b1646e9
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-V.bcmap
new file mode 100644
index 000000000..d7af99b5e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78ms-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78ms-RKSJ-H.bcmap
new file mode 100644
index 000000000..37077d01e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78ms-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/78ms-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/78ms-RKSJ-V.bcmap
new file mode 100644
index 000000000..acf23231a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/78ms-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/83pv-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/83pv-RKSJ-H.bcmap
new file mode 100644
index 000000000..2359bc529
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/83pv-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/90ms-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/90ms-RKSJ-H.bcmap
new file mode 100644
index 000000000..af8293829
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/90ms-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/90ms-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/90ms-RKSJ-V.bcmap
new file mode 100644
index 000000000..780549de1
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/90ms-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/90msp-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/90msp-RKSJ-H.bcmap
new file mode 100644
index 000000000..bfd3119c6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/90msp-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/90msp-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/90msp-RKSJ-V.bcmap
new file mode 100644
index 000000000..25ef14ab4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/90msp-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/90pv-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/90pv-RKSJ-H.bcmap
new file mode 100644
index 000000000..02f713bb8
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/90pv-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/90pv-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/90pv-RKSJ-V.bcmap
new file mode 100644
index 000000000..d08e0cc5d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/90pv-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-H.bcmap
new file mode 100644
index 000000000..59442acaf
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-RKSJ-H.bcmap
new file mode 100644
index 000000000..a3065e441
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-RKSJ-V.bcmap
new file mode 100644
index 000000000..040014cfc
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-V.bcmap
new file mode 100644
index 000000000..2f816d320
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Add-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-0.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-0.bcmap
new file mode 100644
index 000000000..88ec04af4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-0.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-1.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-1.bcmap
new file mode 100644
index 000000000..03a501477
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-1.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-2.bcmap
new file mode 100644
index 000000000..2aa95141f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-3.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-3.bcmap
new file mode 100644
index 000000000..86d8b8c79
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-3.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-4.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-4.bcmap
new file mode 100644
index 000000000..f50fc6c14
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-4.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-5.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-5.bcmap
new file mode 100644
index 000000000..6caf4a831
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-5.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-6.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-6.bcmap
new file mode 100644
index 000000000..b77fb0705
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-6.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-UCS2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-UCS2.bcmap
new file mode 100644
index 000000000..69d79a2c2
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-CNS1-UCS2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-0.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-0.bcmap
new file mode 100644
index 000000000..36101083f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-0.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-1.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-1.bcmap
new file mode 100644
index 000000000..707bb1065
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-1.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-2.bcmap
new file mode 100644
index 000000000..f7648cc3f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-3.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-3.bcmap
new file mode 100644
index 000000000..852145890
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-3.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-4.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-4.bcmap
new file mode 100644
index 000000000..e40c63ab1
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-4.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-5.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-5.bcmap
new file mode 100644
index 000000000..d7623b500
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-5.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-UCS2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-UCS2.bcmap
new file mode 100644
index 000000000..758652593
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-GB1-UCS2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-0.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-0.bcmap
new file mode 100644
index 000000000..f0e94ec19
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-0.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-1.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-1.bcmap
new file mode 100644
index 000000000..dad42c5ad
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-1.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-2.bcmap
new file mode 100644
index 000000000..090819a06
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-3.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-3.bcmap
new file mode 100644
index 000000000..087dfc155
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-3.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-4.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-4.bcmap
new file mode 100644
index 000000000..46aa9bffe
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-4.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-5.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-5.bcmap
new file mode 100644
index 000000000..5b4b65cc6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-5.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-6.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-6.bcmap
new file mode 100644
index 000000000..e77d699ab
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-6.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-UCS2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-UCS2.bcmap
new file mode 100644
index 000000000..128a14107
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Japan1-UCS2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-0.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-0.bcmap
new file mode 100644
index 000000000..cef1a9985
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-0.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-1.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-1.bcmap
new file mode 100644
index 000000000..11ffa36df
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-1.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-2.bcmap
new file mode 100644
index 000000000..3172308c7
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-UCS2.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-UCS2.bcmap
new file mode 100644
index 000000000..f3371c0cb
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Adobe-Korea1-UCS2.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5-H.bcmap
new file mode 100644
index 000000000..beb4d2281
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5-V.bcmap
new file mode 100644
index 000000000..2d4f87d50
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/B5pc-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5pc-H.bcmap
new file mode 100644
index 000000000..ce0013167
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5pc-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/B5pc-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5pc-V.bcmap
new file mode 100644
index 000000000..73b99ff2f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/B5pc-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS-EUC-H.bcmap
new file mode 100644
index 000000000..61d1d0cb0
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS-EUC-V.bcmap
new file mode 100644
index 000000000..1a393a51e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS1-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS1-H.bcmap
new file mode 100644
index 000000000..f738e218a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS1-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS1-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS1-V.bcmap
new file mode 100644
index 000000000..9c3169f0d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS1-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS2-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS2-H.bcmap
new file mode 100644
index 000000000..c89b3527f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS2-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS2-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS2-V.bcmap
new file mode 100644
index 000000000..7588cec83
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/CNS2-V.bcmap
@@ -0,0 +1,3 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSEáCNS2-H
\ No newline at end of file
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/ETHK-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETHK-B5-H.bcmap
new file mode 100644
index 000000000..cb29415de
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETHK-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/ETHK-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETHK-B5-V.bcmap
new file mode 100644
index 000000000..f09aec631
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETHK-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/ETen-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETen-B5-H.bcmap
new file mode 100644
index 000000000..c2d77462d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETen-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/ETen-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETen-B5-V.bcmap
new file mode 100644
index 000000000..89bff159e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETen-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/ETenms-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETenms-B5-H.bcmap
new file mode 100644
index 000000000..a7d69db5e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETenms-B5-H.bcmap
@@ -0,0 +1,3 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSEá	ETen-B5-H`
 ^

\ No newline at end of file
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/ETenms-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETenms-B5-V.bcmap
new file mode 100644
index 000000000..adc5d618d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/ETenms-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/EUC-H.bcmap
new file mode 100644
index 000000000..e92ea5b3b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/EUC-V.bcmap
new file mode 100644
index 000000000..7a7c18322
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-H.bcmap
new file mode 100644
index 000000000..3b5cde44d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-RKSJ-H.bcmap
new file mode 100644
index 000000000..ea4d2d97b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-RKSJ-V.bcmap
new file mode 100644
index 000000000..3457c2770
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-V.bcmap
new file mode 100644
index 000000000..4999ca404
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Ext-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-EUC-H.bcmap
new file mode 100644
index 000000000..e39908b98
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-EUC-V.bcmap
new file mode 100644
index 000000000..d5be5446a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-H.bcmap
new file mode 100644
index 000000000..39189c54e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-H.bcmap
@@ -0,0 +1,4 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSE

!!�º]aX!!]`�21�>	�p�z�$]‚�"R‚d�-Uƒ7�*„
4„%�+ „Z „{�/…%…<�9K…b�1]†.�"‡‰`]‡,�"]ˆ
+�"]ˆh�"]‰F�"]Š$�"]‹�"]‹`�"]Œ>�"]��"]�z�"]ŽX�"]�6�"]��"]�r�"]‘P�"]’.�"]“�"]“j�"]”H�"]•&�"]–�"]–b�"]—@�"]˜�"]˜|�"]™Z�"]š8�"]›�"]›t�"]œR�"]�0�"]ž�"]žl�"]ŸJ�"] (�"]¡�"]¡d�"]¢B�"]£ �"X£~�']¤W�"]¥5�"]¦�"]¦q�"]§O�"]¨-�"]©�"]©i�"]ªG�"]«%�"]¬�"]¬a�"]­?�"]®�"]®{�"]¯Y�"]°7�"]±�"]±s�"]²Q�"]³/�"]´
�"]´k�"]µI�"]¶'�"]·�"]·c�"]¸A�"]¹�"]¹}�"]º[�"]»9
\ No newline at end of file
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-V.bcmap
new file mode 100644
index 000000000..310834512
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GB-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK-EUC-H.bcmap
new file mode 100644
index 000000000..05fff7e82
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK-EUC-V.bcmap
new file mode 100644
index 000000000..0cdf6bed6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK2K-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK2K-H.bcmap
new file mode 100644
index 000000000..46f6ba596
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK2K-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK2K-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK2K-V.bcmap
new file mode 100644
index 000000000..d9a947984
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBK2K-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBKp-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBKp-EUC-H.bcmap
new file mode 100644
index 000000000..5cb0af687
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBKp-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBKp-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBKp-EUC-V.bcmap
new file mode 100644
index 000000000..bca93b8ef
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBKp-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-EUC-H.bcmap
new file mode 100644
index 000000000..4b4e2d322
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-EUC-V.bcmap
new file mode 100644
index 000000000..38f706699
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-H.bcmap
new file mode 100644
index 000000000..8437ac337
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-V.bcmap
new file mode 100644
index 000000000..697ab4a8e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBT-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBTpc-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBTpc-EUC-H.bcmap
new file mode 100644
index 000000000..f6e50e893
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBTpc-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBTpc-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBTpc-EUC-V.bcmap
new file mode 100644
index 000000000..6c0d71a2d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBTpc-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBpc-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBpc-EUC-H.bcmap
new file mode 100644
index 000000000..c9edf67cf
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBpc-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/GBpc-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBpc-EUC-V.bcmap
new file mode 100644
index 000000000..31450c97f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/GBpc-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/H.bcmap
new file mode 100644
index 000000000..7b24ea462
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdla-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdla-B5-H.bcmap
new file mode 100644
index 000000000..7d30c0500
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdla-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdla-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdla-B5-V.bcmap
new file mode 100644
index 000000000..78946940d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdla-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdlb-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdlb-B5-H.bcmap
new file mode 100644
index 000000000..d829a2310
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdlb-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdlb-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdlb-B5-V.bcmap
new file mode 100644
index 000000000..2b572b50a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKdlb-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKgccs-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKgccs-B5-H.bcmap
new file mode 100644
index 000000000..971a4f23f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKgccs-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKgccs-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKgccs-B5-V.bcmap
new file mode 100644
index 000000000..d353ca256
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKgccs-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm314-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm314-B5-H.bcmap
new file mode 100644
index 000000000..576dc0111
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm314-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm314-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm314-B5-V.bcmap
new file mode 100644
index 000000000..0e96d0e22
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm314-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm471-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm471-B5-H.bcmap
new file mode 100644
index 000000000..11d170c75
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm471-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm471-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm471-B5-V.bcmap
new file mode 100644
index 000000000..54959bf9e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKm471-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKscs-B5-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKscs-B5-H.bcmap
new file mode 100644
index 000000000..6ef7857ad
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKscs-B5-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/HKscs-B5-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKscs-B5-V.bcmap
new file mode 100644
index 000000000..1fb2fa2a2
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/HKscs-B5-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Hankaku.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Hankaku.bcmap
new file mode 100644
index 000000000..4b8ec7fce
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Hankaku.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Hiragana.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Hiragana.bcmap
new file mode 100644
index 000000000..17e983e77
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Hiragana.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-EUC-H.bcmap
new file mode 100644
index 000000000..a45c65f00
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-EUC-V.bcmap
new file mode 100644
index 000000000..0e7b21f0a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-H.bcmap
new file mode 100644
index 000000000..b9b22b678
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-Johab-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-Johab-H.bcmap
new file mode 100644
index 000000000..2531ffcf4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-Johab-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-Johab-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-Johab-V.bcmap
new file mode 100644
index 000000000..367ceb226
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-Johab-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-V.bcmap
new file mode 100644
index 000000000..6ae2f0b6b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-H.bcmap
new file mode 100644
index 000000000..a8d4240e6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-HW-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-HW-H.bcmap
new file mode 100644
index 000000000..8b4ae18fd
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-HW-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-HW-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-HW-V.bcmap
new file mode 100644
index 000000000..b655dbcfb
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-HW-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-V.bcmap
new file mode 100644
index 000000000..21f97f65b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCms-UHC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCpc-EUC-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCpc-EUC-H.bcmap
new file mode 100644
index 000000000..e06f361eb
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCpc-EUC-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCpc-EUC-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCpc-EUC-V.bcmap
new file mode 100644
index 000000000..f3c9113fc
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/KSCpc-EUC-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Katakana.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Katakana.bcmap
new file mode 100644
index 000000000..524303c4f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Katakana.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/LICENSE b/application/basilisk/extensions/pdfjs/content/web/cmaps/LICENSE
new file mode 100644
index 000000000..b1ad168ad
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/LICENSE
@@ -0,0 +1,36 @@
+%%Copyright: -----------------------------------------------------------
+%%Copyright: Copyright 1990-2009 Adobe Systems Incorporated.
+%%Copyright: All rights reserved.
+%%Copyright:
+%%Copyright: Redistribution and use in source and binary forms, with or
+%%Copyright: without modification, are permitted provided that the
+%%Copyright: following conditions are met:
+%%Copyright:
+%%Copyright: Redistributions of source code must retain the above
+%%Copyright: copyright notice, this list of conditions and the following
+%%Copyright: disclaimer.
+%%Copyright:
+%%Copyright: Redistributions in binary form must reproduce the above
+%%Copyright: copyright notice, this list of conditions and the following
+%%Copyright: disclaimer in the documentation and/or other materials
+%%Copyright: provided with the distribution. 
+%%Copyright:
+%%Copyright: Neither the name of Adobe Systems Incorporated nor the names
+%%Copyright: of its contributors may be used to endorse or promote
+%%Copyright: products derived from this software without specific prior
+%%Copyright: written permission. 
+%%Copyright:
+%%Copyright: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+%%Copyright: CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+%%Copyright: INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%%Copyright: MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+%%Copyright: DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+%%Copyright: CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+%%Copyright: SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+%%Copyright: NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%%Copyright: LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+%%Copyright: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+%%Copyright: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+%%Copyright: OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%%Copyright: SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+%%Copyright: -----------------------------------------------------------
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/NWP-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/NWP-H.bcmap
new file mode 100644
index 000000000..afc5e4b05
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/NWP-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/NWP-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/NWP-V.bcmap
new file mode 100644
index 000000000..bb5785e32
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/NWP-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/RKSJ-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/RKSJ-H.bcmap
new file mode 100644
index 000000000..fb8d298e9
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/RKSJ-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/RKSJ-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/RKSJ-V.bcmap
new file mode 100644
index 000000000..a2555a6c0
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/RKSJ-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/Roman.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/Roman.bcmap
new file mode 100644
index 000000000..f896dcf1c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/Roman.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UCS2-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UCS2-H.bcmap
new file mode 100644
index 000000000..d5db27c5c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UCS2-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UCS2-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UCS2-V.bcmap
new file mode 100644
index 000000000..1dc9b7a21
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UCS2-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF16-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF16-H.bcmap
new file mode 100644
index 000000000..961afefb6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF16-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF16-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF16-V.bcmap
new file mode 100644
index 000000000..df0cffe86
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF16-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF32-H.bcmap
new file mode 100644
index 000000000..1ab18a143
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF32-V.bcmap
new file mode 100644
index 000000000..ad14662e2
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF8-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF8-H.bcmap
new file mode 100644
index 000000000..83c6bd7c4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF8-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF8-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF8-V.bcmap
new file mode 100644
index 000000000..22a27e4dd
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniCNS-UTF8-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UCS2-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UCS2-H.bcmap
new file mode 100644
index 000000000..5bd6228ce
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UCS2-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UCS2-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UCS2-V.bcmap
new file mode 100644
index 000000000..53c534b7f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UCS2-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF16-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF16-H.bcmap
new file mode 100644
index 000000000..b95045b40
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF16-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF16-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF16-V.bcmap
new file mode 100644
index 000000000..51f023e0d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF16-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF32-H.bcmap
new file mode 100644
index 000000000..f0dbd14f3
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF32-V.bcmap
new file mode 100644
index 000000000..ce9c30a98
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF8-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF8-H.bcmap
new file mode 100644
index 000000000..982ca462b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF8-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF8-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF8-V.bcmap
new file mode 100644
index 000000000..f78020dd4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniGB-UTF8-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-H.bcmap
new file mode 100644
index 000000000..7daf56afa
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-H.bcmap
new file mode 100644
index 000000000..ac9975c58
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-V.bcmap
new file mode 100644
index 000000000..3da0a1c62
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-HW-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-V.bcmap
new file mode 100644
index 000000000..c50b9ddfd
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UCS2-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF16-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF16-H.bcmap
new file mode 100644
index 000000000..676134463
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF16-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF16-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF16-V.bcmap
new file mode 100644
index 000000000..70bf90c0e
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF16-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF32-H.bcmap
new file mode 100644
index 000000000..7a83d53ae
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF32-V.bcmap
new file mode 100644
index 000000000..7a8713539
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF8-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF8-H.bcmap
new file mode 100644
index 000000000..9f0334cac
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF8-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF8-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF8-V.bcmap
new file mode 100644
index 000000000..808a94f0f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS-UTF8-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF16-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF16-H.bcmap
new file mode 100644
index 000000000..d768bf811
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF16-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF16-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF16-V.bcmap
new file mode 100644
index 000000000..3d5bf6fb4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF16-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF32-H.bcmap
new file mode 100644
index 000000000..09eee10d4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF32-V.bcmap
new file mode 100644
index 000000000..6c5460013
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF8-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF8-H.bcmap
new file mode 100644
index 000000000..1b1a64f50
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF8-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF8-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF8-V.bcmap
new file mode 100644
index 000000000..994aa9ef9
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJIS2004-UTF8-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UCS2-HW-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UCS2-HW-V.bcmap
new file mode 100644
index 000000000..643f921b6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UCS2-HW-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UCS2-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UCS2-V.bcmap
new file mode 100644
index 000000000..c148f67f5
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UCS2-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UTF8-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UTF8-V.bcmap
new file mode 100644
index 000000000..1849d809a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISPro-UTF8-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX0213-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX0213-UTF32-H.bcmap
new file mode 100644
index 000000000..a83a677c5
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX0213-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX0213-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX0213-UTF32-V.bcmap
new file mode 100644
index 000000000..f527248ad
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX0213-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-H.bcmap
new file mode 100644
index 000000000..e1a988dc9
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-V.bcmap
new file mode 100644
index 000000000..47e054a96
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniJISX02132004-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UCS2-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UCS2-H.bcmap
new file mode 100644
index 000000000..b5b94852a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UCS2-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UCS2-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UCS2-V.bcmap
new file mode 100644
index 000000000..026adcaad
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UCS2-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF16-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF16-H.bcmap
new file mode 100644
index 000000000..fd4e66e81
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF16-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF16-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF16-V.bcmap
new file mode 100644
index 000000000..075efb705
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF16-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF32-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF32-H.bcmap
new file mode 100644
index 000000000..769d2142c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF32-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF32-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF32-V.bcmap
new file mode 100644
index 000000000..bdab208b6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF32-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF8-H.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF8-H.bcmap
new file mode 100644
index 000000000..6ff8674af
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF8-H.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF8-V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF8-V.bcmap
new file mode 100644
index 000000000..8dfa76a58
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/UniKS-UTF8-V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/V.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/V.bcmap
new file mode 100644
index 000000000..fdec99066
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/V.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/cmaps/WP-Symbol.bcmap b/application/basilisk/extensions/pdfjs/content/web/cmaps/WP-Symbol.bcmap
new file mode 100644
index 000000000..46729bbf3
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/cmaps/WP-Symbol.bcmap
diff --git a/application/basilisk/extensions/pdfjs/content/web/debugger.js b/application/basilisk/extensions/pdfjs/content/web/debugger.js
new file mode 100644
index 000000000..8a049f4c6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/debugger.js
@@ -0,0 +1,616 @@
+/* Copyright 2012 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.
+ */
+
+'use strict';
+
+var FontInspector = (function FontInspectorClosure() {
+  var fonts;
+  var active = false;
+  var fontAttribute = 'data-font-name';
+  function removeSelection() {
+    var divs = document.querySelectorAll('div[' + fontAttribute + ']');
+    for (var i = 0, ii = divs.length; i < ii; ++i) {
+      var div = divs[i];
+      div.className = '';
+    }
+  }
+  function resetSelection() {
+    var divs = document.querySelectorAll('div[' + fontAttribute + ']');
+    for (var i = 0, ii = divs.length; i < ii; ++i) {
+      var div = divs[i];
+      div.className = 'debuggerHideText';
+    }
+  }
+  function selectFont(fontName, show) {
+    var divs = document.querySelectorAll('div[' + fontAttribute + '=' +
+                                         fontName + ']');
+    for (var i = 0, ii = divs.length; i < ii; ++i) {
+      var div = divs[i];
+      div.className = show ? 'debuggerShowText' : 'debuggerHideText';
+    }
+  }
+  function textLayerClick(e) {
+    if (!e.target.dataset.fontName ||
+        e.target.tagName.toUpperCase() !== 'DIV') {
+      return;
+    }
+    var fontName = e.target.dataset.fontName;
+    var selects = document.getElementsByTagName('input');
+    for (var i = 0; i < selects.length; ++i) {
+      var select = selects[i];
+      if (select.dataset.fontName !== fontName) {
+        continue;
+      }
+      select.checked = !select.checked;
+      selectFont(fontName, select.checked);
+      select.scrollIntoView();
+    }
+  }
+  return {
+    // Properties/functions needed by PDFBug.
+    id: 'FontInspector',
+    name: 'Font Inspector',
+    panel: null,
+    manager: null,
+    init: function init(pdfjsLib) {
+      var panel = this.panel;
+      panel.setAttribute('style', 'padding: 5px;');
+      var tmp = document.createElement('button');
+      tmp.addEventListener('click', resetSelection);
+      tmp.textContent = 'Refresh';
+      panel.appendChild(tmp);
+
+      fonts = document.createElement('div');
+      panel.appendChild(fonts);
+    },
+    cleanup: function cleanup() {
+      fonts.textContent = '';
+    },
+    enabled: false,
+    get active() {
+      return active;
+    },
+    set active(value) {
+      active = value;
+      if (active) {
+        document.body.addEventListener('click', textLayerClick, true);
+        resetSelection();
+      } else {
+        document.body.removeEventListener('click', textLayerClick, true);
+        removeSelection();
+      }
+    },
+    // FontInspector specific functions.
+    fontAdded: function fontAdded(fontObj, url) {
+      function properties(obj, list) {
+        var moreInfo = document.createElement('table');
+        for (var i = 0; i < list.length; i++) {
+          var tr = document.createElement('tr');
+          var td1 = document.createElement('td');
+          td1.textContent = list[i];
+          tr.appendChild(td1);
+          var td2 = document.createElement('td');
+          td2.textContent = obj[list[i]].toString();
+          tr.appendChild(td2);
+          moreInfo.appendChild(tr);
+        }
+        return moreInfo;
+      }
+      var moreInfo = properties(fontObj, ['name', 'type']);
+      var fontName = fontObj.loadedName;
+      var font = document.createElement('div');
+      var name = document.createElement('span');
+      name.textContent = fontName;
+      var download = document.createElement('a');
+      if (url) {
+        url = /url\(['"]?([^\)"']+)/.exec(url);
+        download.href = url[1];
+      } else if (fontObj.data) {
+        url = URL.createObjectURL(new Blob([fontObj.data], {
+          type: fontObj.mimeType
+        }));
+        download.href = url;
+      }
+      download.textContent = 'Download';
+      var logIt = document.createElement('a');
+      logIt.href = '';
+      logIt.textContent = 'Log';
+      logIt.addEventListener('click', function(event) {
+        event.preventDefault();
+        console.log(fontObj);
+      });
+      var select = document.createElement('input');
+      select.setAttribute('type', 'checkbox');
+      select.dataset.fontName = fontName;
+      select.addEventListener('click', (function(select, fontName) {
+        return (function() {
+           selectFont(fontName, select.checked);
+        });
+      })(select, fontName));
+      font.appendChild(select);
+      font.appendChild(name);
+      font.appendChild(document.createTextNode(' '));
+      font.appendChild(download);
+      font.appendChild(document.createTextNode(' '));
+      font.appendChild(logIt);
+      font.appendChild(moreInfo);
+      fonts.appendChild(font);
+      // Somewhat of a hack, should probably add a hook for when the text layer
+      // is done rendering.
+      setTimeout(function() {
+        if (this.active) {
+          resetSelection();
+        }
+      }.bind(this), 2000);
+    }
+  };
+})();
+
+var opMap;
+
+// Manages all the page steppers.
+var StepperManager = (function StepperManagerClosure() {
+  var steppers = [];
+  var stepperDiv = null;
+  var stepperControls = null;
+  var stepperChooser = null;
+  var breakPoints = Object.create(null);
+  return {
+    // Properties/functions needed by PDFBug.
+    id: 'Stepper',
+    name: 'Stepper',
+    panel: null,
+    manager: null,
+    init: function init(pdfjsLib) {
+      var self = this;
+      this.panel.setAttribute('style', 'padding: 5px;');
+      stepperControls = document.createElement('div');
+      stepperChooser = document.createElement('select');
+      stepperChooser.addEventListener('change', function(event) {
+        self.selectStepper(this.value);
+      });
+      stepperControls.appendChild(stepperChooser);
+      stepperDiv = document.createElement('div');
+      this.panel.appendChild(stepperControls);
+      this.panel.appendChild(stepperDiv);
+      if (sessionStorage.getItem('pdfjsBreakPoints')) {
+        breakPoints = JSON.parse(sessionStorage.getItem('pdfjsBreakPoints'));
+      }
+
+      opMap = Object.create(null);
+      for (var key in pdfjsLib.OPS) {
+        opMap[pdfjsLib.OPS[key]] = key;
+      }
+    },
+    cleanup: function cleanup() {
+      stepperChooser.textContent = '';
+      stepperDiv.textContent = '';
+      steppers = [];
+    },
+    enabled: false,
+    active: false,
+    // Stepper specific functions.
+    create: function create(pageIndex) {
+      var debug = document.createElement('div');
+      debug.id = 'stepper' + pageIndex;
+      debug.setAttribute('hidden', true);
+      debug.className = 'stepper';
+      stepperDiv.appendChild(debug);
+      var b = document.createElement('option');
+      b.textContent = 'Page ' + (pageIndex + 1);
+      b.value = pageIndex;
+      stepperChooser.appendChild(b);
+      var initBreakPoints = breakPoints[pageIndex] || [];
+      var stepper = new Stepper(debug, pageIndex, initBreakPoints);
+      steppers.push(stepper);
+      if (steppers.length === 1) {
+        this.selectStepper(pageIndex, false);
+      }
+      return stepper;
+    },
+    selectStepper: function selectStepper(pageIndex, selectPanel) {
+      var i;
+      pageIndex = pageIndex | 0;
+      if (selectPanel) {
+        this.manager.selectPanel(this);
+      }
+      for (i = 0; i < steppers.length; ++i) {
+        var stepper = steppers[i];
+        if (stepper.pageIndex === pageIndex) {
+          stepper.panel.removeAttribute('hidden');
+        } else {
+          stepper.panel.setAttribute('hidden', true);
+        }
+      }
+      var options = stepperChooser.options;
+      for (i = 0; i < options.length; ++i) {
+        var option = options[i];
+        option.selected = (option.value | 0) === pageIndex;
+      }
+    },
+    saveBreakPoints: function saveBreakPoints(pageIndex, bps) {
+      breakPoints[pageIndex] = bps;
+      sessionStorage.setItem('pdfjsBreakPoints', JSON.stringify(breakPoints));
+    }
+  };
+})();
+
+// The stepper for each page's IRQueue.
+var Stepper = (function StepperClosure() {
+  // Shorter way to create element and optionally set textContent.
+  function c(tag, textContent) {
+    var d = document.createElement(tag);
+    if (textContent) {
+      d.textContent = textContent;
+    }
+    return d;
+  }
+
+  function simplifyArgs(args) {
+    if (typeof args === 'string') {
+      var MAX_STRING_LENGTH = 75;
+      return args.length <= MAX_STRING_LENGTH ? args :
+        args.substr(0, MAX_STRING_LENGTH) + '...';
+    }
+    if (typeof args !== 'object' || args === null) {
+      return args;
+    }
+    if ('length' in args) { // array
+      var simpleArgs = [], i, ii;
+      var MAX_ITEMS = 10;
+      for (i = 0, ii = Math.min(MAX_ITEMS, args.length); i < ii; i++) {
+        simpleArgs.push(simplifyArgs(args[i]));
+      }
+      if (i < args.length) {
+        simpleArgs.push('...');
+      }
+      return simpleArgs;
+    }
+    var simpleObj = {};
+    for (var key in args) {
+      simpleObj[key] = simplifyArgs(args[key]);
+    }
+    return simpleObj;
+  }
+
+  function Stepper(panel, pageIndex, initialBreakPoints) {
+    this.panel = panel;
+    this.breakPoint = 0;
+    this.nextBreakPoint = null;
+    this.pageIndex = pageIndex;
+    this.breakPoints = initialBreakPoints;
+    this.currentIdx = -1;
+    this.operatorListIdx = 0;
+  }
+  Stepper.prototype = {
+    init: function init(operatorList) {
+      var panel = this.panel;
+      var content = c('div', 'c=continue, s=step');
+      var table = c('table');
+      content.appendChild(table);
+      table.cellSpacing = 0;
+      var headerRow = c('tr');
+      table.appendChild(headerRow);
+      headerRow.appendChild(c('th', 'Break'));
+      headerRow.appendChild(c('th', 'Idx'));
+      headerRow.appendChild(c('th', 'fn'));
+      headerRow.appendChild(c('th', 'args'));
+      panel.appendChild(content);
+      this.table = table;
+      this.updateOperatorList(operatorList);
+    },
+    updateOperatorList: function updateOperatorList(operatorList) {
+      var self = this;
+
+      function cboxOnClick() {
+        var x = +this.dataset.idx;
+        if (this.checked) {
+          self.breakPoints.push(x);
+        } else {
+          self.breakPoints.splice(self.breakPoints.indexOf(x), 1);
+        }
+        StepperManager.saveBreakPoints(self.pageIndex, self.breakPoints);
+      }
+
+      var MAX_OPERATORS_COUNT = 15000;
+      if (this.operatorListIdx > MAX_OPERATORS_COUNT) {
+        return;
+      }
+
+      var chunk = document.createDocumentFragment();
+      var operatorsToDisplay = Math.min(MAX_OPERATORS_COUNT,
+                                        operatorList.fnArray.length);
+      for (var i = this.operatorListIdx; i < operatorsToDisplay; i++) {
+        var line = c('tr');
+        line.className = 'line';
+        line.dataset.idx = i;
+        chunk.appendChild(line);
+        var checked = this.breakPoints.indexOf(i) !== -1;
+        var args = operatorList.argsArray[i] || [];
+
+        var breakCell = c('td');
+        var cbox = c('input');
+        cbox.type = 'checkbox';
+        cbox.className = 'points';
+        cbox.checked = checked;
+        cbox.dataset.idx = i;
+        cbox.onclick = cboxOnClick;
+
+        breakCell.appendChild(cbox);
+        line.appendChild(breakCell);
+        line.appendChild(c('td', i.toString()));
+        var fn = opMap[operatorList.fnArray[i]];
+        var decArgs = args;
+        if (fn === 'showText') {
+          var glyphs = args[0];
+          var newArgs = [];
+          var str = [];
+          for (var j = 0; j < glyphs.length; j++) {
+            var glyph = glyphs[j];
+            if (typeof glyph === 'object' && glyph !== null) {
+              str.push(glyph.fontChar);
+            } else {
+              if (str.length > 0) {
+                newArgs.push(str.join(''));
+                str = [];
+              }
+              newArgs.push(glyph); // null or number
+            }
+          }
+          if (str.length > 0) {
+            newArgs.push(str.join(''));
+          }
+          decArgs = [newArgs];
+        }
+        line.appendChild(c('td', fn));
+        line.appendChild(c('td', JSON.stringify(simplifyArgs(decArgs))));
+      }
+      if (operatorsToDisplay < operatorList.fnArray.length) {
+        line = c('tr');
+        var lastCell = c('td', '...');
+        lastCell.colspan = 4;
+        chunk.appendChild(lastCell);
+      }
+      this.operatorListIdx = operatorList.fnArray.length;
+      this.table.appendChild(chunk);
+    },
+    getNextBreakPoint: function getNextBreakPoint() {
+      this.breakPoints.sort(function(a, b) { return a - b; });
+      for (var i = 0; i < this.breakPoints.length; i++) {
+        if (this.breakPoints[i] > this.currentIdx) {
+          return this.breakPoints[i];
+        }
+      }
+      return null;
+    },
+    breakIt: function breakIt(idx, callback) {
+      StepperManager.selectStepper(this.pageIndex, true);
+      var self = this;
+      var dom = document;
+      self.currentIdx = idx;
+      var listener = function(e) {
+        switch (e.keyCode) {
+          case 83: // step
+            dom.removeEventListener('keydown', listener, false);
+            self.nextBreakPoint = self.currentIdx + 1;
+            self.goTo(-1);
+            callback();
+            break;
+          case 67: // continue
+            dom.removeEventListener('keydown', listener, false);
+            var breakPoint = self.getNextBreakPoint();
+            self.nextBreakPoint = breakPoint;
+            self.goTo(-1);
+            callback();
+            break;
+        }
+      };
+      dom.addEventListener('keydown', listener, false);
+      self.goTo(idx);
+    },
+    goTo: function goTo(idx) {
+      var allRows = this.panel.getElementsByClassName('line');
+      for (var x = 0, xx = allRows.length; x < xx; ++x) {
+        var row = allRows[x];
+        if ((row.dataset.idx | 0) === idx) {
+          row.style.backgroundColor = 'rgb(251,250,207)';
+          row.scrollIntoView();
+        } else {
+          row.style.backgroundColor = null;
+        }
+      }
+    }
+  };
+  return Stepper;
+})();
+
+var Stats = (function Stats() {
+  var stats = [];
+  function clear(node) {
+    while (node.hasChildNodes()) {
+      node.removeChild(node.lastChild);
+    }
+  }
+  function getStatIndex(pageNumber) {
+    for (var i = 0, ii = stats.length; i < ii; ++i) {
+      if (stats[i].pageNumber === pageNumber) {
+        return i;
+      }
+    }
+    return false;
+  }
+  return {
+    // Properties/functions needed by PDFBug.
+    id: 'Stats',
+    name: 'Stats',
+    panel: null,
+    manager: null,
+    init: function init(pdfjsLib) {
+      this.panel.setAttribute('style', 'padding: 5px;');
+      pdfjsLib.PDFJS.enableStats = true;
+    },
+    enabled: false,
+    active: false,
+    // Stats specific functions.
+    add: function(pageNumber, stat) {
+      if (!stat) {
+        return;
+      }
+      var statsIndex = getStatIndex(pageNumber);
+      if (statsIndex !== false) {
+        var b = stats[statsIndex];
+        this.panel.removeChild(b.div);
+        stats.splice(statsIndex, 1);
+      }
+      var wrapper = document.createElement('div');
+      wrapper.className = 'stats';
+      var title = document.createElement('div');
+      title.className = 'title';
+      title.textContent = 'Page: ' + pageNumber;
+      var statsDiv = document.createElement('div');
+      statsDiv.textContent = stat.toString();
+      wrapper.appendChild(title);
+      wrapper.appendChild(statsDiv);
+      stats.push({ pageNumber: pageNumber, div: wrapper });
+      stats.sort(function(a, b) { return a.pageNumber - b.pageNumber; });
+      clear(this.panel);
+      for (var i = 0, ii = stats.length; i < ii; ++i) {
+        this.panel.appendChild(stats[i].div);
+      }
+    },
+    cleanup: function () {
+      stats = [];
+      clear(this.panel);
+    }
+  };
+})();
+
+// Manages all the debugging tools.
+var PDFBug = (function PDFBugClosure() {
+  var panelWidth = 300;
+  var buttons = [];
+  var activePanel = null;
+
+  return {
+    tools: [
+      FontInspector,
+      StepperManager,
+      Stats
+    ],
+    enable: function(ids) {
+      var all = false, tools = this.tools;
+      if (ids.length === 1 && ids[0] === 'all') {
+        all = true;
+      }
+      for (var i = 0; i < tools.length; ++i) {
+        var tool = tools[i];
+        if (all || ids.indexOf(tool.id) !== -1) {
+          tool.enabled = true;
+        }
+      }
+      if (!all) {
+        // Sort the tools by the order they are enabled.
+        tools.sort(function(a, b) {
+          var indexA = ids.indexOf(a.id);
+          indexA = indexA < 0 ? tools.length : indexA;
+          var indexB = ids.indexOf(b.id);
+          indexB = indexB < 0 ? tools.length : indexB;
+          return indexA - indexB;
+        });
+      }
+    },
+    init: function init(pdfjsLib, container) {
+      /*
+       * Basic Layout:
+       * PDFBug
+       *  Controls
+       *  Panels
+       *    Panel
+       *    Panel
+       *    ...
+       */
+      var ui = document.createElement('div');
+      ui.id = 'PDFBug';
+
+      var controls = document.createElement('div');
+      controls.setAttribute('class', 'controls');
+      ui.appendChild(controls);
+
+      var panels = document.createElement('div');
+      panels.setAttribute('class', 'panels');
+      ui.appendChild(panels);
+
+      container.appendChild(ui);
+      container.style.right = panelWidth + 'px';
+
+      // Initialize all the debugging tools.
+      var tools = this.tools;
+      var self = this;
+      for (var i = 0; i < tools.length; ++i) {
+        var tool = tools[i];
+        var panel = document.createElement('div');
+        var panelButton = document.createElement('button');
+        panelButton.textContent = tool.name;
+        panelButton.addEventListener('click', (function(selected) {
+          return function(event) {
+            event.preventDefault();
+            self.selectPanel(selected);
+          };
+        })(i));
+        controls.appendChild(panelButton);
+        panels.appendChild(panel);
+        tool.panel = panel;
+        tool.manager = this;
+        if (tool.enabled) {
+          tool.init(pdfjsLib);
+        } else {
+          panel.textContent = tool.name + ' is disabled. To enable add ' +
+                              ' "' + tool.id + '" to the pdfBug parameter ' +
+                              'and refresh (separate multiple by commas).';
+        }
+        buttons.push(panelButton);
+      }
+      this.selectPanel(0);
+    },
+    cleanup: function cleanup() {
+      for (var i = 0, ii = this.tools.length; i < ii; i++) {
+        if (this.tools[i].enabled) {
+          this.tools[i].cleanup();
+        }
+      }
+    },
+    selectPanel: function selectPanel(index) {
+      if (typeof index !== 'number') {
+        index = this.tools.indexOf(index);
+      }
+      if (index === activePanel) {
+        return;
+      }
+      activePanel = index;
+      var tools = this.tools;
+      for (var j = 0; j < tools.length; ++j) {
+        if (j === index) {
+          buttons[j].setAttribute('class', 'active');
+          tools[j].active = true;
+          tools[j].panel.removeAttribute('hidden');
+        } else {
+          buttons[j].setAttribute('class', '');
+          tools[j].active = false;
+          tools[j].panel.setAttribute('hidden', 'true');
+        }
+      }
+    }
+  };
+})();
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-check.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-check.svg
new file mode 100644
index 000000000..71cd16df5
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-check.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <path
+     d="M 1.5006714,23.536225 6.8925879,18.994244 14.585721,26.037937 34.019683,4.5410479 38.499329,9.2235032 14.585721,35.458952 z"
+     id="path4"
+     style="fill:#ffff00;fill-opacity:1;stroke:#000000;stroke-width:1.25402856;stroke-opacity:1" />
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-comment.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-comment.svg
new file mode 100644
index 000000000..86f1f1724
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-comment.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   height="40"
+   width="40"
+   viewBox="0 0 40 40">
+  <rect
+     style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+     width="33.76017"
+     height="33.76017"
+     x="3.119915"
+     y="3.119915" />
+  <path
+     d="m 20.677967,8.54499 c -7.342801,0 -13.295293,4.954293 -13.295293,11.065751 0,2.088793 0.3647173,3.484376 1.575539,5.150563 L 6.0267418,31.45501 13.560595,29.011117 c 2.221262,1.387962 4.125932,1.665377 7.117372,1.665377 7.3428,0 13.295291,-4.954295 13.295291,-11.065753 0,-6.111458 -5.952491,-11.065751 -13.295291,-11.065751 z"
+     style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.93031836;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"/>
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-help.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-help.svg
new file mode 100644
index 000000000..00938fefe
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-help.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <g
+     transform="translate(0,-60)"
+     id="layer1">
+    <rect
+       width="36.460953"
+       height="34.805603"
+       x="1.7695236"
+       y="62.597198"
+       style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.30826771;stroke-opacity:1" />
+    <g
+       transform="matrix(0.88763677,0,0,0.88763677,2.2472646,8.9890584)">
+      <path
+         d="M 20,64.526342 C 11.454135,64.526342 4.5263421,71.454135 4.5263421,80 4.5263421,88.545865 11.454135,95.473658 20,95.473658 28.545865,95.473658 35.473658,88.545865 35.473658,80 35.473658,71.454135 28.545865,64.526342 20,64.526342 z m -0.408738,9.488564 c 3.527079,0 6.393832,2.84061 6.393832,6.335441 0,3.494831 -2.866753,6.335441 -6.393832,6.335441 -3.527079,0 -6.393832,-2.84061 -6.393832,-6.335441 0,-3.494831 2.866753,-6.335441 6.393832,-6.335441 z"
+         style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:1.02768445;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+      <path
+         d="m 7.2335209,71.819938 4.9702591,4.161823 c -1.679956,2.581606 -1.443939,6.069592 0.159325,8.677725 l -5.1263071,3.424463 c 0.67516,1.231452 3.0166401,3.547686 4.2331971,4.194757 l 3.907728,-4.567277 c 2.541952,1.45975 5.730694,1.392161 8.438683,-0.12614 l 3.469517,6.108336 c 1.129779,-0.44367 4.742234,-3.449633 5.416358,-5.003859 l -5.46204,-4.415541 c 1.44319,-2.424098 1.651175,-5.267515 0.557303,-7.748623 l 5.903195,-3.833951 C 33.14257,71.704996 30.616217,69.018606 29.02952,67.99296 l -4.118813,4.981678 C 22.411934,71.205099 18.900853,70.937534 16.041319,72.32916 l -3.595408,-5.322091 c -1.345962,0.579488 -4.1293881,2.921233 -5.2123901,4.812869 z m 8.1010311,3.426672 c 2.75284,-2.446266 6.769149,-2.144694 9.048998,0.420874 2.279848,2.56557 2.113919,6.596919 -0.638924,9.043185 -2.752841,2.446267 -6.775754,2.13726 -9.055604,-0.428308 -2.279851,-2.565568 -2.107313,-6.589485 0.64553,-9.035751 z"
+         style="fill:#000000;fill-opacity:1;stroke:none" />
+    </g>
+  </g>
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-insert.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-insert.svg
new file mode 100644
index 000000000..519ef6826
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-insert.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64">
+  <path
+     d="M 32.003143,1.4044602 57.432701,62.632577 6.5672991,62.627924 z"
+     style="fill:#ffff00;fill-opacity:0.94117647;fill-rule:nonzero;stroke:#000000;stroke-width:1.00493038;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-key.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-key.svg
new file mode 100644
index 000000000..8d09d5378
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-key.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64">
+  <path
+     d="M 25.470843,9.4933766 C 25.30219,12.141818 30.139101,14.445969 34.704831,13.529144 40.62635,12.541995 41.398833,7.3856498 35.97505,5.777863 31.400921,4.1549155 25.157674,6.5445892 25.470843,9.4933766 z M 4.5246282,17.652051 C 4.068249,11.832873 9.2742983,5.9270407 18.437379,3.0977088 29.751911,-0.87185184 45.495663,1.4008022 53.603953,7.1104009 c 9.275765,6.1889221 7.158128,16.2079421 -3.171076,21.5939521 -1.784316,1.635815 -6.380222,1.21421 -7.068351,3.186186 -1.04003,0.972427 -1.288046,2.050158 -1.232864,3.168203 1.015111,2.000108 -3.831548,1.633216 -3.270553,3.759574 0.589477,5.264544 -0.179276,10.53738 -0.362842,15.806257 -0.492006,2.184998 1.163456,4.574232 -0.734888,6.610642 -2.482919,2.325184 -7.30604,2.189143 -9.193497,-0.274767 -2.733688,-1.740626 -8.254447,-3.615254 -6.104247,-6.339626 3.468112,-1.708686 -2.116197,-3.449897 0.431242,-5.080274 5.058402,-1.39256 -2.393215,-2.304318 -0.146889,-4.334645 3.069198,-0.977415 2.056986,-2.518352 -0.219121,-3.540397 1.876567,-1.807151 1.484149,-4.868919 -2.565455,-5.942205 0.150866,-1.805474 2.905737,-4.136876 -1.679967,-5.20493 C 10.260902,27.882167 4.6872697,22.95045 4.5245945,17.652051 z"
+     id="path604"
+     style="fill:#ffff00;fill-opacity:1;stroke:#000000;stroke-width:1.72665179;stroke-opacity:1" />
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-newparagraph.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-newparagraph.svg
new file mode 100644
index 000000000..38d2497da
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-newparagraph.svg
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="64"
+   height="64"
+   viewBox="0 0 64 64">
+  <path
+     d="M 32.003143,10.913072 57.432701,53.086929 6.567299,53.083723 z"
+     id="path2985"
+     style="fill:#ffff00;fill-opacity:0.94117647;fill-rule:nonzero;stroke:#000000;stroke-width:0.83403099;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-noicon.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-noicon.svg
new file mode 100644
index 000000000..c07d10808
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-noicon.svg
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-note.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-note.svg
new file mode 100644
index 000000000..70173651c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-note.svg
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <rect
+     width="36.075428"
+     height="31.096582"
+     x="1.962286"
+     y="4.4517088"
+     id="rect4"
+     style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.23004246;stroke-opacity:1" />
+  <rect
+     width="27.96859"
+     height="1.5012145"
+     x="6.0157046"
+     y="10.285"
+     id="rect6"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+  <rect
+     width="27.96859"
+     height="0.85783684"
+     x="6.0157056"
+     y="23.21689"
+     id="rect8"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+  <rect
+     width="27.96859"
+     height="0.85783684"
+     x="5.8130345"
+     y="28.964394"
+     id="rect10"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+  <rect
+     width="27.96859"
+     height="0.85783684"
+     x="6.0157046"
+     y="17.426493"
+     id="rect12"
+     style="fill:#000000;fill-opacity:1;stroke:none" />
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/annotation-paragraph.svg b/application/basilisk/extensions/pdfjs/content/web/images/annotation-paragraph.svg
new file mode 100644
index 000000000..6ae5212b7
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/annotation-paragraph.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns="http://www.w3.org/2000/svg"
+   width="40"
+   height="40"
+   viewBox="0 0 40 40">
+  <rect
+     width="33.76017"
+     height="33.76017"
+     x="3.119915"
+     y="3.119915"
+     style="fill:#ffff00;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none" />
+  <path
+     d="m 17.692678,34.50206 0,-16.182224 c -1.930515,-0.103225 -3.455824,-0.730383 -4.57593,-1.881473 -1.12011,-1.151067 -1.680164,-2.619596 -1.680164,-4.405591 0,-1.992435 0.621995,-3.5796849 1.865988,-4.7617553 1.243989,-1.1820288 3.06352,-1.7730536 5.458598,-1.7730764 l 9.802246,0 0,2.6789711 -2.229895,0 0,26.3251486 -2.632515,0 0,-26.3251486 -3.45324,0 0,26.3251486 z"
+     style="font-size:29.42051125px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:1.07795751;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" />
+</svg>
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next-rtl.png
new file mode 100644
index 000000000..bef02743f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next-rtl@2x.png
new file mode 100644
index 000000000..1da6dc949
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next.png
new file mode 100644
index 000000000..de1d0fc90
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next@2x.png
new file mode 100644
index 000000000..0250307c0
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-next@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous-rtl.png
new file mode 100644
index 000000000..de1d0fc90
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous-rtl@2x.png
new file mode 100644
index 000000000..0250307c0
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous.png
new file mode 100644
index 000000000..bef02743f
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous@2x.png
new file mode 100644
index 000000000..1da6dc949
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/findbarButton-previous@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/grab.cur b/application/basilisk/extensions/pdfjs/content/web/images/grab.cur
new file mode 100644
index 000000000..db7ad5aed
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/grab.cur
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/grabbing.cur b/application/basilisk/extensions/pdfjs/content/web/images/grabbing.cur
new file mode 100644
index 000000000..e0dfd04e4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/grabbing.cur
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/loading-icon.gif b/application/basilisk/extensions/pdfjs/content/web/images/loading-icon.gif
new file mode 100644
index 000000000..1c72ebb55
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/loading-icon.gif
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/loading-small.png b/application/basilisk/extensions/pdfjs/content/web/images/loading-small.png
new file mode 100644
index 000000000..8831a8058
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/loading-small.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/loading-small@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/loading-small@2x.png
new file mode 100644
index 000000000..b25b4452a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/loading-small@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-documentProperties.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-documentProperties.png
new file mode 100644
index 000000000..40925e25a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-documentProperties.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-documentProperties@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-documentProperties@2x.png
new file mode 100644
index 000000000..adb240eaa
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-documentProperties@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-firstPage.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-firstPage.png
new file mode 100644
index 000000000..e68846aa5
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-firstPage.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-firstPage@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-firstPage@2x.png
new file mode 100644
index 000000000..3ad8af517
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-firstPage@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-handTool.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-handTool.png
new file mode 100644
index 000000000..cb85a841b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-handTool.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-handTool@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-handTool@2x.png
new file mode 100644
index 000000000..5c13f77ff
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-handTool@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-lastPage.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-lastPage.png
new file mode 100644
index 000000000..be763e0c4
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-lastPage.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-lastPage@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-lastPage@2x.png
new file mode 100644
index 000000000..8570984f2
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-lastPage@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw.png
new file mode 100644
index 000000000..675d6da2c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw@2x.png
new file mode 100644
index 000000000..b9e743122
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCcw@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCw.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCw.png
new file mode 100644
index 000000000..e1c759888
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCw.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCw@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCw@2x.png
new file mode 100644
index 000000000..cb257b41c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/secondaryToolbarButton-rotateCw@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/shadow.png b/application/basilisk/extensions/pdfjs/content/web/images/shadow.png
new file mode 100644
index 000000000..31d3bdb14
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/shadow.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/texture.png b/application/basilisk/extensions/pdfjs/content/web/images/texture.png
new file mode 100644
index 000000000..12bae83a9
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/texture.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-bookmark.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-bookmark.png
new file mode 100644
index 000000000..a187be6c9
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-bookmark.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-bookmark@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-bookmark@2x.png
new file mode 100644
index 000000000..4efbaa675
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-bookmark@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-download.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-download.png
new file mode 100644
index 000000000..eaab35f09
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-download.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-download@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-download@2x.png
new file mode 100644
index 000000000..896face45
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-download@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-menuArrows.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-menuArrows.png
new file mode 100644
index 000000000..e50ca4eee
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-menuArrows.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-menuArrows@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-menuArrows@2x.png
new file mode 100644
index 000000000..f7570bc0d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-menuArrows@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-openFile.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-openFile.png
new file mode 100644
index 000000000..b5cf1bd06
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-openFile.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-openFile@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-openFile@2x.png
new file mode 100644
index 000000000..91ab76593
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-openFile@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown-rtl.png
new file mode 100644
index 000000000..1957f79ab
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown-rtl@2x.png
new file mode 100644
index 000000000..16ebcb8ef
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown.png
new file mode 100644
index 000000000..8219ecf83
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown@2x.png
new file mode 100644
index 000000000..758c01d83
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageDown@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp-rtl.png
new file mode 100644
index 000000000..98e7ce481
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp-rtl@2x.png
new file mode 100644
index 000000000..a01b02380
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp.png
new file mode 100644
index 000000000..fb9daa337
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp@2x.png
new file mode 100644
index 000000000..a5cfd755b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-pageUp@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-presentationMode.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-presentationMode.png
new file mode 100644
index 000000000..3ac21244d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-presentationMode.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-presentationMode@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-presentationMode@2x.png
new file mode 100644
index 000000000..cada9e791
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-presentationMode@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-print.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-print.png
new file mode 100644
index 000000000..51275e54b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-print.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-print@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-print@2x.png
new file mode 100644
index 000000000..53d18daf7
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-print@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-search.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-search.png
new file mode 100644
index 000000000..f9b75579b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-search.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-search@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-search@2x.png
new file mode 100644
index 000000000..456b13324
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-search@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle-rtl.png
new file mode 100644
index 000000000..843709527
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle-rtl@2x.png
new file mode 100644
index 000000000..9d9bfa4f6
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle.png
new file mode 100644
index 000000000..1f90f83da
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle@2x.png
new file mode 100644
index 000000000..b066fe5cb
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-secondaryToolbarToggle@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle-rtl.png
new file mode 100644
index 000000000..6f85ec061
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle-rtl@2x.png
new file mode 100644
index 000000000..291e00679
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle.png
new file mode 100644
index 000000000..025dc9040
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle@2x.png
new file mode 100644
index 000000000..7f834df94
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-sidebarToggle@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewAttachments.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewAttachments.png
new file mode 100644
index 000000000..fcd0b268a
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewAttachments.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewAttachments@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewAttachments@2x.png
new file mode 100644
index 000000000..4a5e2b8a3
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewAttachments@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline-rtl.png
new file mode 100644
index 000000000..aaa943021
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline-rtl@2x.png
new file mode 100644
index 000000000..3410f70df
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline.png
new file mode 100644
index 000000000..976365a50
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline@2x.png
new file mode 100644
index 000000000..b6a197fdf
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewOutline@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewThumbnail.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewThumbnail.png
new file mode 100644
index 000000000..584ba5588
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewThumbnail.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewThumbnail@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewThumbnail@2x.png
new file mode 100644
index 000000000..a0208b413
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-viewThumbnail@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomIn.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomIn.png
new file mode 100644
index 000000000..513d081bc
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomIn.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomIn@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomIn@2x.png
new file mode 100644
index 000000000..d5d49d5ff
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomIn@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomOut.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomOut.png
new file mode 100644
index 000000000..156c26b94
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomOut.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomOut@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomOut@2x.png
new file mode 100644
index 000000000..959e1919d
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/toolbarButton-zoomOut@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed-rtl.png b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed-rtl.png
new file mode 100644
index 000000000..0496b3577
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed-rtl.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed-rtl@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed-rtl@2x.png
new file mode 100644
index 000000000..6ad9ebcdf
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed-rtl@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed.png b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed.png
new file mode 100644
index 000000000..06d4d3769
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed@2x.png
new file mode 100644
index 000000000..eec1e58c1
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-collapsed@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/treeitem-expanded.png b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-expanded.png
new file mode 100644
index 000000000..c8d557351
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-expanded.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/images/treeitem-expanded@2x.png b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-expanded@2x.png
new file mode 100644
index 000000000..3b3b6103b
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/images/treeitem-expanded@2x.png
diff --git a/application/basilisk/extensions/pdfjs/content/web/l10n.js b/application/basilisk/extensions/pdfjs/content/web/l10n.js
new file mode 100644
index 000000000..2e0684e06
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/l10n.js
@@ -0,0 +1,151 @@
+
+'use strict';
+
+// Small subset of the webL10n API by Fabien Cazenave for pdf.js extension.
+(function(window) {
+  var gLanguage = '';
+  var gExternalLocalizerServices = null;
+
+  // fetch an l10n objects
+  function getL10nData(key) {
+    var response = gExternalLocalizerServices.getStrings(key);
+    var data = JSON.parse(response);
+    if (!data) {
+      console.warn('[l10n] #' + key + ' missing for [' + gLanguage + ']');
+    }
+    return data;
+  }
+
+  // replace {{arguments}} with their values
+  function substArguments(text, args) {
+    if (!args) {
+      return text;
+    }
+    return text.replace(/\{\{\s*(\w+)\s*\}\}/g, function(all, name) {
+      return (name in args ? args[name] : '{{' + name + '}}');
+    });
+  }
+
+  // translate a string
+  function translateString(key, args, fallback) {
+    var i = key.lastIndexOf('.');
+    var name, property;
+    if (i >= 0) {
+      name = key.substring(0, i);
+      property = key.substring(i + 1);
+    } else {
+      name = key;
+      property = 'textContent';
+    }
+    var data = getL10nData(name);
+    var value = (data && data[property]) || fallback;
+    if (!value) {
+      return '{{' + key + '}}';
+    }
+    return substArguments(value, args);
+  }
+
+  // translate an HTML element
+  function translateElement(element) {
+    if (!element || !element.dataset) {
+      return;
+    }
+
+    // get the related l10n object
+    var key = element.dataset.l10nId;
+    var data = getL10nData(key);
+    if (!data) {
+      return;
+    }
+
+    // get arguments (if any)
+    // TODO: more flexible parser?
+    var args;
+    if (element.dataset.l10nArgs) {
+      try {
+        args = JSON.parse(element.dataset.l10nArgs);
+      } catch (e) {
+        console.warn('[l10n] could not parse arguments for #' + key + '');
+      }
+    }
+
+    // translate element
+    // TODO: security check?
+    for (var k in data) {
+      element[k] = substArguments(data[k], args);
+    }
+  }
+
+
+  // translate an HTML subtree
+  function translateFragment(element) {
+    element = element || document.querySelector('html');
+
+    // check all translatable children (= w/ a `data-l10n-id' attribute)
+    var children = element.querySelectorAll('*[data-l10n-id]');
+    var elementCount = children.length;
+    for (var i = 0; i < elementCount; i++) {
+      translateElement(children[i]);
+    }
+
+    // translate element itself if necessary
+    if (element.dataset.l10nId) {
+      translateElement(element);
+    }
+  }
+
+  function translateDocument() {
+    gLanguage = gExternalLocalizerServices.getLocale();
+
+    translateFragment();
+
+    // fire a 'localized' DOM event
+    var evtObject = document.createEvent('Event');
+    evtObject.initEvent('localized', false, false);
+    evtObject.language = gLanguage;
+    window.dispatchEvent(evtObject);
+  }
+
+  window.addEventListener('DOMContentLoaded', function() {
+    if (gExternalLocalizerServices) {
+      translateDocument();
+    }
+    // ... else see setExternalLocalizerServices below
+  });
+
+  // Public API
+  document.mozL10n = {
+    // get a localized string
+    get: translateString,
+
+    // get the document language
+    getLanguage: function() {
+      return gLanguage;
+    },
+
+    // get the direction (ltr|rtl) of the current language
+    getDirection: function() {
+      // http://www.w3.org/International/questions/qa-scripts
+      // Arabic, Hebrew, Farsi, Pashto, Urdu
+      var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];
+
+      // use the short language code for "full" codes like 'ar-sa' (issue 5440)
+      var shortCode = gLanguage.split('-')[0];
+
+      return (rtlList.indexOf(shortCode) >= 0) ? 'rtl' : 'ltr';
+    },
+
+    setExternalLocalizerServices: function (externalLocalizerServices) {
+      gExternalLocalizerServices = externalLocalizerServices;
+
+      // ... in case if we missed DOMContentLoaded above.
+      if (window.document.readyState === 'interactive' ||
+          window.document.readyState === 'complete') {
+        translateDocument();
+      }
+    },
+
+    // translate an element or document fragment
+    translate: translateFragment
+  };
+})(this);
diff --git a/application/basilisk/extensions/pdfjs/content/web/viewer.css b/application/basilisk/extensions/pdfjs/content/web/viewer.css
new file mode 100644
index 000000000..74b6fab86
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/viewer.css
@@ -0,0 +1,2034 @@
+/* Copyright 2014 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.
+ */
+
+.textLayer {
+  position: absolute;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  overflow: hidden;
+  opacity: 0.2;
+  line-height: 1.0;
+}
+
+.textLayer > div {
+  color: transparent;
+  position: absolute;
+  white-space: pre;
+  cursor: text;
+  -moz-transform-origin: 0% 0%;
+  transform-origin: 0% 0%;
+}
+
+.textLayer .highlight {
+  margin: -1px;
+  padding: 1px;
+
+  background-color: rgb(180, 0, 170);
+  border-radius: 4px;
+}
+
+.textLayer .highlight.begin {
+  border-radius: 4px 0px 0px 4px;
+}
+
+.textLayer .highlight.end {
+  border-radius: 0px 4px 4px 0px;
+}
+
+.textLayer .highlight.middle {
+  border-radius: 0px;
+}
+
+.textLayer .highlight.selected {
+  background-color: rgb(0, 100, 0);
+}
+
+.textLayer ::selection { background: rgb(0,0,255); }
+.textLayer ::-moz-selection { background: rgb(0,0,255); }
+
+.textLayer .endOfContent {
+  display: block;
+  position: absolute;
+  left: 0px;
+  top: 100%;
+  right: 0px;
+  bottom: 0px;
+  z-index: -1;
+  cursor: default;
+  -moz-user-select: none;
+}
+
+.textLayer .endOfContent.active {
+  top: 0px;
+}
+
+
+.annotationLayer section {
+  position: absolute;
+}
+
+.annotationLayer .linkAnnotation > a {
+  position: absolute;
+  font-size: 1em;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.annotationLayer .linkAnnotation > a:hover {
+  opacity: 0.2;
+  background: #ff0;
+  box-shadow: 0px 2px 10px #ff0;
+}
+
+.annotationLayer .textAnnotation img {
+  position: absolute;
+  cursor: pointer;
+}
+
+.annotationLayer .textWidgetAnnotation input,
+.annotationLayer .textWidgetAnnotation textarea,
+.annotationLayer .choiceWidgetAnnotation select {
+  background-color: rgba(0, 54, 255, 0.13);
+  border: 1px solid transparent;
+  box-sizing: border-box;
+  font-size: 9px;
+  height: 100%;
+  padding: 0 3px;
+  vertical-align: top;
+  width: 100%;
+}
+
+.annotationLayer .textWidgetAnnotation textarea {
+  font: message-box;
+  font-size: 9px;
+  resize: none;
+}
+
+.annotationLayer .textWidgetAnnotation input[disabled],
+.annotationLayer .textWidgetAnnotation textarea[disabled],
+.annotationLayer .choiceWidgetAnnotation select[disabled] {
+  background: none;
+  border: 1px solid transparent;
+  cursor: not-allowed;
+}
+
+.annotationLayer .textWidgetAnnotation input:hover,
+.annotationLayer .textWidgetAnnotation textarea:hover,
+.annotationLayer .choiceWidgetAnnotation select:hover {
+  border: 1px solid #000;
+}
+
+.annotationLayer .textWidgetAnnotation input:focus,
+.annotationLayer .textWidgetAnnotation textarea:focus,
+.annotationLayer .choiceWidgetAnnotation select:focus {
+  background: none;
+  border: 1px solid transparent;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb {
+  font-family: monospace;
+  padding-left: 2px;
+  padding-right: 0;
+}
+
+.annotationLayer .textWidgetAnnotation input.comb:focus {
+  /*
+   * Letter spacing is placed on the right side of each character. Hence, the
+   * letter spacing of the last character may be placed outside the visible
+   * area, causing horizontal scrolling. We avoid this by extending the width
+   * when the element has focus and revert this when it loses focus.
+   */
+  width: 115%;
+}
+
+.annotationLayer .popupWrapper {
+  position: absolute;
+  width: 20em;
+}
+
+.annotationLayer .popup {
+  position: absolute;
+  z-index: 200;
+  max-width: 20em;
+  background-color: #FFFF99;
+  box-shadow: 0px 2px 5px #333;
+  border-radius: 2px;
+  padding: 0.6em;
+  margin-left: 5px;
+  cursor: pointer;
+  word-wrap: break-word;
+}
+
+.annotationLayer .popup h1 {
+  font-size: 1em;
+  border-bottom: 1px solid #000000;
+  padding-bottom: 0.2em;
+}
+
+.annotationLayer .popup p {
+  padding-top: 0.2em;
+}
+
+.annotationLayer .highlightAnnotation,
+.annotationLayer .underlineAnnotation,
+.annotationLayer .squigglyAnnotation,
+.annotationLayer .strikeoutAnnotation,
+.annotationLayer .fileAttachmentAnnotation {
+  cursor: pointer;
+}
+
+.pdfViewer .canvasWrapper {
+  overflow: hidden;
+}
+
+.pdfViewer .page {
+  direction: ltr;
+  width: 816px;
+  height: 1056px;
+  margin: 1px auto -8px auto;
+  position: relative;
+  overflow: visible;
+  border: 9px solid transparent;
+  background-clip: content-box;
+  border-image: url(images/shadow.png) 9 9 repeat;
+  background-color: white;
+}
+
+.pdfViewer.removePageBorders .page {
+  margin: 0px auto 10px auto;
+  border: none;
+}
+
+.pdfViewer.singlePageView {
+  display: inline-block;
+}
+
+.pdfViewer.singlePageView .page {
+  margin: 0;
+  border: none;
+}
+
+.pdfViewer .page canvas {
+  margin: 0;
+  display: block;
+}
+
+.pdfViewer .page .loadingIcon {
+  position: absolute;
+  display: block;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  background: url('images/loading-icon.gif') center no-repeat;
+}
+
+.pdfPresentationMode:-moz-full-screen .pdfViewer .page {
+  margin-bottom: 100%;
+  border: 0;
+}
+
+.pdfPresentationMode:fullscreen .pdfViewer .page {
+  margin-bottom: 100%;
+  border: 0;
+}
+
+* {
+  padding: 0;
+  margin: 0;
+}
+
+html {
+  height: 100%;
+  width: 100%;
+  /* Font size is needed to make the activity bar the correct size. */
+  font-size: 10px;
+}
+
+body {
+  height: 100%;
+  width: 100%;
+  background-color: #404040;
+  background-image: url(images/texture.png);
+}
+
+body,
+input,
+button,
+select {
+  font: message-box;
+  outline: none;
+}
+
+.hidden {
+  display: none !important;
+}
+[hidden] {
+  display: none !important;
+}
+
+#viewerContainer.pdfPresentationMode:-moz-full-screen {
+  top: 0px;
+  border-top: 2px solid transparent;
+  background-color: #000;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  cursor: none;
+  -moz-user-select: none;
+}
+
+#viewerContainer.pdfPresentationMode:fullscreen {
+  top: 0px;
+  border-top: 2px solid transparent;
+  background-color: #000;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  cursor: none;
+  -moz-user-select: none;
+}
+
+.pdfPresentationMode:-moz-full-screen a:not(.internalLink) {
+  display: none;
+}
+
+.pdfPresentationMode:fullscreen a:not(.internalLink) {
+  display: none;
+}
+
+.pdfPresentationMode:-moz-full-screen .textLayer > div {
+  cursor: none;
+}
+
+.pdfPresentationMode:fullscreen .textLayer > div {
+  cursor: none;
+}
+
+.pdfPresentationMode.pdfPresentationModeControls > *,
+.pdfPresentationMode.pdfPresentationModeControls .textLayer > div {
+  cursor: default;
+}
+
+#outerContainer {
+  width: 100%;
+  height: 100%;
+  position: relative;
+}
+
+#sidebarContainer {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  width: 200px;
+  visibility: hidden;
+  transition-duration: 200ms;
+  transition-timing-function: ease;
+
+}
+html[dir='ltr'] #sidebarContainer {
+  transition-property: left;
+  left: -200px;
+}
+html[dir='rtl'] #sidebarContainer {
+  transition-property: right;
+  right: -200px;
+}
+
+#outerContainer.sidebarMoving > #sidebarContainer,
+#outerContainer.sidebarOpen > #sidebarContainer {
+  visibility: visible;
+}
+html[dir='ltr'] #outerContainer.sidebarOpen > #sidebarContainer {
+  left: 0px;
+}
+html[dir='rtl'] #outerContainer.sidebarOpen > #sidebarContainer {
+  right: 0px;
+}
+
+#mainContainer {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  min-width: 320px;
+  transition-duration: 200ms;
+  transition-timing-function: ease;
+}
+html[dir='ltr'] #outerContainer.sidebarOpen > #mainContainer {
+  transition-property: left;
+  left: 200px;
+}
+html[dir='rtl'] #outerContainer.sidebarOpen > #mainContainer {
+  transition-property: right;
+  right: 200px;
+}
+
+#sidebarContent {
+  top: 32px;
+  bottom: 0;
+  overflow: auto;
+  position: absolute;
+  width: 200px;
+  background-color: hsla(0,0%,0%,.1);
+}
+html[dir='ltr'] #sidebarContent {
+  left: 0;
+  box-shadow: inset -1px 0 0 hsla(0,0%,0%,.25);
+}
+html[dir='rtl'] #sidebarContent {
+  right: 0;
+  box-shadow: inset 1px 0 0 hsla(0,0%,0%,.25);
+}
+
+#viewerContainer {
+  overflow: auto;
+  position: absolute;
+  top: 32px;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  outline: none;
+}
+html[dir='ltr'] #viewerContainer {
+  box-shadow: inset 1px 0 0 hsla(0,0%,100%,.05);
+}
+html[dir='rtl'] #viewerContainer {
+  box-shadow: inset -1px 0 0 hsla(0,0%,100%,.05);
+}
+
+.toolbar {
+  position: relative;
+  left: 0;
+  right: 0;
+  z-index: 9999;
+  cursor: default;
+}
+
+#toolbarContainer {
+  width: 100%;
+}
+
+#toolbarSidebar {
+  width: 200px;
+  height: 32px;
+  background-color: #424242; /* fallback */
+  background-image: url(images/texture.png),
+                    linear-gradient(hsla(0,0%,30%,.99), hsla(0,0%,25%,.95));
+}
+html[dir='ltr'] #toolbarSidebar {
+  box-shadow: inset -1px 0 0 rgba(0, 0, 0, 0.25),
+              inset 0 -1px 0 hsla(0,0%,100%,.05),
+              0 1px 0 hsla(0,0%,0%,.15),
+              0 0 1px hsla(0,0%,0%,.1);
+}
+html[dir='rtl'] #toolbarSidebar {
+  box-shadow: inset 1px 0 0 rgba(0, 0, 0, 0.25),
+              inset 0 1px 0 hsla(0,0%,100%,.05),
+              0 1px 0 hsla(0,0%,0%,.15),
+              0 0 1px hsla(0,0%,0%,.1);
+}
+
+#toolbarContainer, .findbar, .secondaryToolbar {
+  position: relative;
+  height: 32px;
+  background-color: #474747; /* fallback */
+  background-image: url(images/texture.png),
+                    linear-gradient(hsla(0,0%,32%,.99), hsla(0,0%,27%,.95));
+}
+html[dir='ltr'] #toolbarContainer, .findbar, .secondaryToolbar {
+  box-shadow: inset 1px 0 0 hsla(0,0%,100%,.08),
+              inset 0 1px 1px hsla(0,0%,0%,.15),
+              inset 0 -1px 0 hsla(0,0%,100%,.05),
+              0 1px 0 hsla(0,0%,0%,.15),
+              0 1px 1px hsla(0,0%,0%,.1);
+}
+html[dir='rtl'] #toolbarContainer, .findbar, .secondaryToolbar {
+  box-shadow: inset -1px 0 0 hsla(0,0%,100%,.08),
+              inset 0 1px 1px hsla(0,0%,0%,.15),
+              inset 0 -1px 0 hsla(0,0%,100%,.05),
+              0 1px 0 hsla(0,0%,0%,.15),
+              0 1px 1px hsla(0,0%,0%,.1);
+}
+
+#toolbarViewer {
+  height: 32px;
+}
+
+#loadingBar {
+  position: relative;
+  width: 100%;
+  height: 4px;
+  background-color: #333;
+  border-bottom: 1px solid #333;
+}
+
+#loadingBar .progress {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 0%;
+  height: 100%;
+  background-color: #ddd;
+  overflow: hidden;
+  transition: width 200ms;
+}
+
+@keyframes progressIndeterminate {
+  0% { left: -142px; }
+  100% { left: 0; }
+}
+
+#loadingBar .progress.indeterminate {
+  background-color: #999;
+  transition: none;
+}
+
+#loadingBar .progress.indeterminate .glimmer {
+  position: absolute;
+  top: 0;
+  left: 0;
+  height: 100%;
+  width: calc(100% + 150px);
+
+  background: repeating-linear-gradient(135deg,
+                                        #bbb 0, #999 5px,
+                                        #999 45px, #ddd 55px,
+                                        #ddd 95px, #bbb 100px);
+
+  animation: progressIndeterminate 950ms linear infinite;
+}
+
+.findbar, .secondaryToolbar {
+  top: 32px;
+  position: absolute;
+  z-index: 10000;
+  height: 32px;
+
+  min-width: 16px;
+  padding: 0px 6px 0px 6px;
+  margin: 4px 2px 4px 2px;
+  color: hsl(0,0%,85%);
+  font-size: 12px;
+  line-height: 14px;
+  text-align: left;
+  cursor: default;
+}
+
+html[dir='ltr'] .findbar {
+  left: 68px;
+}
+
+html[dir='rtl'] .findbar {
+  right: 68px;
+}
+
+.findbar label {
+  -moz-user-select: none;
+}
+
+#findInput[data-status="pending"] {
+  background-image: url(images/loading-small.png);
+  background-repeat: no-repeat;
+  background-position: right;
+}
+html[dir='rtl'] #findInput[data-status="pending"] {
+  background-position: left;
+}
+
+.secondaryToolbar {
+  padding: 6px;
+  height: auto;
+  z-index: 30000;
+}
+html[dir='ltr'] .secondaryToolbar {
+  right: 4px;
+}
+html[dir='rtl'] .secondaryToolbar {
+  left: 4px;
+}
+
+#secondaryToolbarButtonContainer {
+  max-width: 200px;
+  max-height: 400px;
+  overflow-y: auto;
+  margin-bottom: -4px;
+}
+
+.doorHanger,
+.doorHangerRight {
+  border: 1px solid hsla(0,0%,0%,.5);
+  border-radius: 2px;
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3);
+}
+.doorHanger:after, .doorHanger:before,
+.doorHangerRight:after, .doorHangerRight:before {
+  bottom: 100%;
+  border: solid transparent;
+  content: " ";
+  height: 0;
+  width: 0;
+  position: absolute;
+  pointer-events: none;
+}
+.doorHanger:after,
+.doorHangerRight:after {
+  border-bottom-color: hsla(0,0%,32%,.99);
+  border-width: 8px;
+}
+.doorHanger:before,
+.doorHangerRight:before {
+  border-bottom-color: hsla(0,0%,0%,.5);
+  border-width: 9px;
+}
+
+html[dir='ltr'] .doorHanger:after,
+html[dir='rtl'] .doorHangerRight:after {
+  left: 13px;
+  margin-left: -8px;
+}
+
+html[dir='ltr'] .doorHanger:before,
+html[dir='rtl'] .doorHangerRight:before {
+  left: 13px;
+  margin-left: -9px;
+}
+
+html[dir='rtl'] .doorHanger:after,
+html[dir='ltr'] .doorHangerRight:after {
+  right: 13px;
+  margin-right: -8px;
+}
+
+html[dir='rtl'] .doorHanger:before,
+html[dir='ltr'] .doorHangerRight:before {
+  right: 13px;
+  margin-right: -9px;
+}
+
+#findResultsCount {
+  background-color: hsl(0, 0%, 85%);
+  color: hsl(0, 0%, 32%);
+  text-align: center;
+  padding: 3px 4px;
+}
+
+#findMsg {
+  font-style: italic;
+  color: #A6B7D0;
+}
+
+#findInput.notFound {
+  background-color: rgb(255, 102, 102);
+}
+
+#toolbarViewerMiddle {
+  position: absolute;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
+html[dir='ltr'] #toolbarViewerLeft,
+html[dir='rtl'] #toolbarViewerRight {
+  float: left;
+}
+html[dir='ltr'] #toolbarViewerRight,
+html[dir='rtl'] #toolbarViewerLeft {
+  float: right;
+}
+html[dir='ltr'] #toolbarViewerLeft > *,
+html[dir='ltr'] #toolbarViewerMiddle > *,
+html[dir='ltr'] #toolbarViewerRight > *,
+html[dir='ltr'] .findbar > * {
+  position: relative;
+  float: left;
+}
+html[dir='rtl'] #toolbarViewerLeft > *,
+html[dir='rtl'] #toolbarViewerMiddle > *,
+html[dir='rtl'] #toolbarViewerRight > *,
+html[dir='rtl'] .findbar > * {
+  position: relative;
+  float: right;
+}
+
+html[dir='ltr'] .splitToolbarButton {
+  margin: 3px 2px 4px 0;
+  display: inline-block;
+}
+html[dir='rtl'] .splitToolbarButton {
+  margin: 3px 0 4px 2px;
+  display: inline-block;
+}
+html[dir='ltr'] .splitToolbarButton > .toolbarButton {
+  border-radius: 0;
+  float: left;
+}
+html[dir='rtl'] .splitToolbarButton > .toolbarButton {
+  border-radius: 0;
+  float: right;
+}
+
+.toolbarButton,
+.secondaryToolbarButton,
+.overlayButton {
+  border: 0 none;
+  background: none;
+  width: 32px;
+  height: 25px;
+}
+
+.toolbarButton > span {
+  display: inline-block;
+  width: 0;
+  height: 0;
+  overflow: hidden;
+}
+
+.toolbarButton[disabled],
+.secondaryToolbarButton[disabled],
+.overlayButton[disabled] {
+  opacity: .5;
+}
+
+.toolbarButton.group {
+  margin-right: 0;
+}
+
+.splitToolbarButton.toggled .toolbarButton {
+  margin: 0;
+}
+
+.splitToolbarButton:hover > .toolbarButton,
+.splitToolbarButton:focus > .toolbarButton,
+.splitToolbarButton.toggled > .toolbarButton,
+.toolbarButton.textButton {
+  background-color: hsla(0,0%,0%,.12);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  border: 1px solid hsla(0,0%,0%,.35);
+  border-color: hsla(0,0%,0%,.32) hsla(0,0%,0%,.38) hsla(0,0%,0%,.42);
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.15) inset,
+              0 1px 0 hsla(0,0%,100%,.05);
+  transition-property: background-color, border-color, box-shadow;
+  transition-duration: 150ms;
+  transition-timing-function: ease;
+
+}
+.splitToolbarButton > .toolbarButton:hover,
+.splitToolbarButton > .toolbarButton:focus,
+.dropdownToolbarButton:hover,
+.overlayButton:hover,
+.overlayButton:focus,
+.toolbarButton.textButton:hover,
+.toolbarButton.textButton:focus {
+  background-color: hsla(0,0%,0%,.2);
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.15) inset,
+              0 0 1px hsla(0,0%,0%,.05);
+  z-index: 199;
+}
+.splitToolbarButton > .toolbarButton {
+  position: relative;
+}
+html[dir='ltr'] .splitToolbarButton > .toolbarButton:first-child,
+html[dir='rtl'] .splitToolbarButton > .toolbarButton:last-child {
+  position: relative;
+  margin: 0;
+  margin-right: -1px;
+  border-top-left-radius: 2px;
+  border-bottom-left-radius: 2px;
+  border-right-color: transparent;
+}
+html[dir='ltr'] .splitToolbarButton > .toolbarButton:last-child,
+html[dir='rtl'] .splitToolbarButton > .toolbarButton:first-child {
+  position: relative;
+  margin: 0;
+  margin-left: -1px;
+  border-top-right-radius: 2px;
+  border-bottom-right-radius: 2px;
+  border-left-color: transparent;
+}
+.splitToolbarButtonSeparator {
+  padding: 8px 0;
+  width: 1px;
+  background-color: hsla(0,0%,0%,.5);
+  z-index: 99;
+  box-shadow: 0 0 0 1px hsla(0,0%,100%,.08);
+  display: inline-block;
+  margin: 5px 0;
+}
+html[dir='ltr'] .splitToolbarButtonSeparator {
+  float: left;
+}
+html[dir='rtl'] .splitToolbarButtonSeparator {
+  float: right;
+}
+.splitToolbarButton:hover > .splitToolbarButtonSeparator,
+.splitToolbarButton.toggled > .splitToolbarButtonSeparator {
+  padding: 12px 0;
+  margin: 1px 0;
+  box-shadow: 0 0 0 1px hsla(0,0%,100%,.03);
+  transition-property: padding;
+  transition-duration: 10ms;
+  transition-timing-function: ease;
+}
+
+.toolbarButton,
+.dropdownToolbarButton,
+.secondaryToolbarButton,
+.overlayButton {
+  min-width: 16px;
+  padding: 2px 6px 0;
+  border: 1px solid transparent;
+  border-radius: 2px;
+  color: hsla(0,0%,100%,.8);
+  font-size: 12px;
+  line-height: 14px;
+  -moz-user-select: none;
+  /* Opera does not support user-select, use <... unselectable="on"> instead */
+  cursor: default;
+  transition-property: background-color, border-color, box-shadow;
+  transition-duration: 150ms;
+  transition-timing-function: ease;
+}
+
+html[dir='ltr'] .toolbarButton,
+html[dir='ltr'] .overlayButton,
+html[dir='ltr'] .dropdownToolbarButton {
+  margin: 3px 2px 4px 0;
+}
+html[dir='rtl'] .toolbarButton,
+html[dir='rtl'] .overlayButton,
+html[dir='rtl'] .dropdownToolbarButton {
+  margin: 3px 0 4px 2px;
+}
+
+.toolbarButton:hover,
+.toolbarButton:focus,
+.dropdownToolbarButton,
+.overlayButton,
+.secondaryToolbarButton:hover,
+.secondaryToolbarButton:focus {
+  background-color: hsla(0,0%,0%,.12);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  border: 1px solid hsla(0,0%,0%,.35);
+  border-color: hsla(0,0%,0%,.32) hsla(0,0%,0%,.38) hsla(0,0%,0%,.42);
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.15) inset,
+              0 1px 0 hsla(0,0%,100%,.05);
+}
+
+.toolbarButton:hover:active,
+.overlayButton:hover:active,
+.dropdownToolbarButton:hover:active,
+.secondaryToolbarButton:hover:active {
+  background-color: hsla(0,0%,0%,.2);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  border-color: hsla(0,0%,0%,.35) hsla(0,0%,0%,.4) hsla(0,0%,0%,.45);
+  box-shadow: 0 1px 1px hsla(0,0%,0%,.1) inset,
+              0 0 1px hsla(0,0%,0%,.2) inset,
+              0 1px 0 hsla(0,0%,100%,.05);
+  transition-property: background-color, border-color, box-shadow;
+  transition-duration: 10ms;
+  transition-timing-function: linear;
+}
+
+.toolbarButton.toggled,
+.splitToolbarButton.toggled > .toolbarButton.toggled,
+.secondaryToolbarButton.toggled {
+  background-color: hsla(0,0%,0%,.3);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  border-color: hsla(0,0%,0%,.4) hsla(0,0%,0%,.45) hsla(0,0%,0%,.5);
+  box-shadow: 0 1px 1px hsla(0,0%,0%,.1) inset,
+              0 0 1px hsla(0,0%,0%,.2) inset,
+              0 1px 0 hsla(0,0%,100%,.05);
+  transition-property: background-color, border-color, box-shadow;
+  transition-duration: 10ms;
+  transition-timing-function: linear;
+}
+
+.toolbarButton.toggled:hover:active,
+.splitToolbarButton.toggled > .toolbarButton.toggled:hover:active,
+.secondaryToolbarButton.toggled:hover:active {
+  background-color: hsla(0,0%,0%,.4);
+  border-color: hsla(0,0%,0%,.4) hsla(0,0%,0%,.5) hsla(0,0%,0%,.55);
+  box-shadow: 0 1px 1px hsla(0,0%,0%,.2) inset,
+              0 0 1px hsla(0,0%,0%,.3) inset,
+              0 1px 0 hsla(0,0%,100%,.05);
+}
+
+.dropdownToolbarButton {
+  width: 120px;
+  max-width: 120px;
+  padding: 0;
+  overflow: hidden;
+  background: url(images/toolbarButton-menuArrows.png) no-repeat;
+}
+html[dir='ltr'] .dropdownToolbarButton {
+  background-position: 95%;
+}
+html[dir='rtl'] .dropdownToolbarButton {
+  background-position: 5%;
+}
+
+.dropdownToolbarButton > select {
+  min-width: 140px;
+  font-size: 12px;
+  color: hsl(0,0%,95%);
+  margin: 0;
+  padding: 3px 2px 2px;
+  border: none;
+  background: rgba(0,0,0,0); /* Opera does not support 'transparent' <select> background */
+}
+
+.dropdownToolbarButton > select > option {
+  background: hsl(0,0%,24%);
+}
+
+#customScaleOption {
+  display: none;
+}
+
+#pageWidthOption {
+  border-bottom: 1px rgba(255, 255, 255, .5) solid;
+}
+
+html[dir='ltr'] .splitToolbarButton:first-child,
+html[dir='ltr'] .toolbarButton:first-child,
+html[dir='rtl'] .splitToolbarButton:last-child,
+html[dir='rtl'] .toolbarButton:last-child {
+  margin-left: 4px;
+}
+html[dir='ltr'] .splitToolbarButton:last-child,
+html[dir='ltr'] .toolbarButton:last-child,
+html[dir='rtl'] .splitToolbarButton:first-child,
+html[dir='rtl'] .toolbarButton:first-child {
+  margin-right: 4px;
+}
+
+.toolbarButtonSpacer {
+  width: 30px;
+  display: inline-block;
+  height: 1px;
+}
+
+.toolbarButtonFlexibleSpacer {
+  -moz-box-flex: 1;
+  min-width: 30px;
+}
+
+html[dir='ltr'] #findPrevious {
+  margin-left: 3px;
+}
+html[dir='ltr'] #findNext {
+  margin-right: 3px;
+}
+
+html[dir='rtl'] #findPrevious {
+  margin-right: 3px;
+}
+html[dir='rtl'] #findNext {
+  margin-left: 3px;
+}
+
+.toolbarButton::before,
+.secondaryToolbarButton::before {
+  /* All matching images have a size of 16x16
+   * All relevant containers have a size of 32x25 */
+  position: absolute;
+  display: inline-block;
+  top: 4px;
+  left: 7px;
+}
+
+html[dir="ltr"] .secondaryToolbarButton::before {
+  left: 4px;
+}
+html[dir="rtl"] .secondaryToolbarButton::before {
+  right: 4px;
+}
+
+html[dir='ltr'] .toolbarButton#sidebarToggle::before {
+  content: url(images/toolbarButton-sidebarToggle.png);
+}
+html[dir='rtl'] .toolbarButton#sidebarToggle::before {
+  content: url(images/toolbarButton-sidebarToggle-rtl.png);
+}
+
+html[dir='ltr'] .toolbarButton#secondaryToolbarToggle::before {
+  content: url(images/toolbarButton-secondaryToolbarToggle.png);
+}
+html[dir='rtl'] .toolbarButton#secondaryToolbarToggle::before {
+  content: url(images/toolbarButton-secondaryToolbarToggle-rtl.png);
+}
+
+html[dir='ltr'] .toolbarButton.findPrevious::before {
+  content: url(images/findbarButton-previous.png);
+}
+html[dir='rtl'] .toolbarButton.findPrevious::before {
+  content: url(images/findbarButton-previous-rtl.png);
+}
+
+html[dir='ltr'] .toolbarButton.findNext::before {
+  content: url(images/findbarButton-next.png);
+}
+html[dir='rtl'] .toolbarButton.findNext::before {
+  content: url(images/findbarButton-next-rtl.png);
+}
+
+html[dir='ltr'] .toolbarButton.pageUp::before {
+  content: url(images/toolbarButton-pageUp.png);
+}
+html[dir='rtl'] .toolbarButton.pageUp::before {
+  content: url(images/toolbarButton-pageUp-rtl.png);
+}
+
+html[dir='ltr'] .toolbarButton.pageDown::before {
+  content: url(images/toolbarButton-pageDown.png);
+}
+html[dir='rtl'] .toolbarButton.pageDown::before {
+  content: url(images/toolbarButton-pageDown-rtl.png);
+}
+
+.toolbarButton.zoomOut::before {
+  content: url(images/toolbarButton-zoomOut.png);
+}
+
+.toolbarButton.zoomIn::before {
+  content: url(images/toolbarButton-zoomIn.png);
+}
+
+.toolbarButton.presentationMode::before,
+.secondaryToolbarButton.presentationMode::before {
+  content: url(images/toolbarButton-presentationMode.png);
+}
+
+.toolbarButton.print::before,
+.secondaryToolbarButton.print::before {
+  content: url(images/toolbarButton-print.png);
+}
+
+.toolbarButton.openFile::before,
+.secondaryToolbarButton.openFile::before {
+  content: url(images/toolbarButton-openFile.png);
+}
+
+.toolbarButton.download::before,
+.secondaryToolbarButton.download::before {
+  content: url(images/toolbarButton-download.png);
+}
+
+.toolbarButton.bookmark,
+.secondaryToolbarButton.bookmark {
+  box-sizing: border-box;
+  outline: none;
+  padding-top: 4px;
+  text-decoration: none;
+}
+.secondaryToolbarButton.bookmark {
+  padding-top: 5px;
+}
+
+.bookmark[href='#'] {
+  opacity: .5;
+  pointer-events: none;
+}
+
+.toolbarButton.bookmark::before,
+.secondaryToolbarButton.bookmark::before {
+  content: url(images/toolbarButton-bookmark.png);
+}
+
+#viewThumbnail.toolbarButton::before {
+  content: url(images/toolbarButton-viewThumbnail.png);
+}
+
+html[dir="ltr"] #viewOutline.toolbarButton::before {
+  content: url(images/toolbarButton-viewOutline.png);
+}
+html[dir="rtl"] #viewOutline.toolbarButton::before {
+  content: url(images/toolbarButton-viewOutline-rtl.png);
+}
+
+#viewAttachments.toolbarButton::before {
+  content: url(images/toolbarButton-viewAttachments.png);
+}
+
+#viewFind.toolbarButton::before {
+  content: url(images/toolbarButton-search.png);
+}
+
+.secondaryToolbarButton {
+  position: relative;
+  margin: 0 0 4px 0;
+  padding: 3px 0 1px 0;
+  height: auto;
+  min-height: 25px;
+  width: auto;
+  min-width: 100%;
+  white-space: normal;
+}
+html[dir="ltr"] .secondaryToolbarButton {
+  padding-left: 24px;
+  text-align: left;
+}
+html[dir="rtl"] .secondaryToolbarButton {
+  padding-right: 24px;
+  text-align: right;
+}
+html[dir="ltr"] .secondaryToolbarButton.bookmark {
+  padding-left: 27px;
+}
+html[dir="rtl"] .secondaryToolbarButton.bookmark {
+  padding-right: 27px;
+}
+
+html[dir="ltr"] .secondaryToolbarButton > span {
+  padding-right: 4px;
+}
+html[dir="rtl"] .secondaryToolbarButton > span {
+  padding-left: 4px;
+}
+
+.secondaryToolbarButton.firstPage::before {
+  content: url(images/secondaryToolbarButton-firstPage.png);
+}
+
+.secondaryToolbarButton.lastPage::before {
+  content: url(images/secondaryToolbarButton-lastPage.png);
+}
+
+.secondaryToolbarButton.rotateCcw::before {
+  content: url(images/secondaryToolbarButton-rotateCcw.png);
+}
+
+.secondaryToolbarButton.rotateCw::before {
+  content: url(images/secondaryToolbarButton-rotateCw.png);
+}
+
+.secondaryToolbarButton.handTool::before {
+  content: url(images/secondaryToolbarButton-handTool.png);
+}
+
+.secondaryToolbarButton.documentProperties::before {
+  content: url(images/secondaryToolbarButton-documentProperties.png);
+}
+
+.verticalToolbarSeparator {
+  display: block;
+  padding: 8px 0;
+  margin: 8px 4px;
+  width: 1px;
+  background-color: hsla(0,0%,0%,.5);
+  box-shadow: 0 0 0 1px hsla(0,0%,100%,.08);
+}
+html[dir='ltr'] .verticalToolbarSeparator {
+  margin-left: 2px;
+}
+html[dir='rtl'] .verticalToolbarSeparator {
+  margin-right: 2px;
+}
+
+.horizontalToolbarSeparator {
+  display: block;
+  margin: 0 0 4px 0;
+  height: 1px;
+  width: 100%;
+  background-color: hsla(0,0%,0%,.5);
+  box-shadow: 0 0 0 1px hsla(0,0%,100%,.08);
+}
+
+.toolbarField {
+  padding: 3px 6px;
+  margin: 4px 0 4px 0;
+  border: 1px solid transparent;
+  border-radius: 2px;
+  background-color: hsla(0,0%,100%,.09);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  border: 1px solid hsla(0,0%,0%,.35);
+  border-color: hsla(0,0%,0%,.32) hsla(0,0%,0%,.38) hsla(0,0%,0%,.42);
+  box-shadow: 0 1px 0 hsla(0,0%,0%,.05) inset,
+              0 1px 0 hsla(0,0%,100%,.05);
+  color: hsl(0,0%,95%);
+  font-size: 12px;
+  line-height: 14px;
+  outline-style: none;
+  transition-property: background-color, border-color, box-shadow;
+  transition-duration: 150ms;
+  transition-timing-function: ease;
+}
+
+.toolbarField[type=checkbox] {
+  display: inline-block;
+  margin: 8px 0px;
+}
+
+.toolbarField.pageNumber {
+  -moz-appearance: textfield; /* hides the spinner in moz */
+  min-width: 16px;
+  text-align: right;
+  width: 40px;
+}
+
+.toolbarField.pageNumber.visiblePageIsLoading {
+  background-image: url(images/loading-small.png);
+  background-repeat: no-repeat;
+  background-position: 1px;
+}
+
+.toolbarField:hover {
+  background-color: hsla(0,0%,100%,.11);
+  border-color: hsla(0,0%,0%,.4) hsla(0,0%,0%,.43) hsla(0,0%,0%,.45);
+}
+
+.toolbarField:focus {
+  background-color: hsla(0,0%,100%,.15);
+  border-color: hsla(204,100%,65%,.8) hsla(204,100%,65%,.85) hsla(204,100%,65%,.9);
+}
+
+.toolbarLabel {
+  min-width: 16px;
+  padding: 3px 6px 3px 2px;
+  margin: 4px 2px 4px 0;
+  border: 1px solid transparent;
+  border-radius: 2px;
+  color: hsl(0,0%,85%);
+  font-size: 12px;
+  line-height: 14px;
+  text-align: left;
+  -moz-user-select: none;
+  cursor: default;
+}
+
+#thumbnailView {
+  position: absolute;
+  width: 120px;
+  top: 0;
+  bottom: 0;
+  padding: 10px 40px 0;
+  overflow: auto;
+}
+
+.thumbnail {
+  float: left;
+  margin-bottom: 5px;
+}
+
+#thumbnailView > a:last-of-type > .thumbnail {
+  margin-bottom: 10px;
+}
+
+#thumbnailView > a:last-of-type > .thumbnail:not([data-loaded]) {
+  margin-bottom: 9px;
+}
+
+.thumbnail:not([data-loaded]) {
+  border: 1px dashed rgba(255, 255, 255, 0.5);
+  margin: -1px -1px 4px -1px;
+}
+
+.thumbnailImage {
+  border: 1px solid transparent;
+  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.5), 0 2px 8px rgba(0, 0, 0, 0.3);
+  opacity: 0.8;
+  z-index: 99;
+  background-color: white;
+  background-clip: content-box;
+}
+
+.thumbnailSelectionRing {
+  border-radius: 2px;
+  padding: 7px;
+}
+
+a:focus > .thumbnail > .thumbnailSelectionRing > .thumbnailImage,
+.thumbnail:hover > .thumbnailSelectionRing > .thumbnailImage {
+  opacity: .9;
+}
+
+a:focus > .thumbnail > .thumbnailSelectionRing,
+.thumbnail:hover > .thumbnailSelectionRing {
+  background-color: hsla(0,0%,100%,.15);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.2) inset,
+              0 0 1px hsla(0,0%,0%,.2);
+  color: hsla(0,0%,100%,.9);
+}
+
+.thumbnail.selected > .thumbnailSelectionRing > .thumbnailImage {
+  box-shadow: 0 0 0 1px hsla(0,0%,0%,.5);
+  opacity: 1;
+}
+
+.thumbnail.selected > .thumbnailSelectionRing {
+  background-color: hsla(0,0%,100%,.3);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.1) inset,
+              0 0 1px hsla(0,0%,0%,.2);
+  color: hsla(0,0%,100%,1);
+}
+
+#outlineView,
+#attachmentsView {
+  position: absolute;
+  width: 192px;
+  top: 0;
+  bottom: 0;
+  overflow: auto;
+  -moz-user-select: none;
+}
+
+#outlineView {
+  padding: 4px 4px 0;
+}
+#attachmentsView {
+  padding: 3px 4px 0;
+}
+
+html[dir='ltr'] .outlineWithDeepNesting > .outlineItem,
+html[dir='ltr'] .outlineItem > .outlineItems {
+  margin-left: 20px;
+}
+
+html[dir='rtl'] .outlineWithDeepNesting > .outlineItem,
+html[dir='rtl'] .outlineItem > .outlineItems {
+  margin-right: 20px;
+}
+
+.outlineItem > a,
+.attachmentsItem > button {
+  text-decoration: none;
+  display: inline-block;
+  min-width: 95%;
+  min-width: calc(100% - 4px); /* Subtract the right padding (left, in RTL mode)
+                                  of the container. */
+  height: auto;
+  margin-bottom: 1px;
+  border-radius: 2px;
+  color: hsla(0,0%,100%,.8);
+  font-size: 13px;
+  line-height: 15px;
+  -moz-user-select: none;
+  white-space: normal;
+}
+
+.attachmentsItem > button {
+  border: 0 none;
+  background: none;
+  cursor: pointer;
+  width: 100%;
+}
+
+html[dir='ltr'] .outlineItem > a {
+  padding: 2px 0 5px 4px;
+}
+html[dir='ltr'] .attachmentsItem > button {
+  padding: 2px 0 3px 7px;
+  text-align: left;
+}
+
+html[dir='rtl'] .outlineItem > a {
+  padding: 2px 4px 5px 0;
+}
+html[dir='rtl'] .attachmentsItem > button {
+  padding: 2px 7px 3px 0;
+  text-align: right;
+}
+
+.outlineItemToggler {
+  position: relative;
+  height: 0;
+  width: 0;
+  color: hsla(0,0%,100%,.5);
+}
+.outlineItemToggler::before {
+  content: url(images/treeitem-expanded.png);
+  display: inline-block;
+  position: absolute;
+}
+html[dir='ltr'] .outlineItemToggler.outlineItemsHidden::before {
+  content: url(images/treeitem-collapsed.png);
+}
+html[dir='rtl'] .outlineItemToggler.outlineItemsHidden::before {
+  content: url(images/treeitem-collapsed-rtl.png);
+}
+.outlineItemToggler.outlineItemsHidden ~ .outlineItems {
+  display: none;
+}
+html[dir='ltr'] .outlineItemToggler {
+  float: left;
+}
+html[dir='rtl'] .outlineItemToggler {
+  float: right;
+}
+html[dir='ltr'] .outlineItemToggler::before {
+  right: 4px;
+}
+html[dir='rtl'] .outlineItemToggler::before {
+  left: 4px;
+}
+
+.outlineItemToggler:hover,
+.outlineItemToggler:hover + a,
+.outlineItemToggler:hover ~ .outlineItems,
+.outlineItem > a:hover,
+.attachmentsItem > button:hover {
+  background-color: hsla(0,0%,100%,.02);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.2) inset,
+              0 0 1px hsla(0,0%,0%,.2);
+  border-radius: 2px;
+  color: hsla(0,0%,100%,.9);
+}
+
+.outlineItem.selected {
+  background-color: hsla(0,0%,100%,.08);
+  background-image: linear-gradient(hsla(0,0%,100%,.05), hsla(0,0%,100%,0));
+  background-clip: padding-box;
+  box-shadow: 0 1px 0 hsla(0,0%,100%,.05) inset,
+              0 0 1px hsla(0,0%,100%,.1) inset,
+              0 0 1px hsla(0,0%,0%,.2);
+  color: hsla(0,0%,100%,1);
+}
+
+.noResults {
+  font-size: 12px;
+  color: hsla(0,0%,100%,.8);
+  font-style: italic;
+  cursor: default;
+}
+
+/* TODO: file FF bug to support ::-moz-selection:window-inactive
+   so we can override the opaque grey background when the window is inactive;
+   see https://bugzilla.mozilla.org/show_bug.cgi?id=706209 */
+::selection { background: rgba(0,0,255,0.3); }
+::-moz-selection { background: rgba(0,0,255,0.3); }
+
+#errorWrapper {
+  background: none repeat scroll 0 0 #FF5555;
+  color: white;
+  left: 0;
+  position: absolute;
+  right: 0;
+  z-index: 1000;
+  padding: 3px;
+  font-size: 0.8em;
+}
+.loadingInProgress #errorWrapper {
+  top: 37px;
+}
+
+#errorMessageLeft {
+  float: left;
+}
+
+#errorMessageRight {
+  float: right;
+}
+
+#errorMoreInfo {
+  background-color: #FFFFFF;
+  color: black;
+  padding: 3px;
+  margin: 3px;
+  width: 98%;
+}
+
+.overlayButton {
+  width: auto;
+  margin: 3px 4px 2px 4px !important;
+  padding: 2px 6px 3px 6px;
+}
+
+#overlayContainer {
+  display: table;
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  background-color: hsla(0,0%,0%,.2);
+  z-index: 40000;
+}
+#overlayContainer > * {
+  overflow: auto;
+}
+
+#overlayContainer > .container {
+  display: table-cell;
+  vertical-align: middle;
+  text-align: center;
+}
+
+#overlayContainer > .container > .dialog {
+  display: inline-block;
+  padding: 15px;
+  border-spacing: 4px;
+  color: hsl(0,0%,85%);
+  font-size: 12px;
+  line-height: 14px;
+  background-color: #474747; /* fallback */
+  background-image: url(images/texture.png),
+                    linear-gradient(hsla(0,0%,32%,.99), hsla(0,0%,27%,.95));
+  box-shadow: inset 1px 0 0 hsla(0,0%,100%,.08),
+              inset 0 1px 1px hsla(0,0%,0%,.15),
+              inset 0 -1px 0 hsla(0,0%,100%,.05),
+              0 1px 0 hsla(0,0%,0%,.15),
+              0 1px 1px hsla(0,0%,0%,.1);
+  border: 1px solid hsla(0,0%,0%,.5);
+  border-radius: 4px;
+  box-shadow: 0 1px 4px rgba(0, 0, 0, 0.3);
+}
+
+.dialog > .row {
+  display: table-row;
+}
+
+.dialog > .row > * {
+  display: table-cell;
+}
+
+.dialog .toolbarField {
+  margin: 5px 0;
+}
+
+.dialog .separator {
+  display: block;
+  margin: 4px 0 4px 0;
+  height: 1px;
+  width: 100%;
+  background-color: hsla(0,0%,0%,.5);
+  box-shadow: 0 0 0 1px hsla(0,0%,100%,.08);
+}
+
+.dialog .buttonRow {
+  text-align: center;
+  vertical-align: middle;
+}
+
+.dialog :link {
+  color: white;
+}
+
+#passwordOverlay > .dialog {
+  text-align: center;
+}
+#passwordOverlay .toolbarField {
+  width: 200px;
+}
+
+#documentPropertiesOverlay > .dialog {
+  text-align: left;
+}
+#documentPropertiesOverlay .row > * {
+  min-width: 100px;
+}
+html[dir='ltr'] #documentPropertiesOverlay .row > * {
+  text-align: left;
+}
+html[dir='rtl'] #documentPropertiesOverlay .row > * {
+  text-align: right;
+}
+#documentPropertiesOverlay .row > span {
+  width: 125px;
+  word-wrap: break-word;
+}
+#documentPropertiesOverlay .row > p {
+  max-width: 225px;
+  word-wrap: break-word;
+}
+#documentPropertiesOverlay .buttonRow {
+  margin-top: 10px;
+}
+
+.clearBoth {
+  clear: both;
+}
+
+.fileInput {
+  background: white;
+  color: black;
+  margin-top: 5px;
+  visibility: hidden;
+  position: fixed;
+  right: 0;
+  top: 0;
+}
+
+#PDFBug {
+  background: none repeat scroll 0 0 white;
+  border: 1px solid #666666;
+  position: fixed;
+  top: 32px;
+  right: 0;
+  bottom: 0;
+  font-size: 10px;
+  padding: 0;
+  width: 300px;
+}
+#PDFBug .controls {
+    background:#EEEEEE;
+    border-bottom: 1px solid #666666;
+    padding: 3px;
+}
+#PDFBug .panels {
+  bottom: 0;
+  left: 0;
+  overflow: auto;
+  position: absolute;
+  right: 0;
+  top: 27px;
+}
+#PDFBug button.active {
+  font-weight: bold;
+}
+.debuggerShowText {
+  background: none repeat scroll 0 0 yellow;
+  color: blue;
+}
+.debuggerHideText:hover {
+  background: none repeat scroll 0 0 yellow;
+}
+#PDFBug .stats {
+  font-family: courier;
+  font-size: 10px;
+  white-space: pre;
+}
+#PDFBug .stats .title {
+    font-weight: bold;
+}
+#PDFBug table {
+  font-size: 10px;
+}
+
+#viewer.textLayer-visible .textLayer {
+  opacity: 1.0;
+}
+
+#viewer.textLayer-visible .canvasWrapper {
+  background-color: rgb(128,255,128);
+}
+
+#viewer.textLayer-visible .canvasWrapper canvas {
+  mix-blend-mode: screen;
+}
+
+#viewer.textLayer-visible .textLayer > div {
+  background-color: rgba(255, 255, 0, 0.1);
+  color: black;
+  border: solid 1px rgba(255, 0, 0, 0.5);
+  box-sizing: border-box;
+}
+
+#viewer.textLayer-hover .textLayer > div:hover {
+  background-color: white;
+  color: black;
+}
+
+#viewer.textLayer-shadow .textLayer > div {
+  background-color: rgba(255,255,255, .6);
+  color: black;
+}
+
+.grab-to-pan-grab {
+  cursor: url("images/grab.cur"), move !important;
+  cursor: grab !important;
+}
+.grab-to-pan-grab *:not(input):not(textarea):not(button):not(select):not(:link) {
+  cursor: inherit !important;
+}
+.grab-to-pan-grab:active,
+.grab-to-pan-grabbing {
+  cursor: url("images/grabbing.cur"), move !important;
+  cursor: grabbing !important;
+
+  position: fixed;
+  background: transparent;
+  display: block;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  overflow: hidden;
+  z-index: 50000; /* should be higher than anything else in PDF.js! */
+}
+
+@page {
+  margin: 0;
+}
+
+#printContainer {
+  display: none;
+}
+
+@media screen and (min-resolution: 2dppx) {
+  /* Rules for Retina screens */
+  .toolbarButton::before {
+    transform: scale(0.5);
+    top: -5px;
+  }
+
+  .secondaryToolbarButton::before {
+    transform: scale(0.5);
+    top: -4px;
+  }
+
+  html[dir='ltr'] .toolbarButton::before,
+  html[dir='rtl'] .toolbarButton::before {
+    left: -1px;
+  }
+
+  html[dir='ltr'] .secondaryToolbarButton::before {
+    left: -2px;
+  }
+  html[dir='rtl'] .secondaryToolbarButton::before {
+    left: 186px;
+  }
+
+  .toolbarField.pageNumber.visiblePageIsLoading,
+  #findInput[data-status="pending"] {
+    background-image: url(images/loading-small@2x.png);
+    background-size: 16px 17px;
+  }
+
+  .dropdownToolbarButton {
+    background: url(images/toolbarButton-menuArrows@2x.png) no-repeat;
+    background-size: 7px 16px;
+  }
+
+  html[dir='ltr'] .toolbarButton#sidebarToggle::before {
+    content: url(images/toolbarButton-sidebarToggle@2x.png);
+  }
+  html[dir='rtl'] .toolbarButton#sidebarToggle::before {
+    content: url(images/toolbarButton-sidebarToggle-rtl@2x.png);
+  }
+
+  html[dir='ltr'] .toolbarButton#secondaryToolbarToggle::before {
+    content: url(images/toolbarButton-secondaryToolbarToggle@2x.png);
+  }
+  html[dir='rtl'] .toolbarButton#secondaryToolbarToggle::before {
+    content: url(images/toolbarButton-secondaryToolbarToggle-rtl@2x.png);
+  }
+
+  html[dir='ltr'] .toolbarButton.findPrevious::before {
+    content: url(images/findbarButton-previous@2x.png);
+  }
+  html[dir='rtl'] .toolbarButton.findPrevious::before {
+    content: url(images/findbarButton-previous-rtl@2x.png);
+  }
+
+  html[dir='ltr'] .toolbarButton.findNext::before {
+    content: url(images/findbarButton-next@2x.png);
+  }
+  html[dir='rtl'] .toolbarButton.findNext::before {
+    content: url(images/findbarButton-next-rtl@2x.png);
+  }
+
+  html[dir='ltr'] .toolbarButton.pageUp::before {
+    content: url(images/toolbarButton-pageUp@2x.png);
+  }
+  html[dir='rtl'] .toolbarButton.pageUp::before {
+    content: url(images/toolbarButton-pageUp-rtl@2x.png);
+  }
+
+  html[dir='ltr'] .toolbarButton.pageDown::before {
+    content: url(images/toolbarButton-pageDown@2x.png);
+  }
+  html[dir='rtl'] .toolbarButton.pageDown::before {
+    content: url(images/toolbarButton-pageDown-rtl@2x.png);
+  }
+
+  .toolbarButton.zoomIn::before {
+    content: url(images/toolbarButton-zoomIn@2x.png);
+  }
+
+  .toolbarButton.zoomOut::before {
+    content: url(images/toolbarButton-zoomOut@2x.png);
+  }
+
+  .toolbarButton.presentationMode::before,
+  .secondaryToolbarButton.presentationMode::before {
+    content: url(images/toolbarButton-presentationMode@2x.png);
+  }
+
+  .toolbarButton.print::before,
+  .secondaryToolbarButton.print::before {
+    content: url(images/toolbarButton-print@2x.png);
+  }
+
+  .toolbarButton.openFile::before,
+  .secondaryToolbarButton.openFile::before {
+    content: url(images/toolbarButton-openFile@2x.png);
+  }
+
+  .toolbarButton.download::before,
+  .secondaryToolbarButton.download::before {
+    content: url(images/toolbarButton-download@2x.png);
+  }
+
+  .toolbarButton.bookmark::before,
+  .secondaryToolbarButton.bookmark::before {
+    content: url(images/toolbarButton-bookmark@2x.png);
+  }
+
+  #viewThumbnail.toolbarButton::before {
+    content: url(images/toolbarButton-viewThumbnail@2x.png);
+  }
+
+  html[dir="ltr"] #viewOutline.toolbarButton::before {
+    content: url(images/toolbarButton-viewOutline@2x.png);
+  }
+  html[dir="rtl"] #viewOutline.toolbarButton::before {
+    content: url(images/toolbarButton-viewOutline-rtl@2x.png);
+  }
+
+  #viewAttachments.toolbarButton::before {
+    content: url(images/toolbarButton-viewAttachments@2x.png);
+  }
+
+  #viewFind.toolbarButton::before {
+    content: url(images/toolbarButton-search@2x.png);
+  }
+
+  .secondaryToolbarButton.firstPage::before {
+    content: url(images/secondaryToolbarButton-firstPage@2x.png);
+  }
+
+  .secondaryToolbarButton.lastPage::before {
+    content: url(images/secondaryToolbarButton-lastPage@2x.png);
+  }
+
+  .secondaryToolbarButton.rotateCcw::before {
+    content: url(images/secondaryToolbarButton-rotateCcw@2x.png);
+  }
+
+  .secondaryToolbarButton.rotateCw::before {
+    content: url(images/secondaryToolbarButton-rotateCw@2x.png);
+  }
+
+  .secondaryToolbarButton.handTool::before {
+    content: url(images/secondaryToolbarButton-handTool@2x.png);
+  }
+
+  .secondaryToolbarButton.documentProperties::before {
+    content: url(images/secondaryToolbarButton-documentProperties@2x.png);
+  }
+
+  .outlineItemToggler::before {
+    transform: scale(0.5);
+    top: -1px;
+    content: url(images/treeitem-expanded@2x.png);
+  }
+  html[dir='ltr'] .outlineItemToggler.outlineItemsHidden::before {
+    content: url(images/treeitem-collapsed@2x.png);
+  }
+  html[dir='rtl'] .outlineItemToggler.outlineItemsHidden::before {
+    content: url(images/treeitem-collapsed-rtl@2x.png);
+  }
+  html[dir='ltr'] .outlineItemToggler::before {
+    right: 0;
+  }
+  html[dir='rtl'] .outlineItemToggler::before {
+    left: 0;
+  }
+}
+
+@media print {
+  /* General rules for printing. */
+  body {
+    background: transparent none;
+  }
+
+  /* Rules for browsers that don't support mozPrintCallback. */
+  #sidebarContainer, #secondaryToolbar, .toolbar, #loadingBox, #errorWrapper, .textLayer {
+    display: none;
+  }
+  #viewerContainer {
+    overflow: visible;
+  }
+
+  #mainContainer, #viewerContainer, .page, .page canvas {
+    position: static;
+    padding: 0;
+    margin: 0;
+  }
+
+  .page {
+    float: left;
+    display: none;
+    border: none;
+    box-shadow: none;
+    background-clip: content-box;
+    background-color: white;
+  }
+
+  .page[data-loaded] {
+    display: block;
+  }
+
+  .fileInput {
+    display: none;
+  }
+
+  /* Rules for browsers that support PDF.js printing */
+  body[data-pdfjsprinting] #outerContainer {
+    display: none;
+  }
+  body[data-pdfjsprinting] #printContainer {
+    display: block;
+  }
+  #printContainer {
+    height: 100%;
+  }
+  /* wrapper around (scaled) print canvas elements */
+  #printContainer > div {
+    position: relative;
+    top: 0;
+    left: 0;
+    width: 1px;
+    height: 1px;
+    overflow: visible;
+    page-break-after: always;
+    page-break-inside: avoid;
+  }
+  #printContainer canvas,
+  #printContainer img {
+    display: block;
+  }
+}
+
+.visibleLargeView,
+.visibleMediumView,
+.visibleSmallView {
+  display: none;
+}
+
+@media all and (max-width: 1040px) {
+  #outerContainer.sidebarMoving #toolbarViewerMiddle,
+  #outerContainer.sidebarOpen #toolbarViewerMiddle {
+    display: table;
+    margin: auto;
+    left: auto;
+    position: inherit;
+    transform: none;
+  }
+}
+
+@media all and (max-width: 980px) {
+  .sidebarMoving .hiddenLargeView,
+  .sidebarOpen .hiddenLargeView {
+    display: none;
+  }
+  .sidebarMoving .visibleLargeView,
+  .sidebarOpen .visibleLargeView {
+    display: inherit;
+  }
+}
+
+@media all and (max-width: 900px) {
+  #toolbarViewerMiddle {
+    display: table;
+    margin: auto;
+    left: auto;
+    position: inherit;
+    transform: none;
+  }
+  .sidebarMoving .hiddenMediumView,
+  .sidebarOpen .hiddenMediumView {
+    display: none;
+  }
+  .sidebarMoving .visibleMediumView,
+  .sidebarOpen .visibleMediumView {
+    display: inherit;
+  }
+}
+
+@media all and (max-width: 840px) {
+  #sidebarContainer {
+    top: 32px;
+    z-index: 100;
+  }
+  .loadingInProgress #sidebarContainer {
+    top: 37px;
+  }
+  #sidebarContent {
+    top: 32px;
+    background-color: hsla(0,0%,0%,.7);
+  }
+
+  html[dir='ltr'] #outerContainer.sidebarOpen > #mainContainer {
+    left: 0px;
+  }
+  html[dir='rtl'] #outerContainer.sidebarOpen > #mainContainer {
+    right: 0px;
+  }
+
+  #outerContainer .hiddenLargeView,
+  #outerContainer .hiddenMediumView {
+    display: inherit;
+  }
+  #outerContainer .visibleLargeView,
+  #outerContainer .visibleMediumView {
+    display: none;
+  }
+}
+
+@media all and (max-width: 770px) {
+  #outerContainer .hiddenLargeView {
+    display: none;
+  }
+  #outerContainer .visibleLargeView {
+    display: inherit;
+  }
+}
+
+@media all and (max-width: 700px) {
+  #outerContainer .hiddenMediumView {
+    display: none;
+  }
+  #outerContainer .visibleMediumView {
+    display: inherit;
+  }
+}
+
+@media all and (max-width: 640px) {
+  .hiddenSmallView {
+    display: none;
+  }
+  .visibleSmallView {
+    display: inherit;
+  }
+  .toolbarButtonSpacer {
+    width: 0;
+  }
+}
+
+@media all and (max-width: 535px) {
+  #scaleSelectContainer {
+    display: none;
+  }
+}
diff --git a/application/basilisk/extensions/pdfjs/content/web/viewer.html b/application/basilisk/extensions/pdfjs/content/web/viewer.html
new file mode 100644
index 000000000..3a06aa7b1
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/viewer.html
@@ -0,0 +1,337 @@
+<!DOCTYPE html>
+<!--
+Copyright 2012 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.
+
+Adobe CMap resources are covered by their own copyright but the same license:
+
+    Copyright 1990-2015 Adobe Systems Incorporated.
+
+See https://github.com/adobe-type-tools/cmap-resources
+-->
+<html dir="ltr" mozdisallowselectionprint moznomarginboxes>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+    <title>PDF.js viewer</title>
+
+<!-- This snippet is used in the Firefox extension (included from viewer.html) -->
+<base href="resource://pdf.js/web/">
+<script src="l10n.js"></script>
+<script src="../build/pdf.js"></script>
+
+
+    <link rel="stylesheet" href="viewer.css">
+
+
+
+
+
+
+    <script src="viewer.js"></script>
+
+  </head>
+
+  <body tabindex="1" class="loadingInProgress">
+    <div id="outerContainer">
+
+      <div id="sidebarContainer">
+        <div id="toolbarSidebar">
+          <div class="splitToolbarButton toggled">
+            <button id="viewThumbnail" class="toolbarButton group toggled" title="Show Thumbnails" tabindex="2" data-l10n-id="thumbs">
+               <span data-l10n-id="thumbs_label">Thumbnails</span>
+            </button>
+            <button id="viewOutline" class="toolbarButton group" title="Show Document Outline (double-click to expand/collapse all items)" tabindex="3" data-l10n-id="document_outline">
+               <span data-l10n-id="document_outline_label">Document Outline</span>
+            </button>
+            <button id="viewAttachments" class="toolbarButton group" title="Show Attachments" tabindex="4" data-l10n-id="attachments">
+               <span data-l10n-id="attachments_label">Attachments</span>
+            </button>
+          </div>
+        </div>
+        <div id="sidebarContent">
+          <div id="thumbnailView">
+          </div>
+          <div id="outlineView" class="hidden">
+          </div>
+          <div id="attachmentsView" class="hidden">
+          </div>
+        </div>
+      </div>  <!-- sidebarContainer -->
+
+      <div id="mainContainer">
+        <div class="findbar hidden doorHanger hiddenSmallView" id="findbar">
+          <label for="findInput" class="toolbarLabel" data-l10n-id="find_label">Find:</label>
+          <input id="findInput" class="toolbarField" tabindex="91">
+          <div class="splitToolbarButton">
+            <button class="toolbarButton findPrevious" title="" id="findPrevious" tabindex="92" data-l10n-id="find_previous">
+              <span data-l10n-id="find_previous_label">Previous</span>
+            </button>
+            <div class="splitToolbarButtonSeparator"></div>
+            <button class="toolbarButton findNext" title="" id="findNext" tabindex="93" data-l10n-id="find_next">
+              <span data-l10n-id="find_next_label">Next</span>
+            </button>
+          </div>
+          <input type="checkbox" id="findHighlightAll" class="toolbarField" tabindex="94">
+          <label for="findHighlightAll" class="toolbarLabel" data-l10n-id="find_highlight">Highlight all</label>
+          <input type="checkbox" id="findMatchCase" class="toolbarField" tabindex="95">
+          <label for="findMatchCase" class="toolbarLabel" data-l10n-id="find_match_case_label">Match case</label>
+          <span id="findResultsCount" class="toolbarLabel hidden"></span>
+          <span id="findMsg" class="toolbarLabel"></span>
+        </div>  <!-- findbar -->
+
+        <div id="secondaryToolbar" class="secondaryToolbar hidden doorHangerRight">
+          <div id="secondaryToolbarButtonContainer">
+            <button id="secondaryPresentationMode" class="secondaryToolbarButton presentationMode visibleLargeView" title="Switch to Presentation Mode" tabindex="51" data-l10n-id="presentation_mode">
+              <span data-l10n-id="presentation_mode_label">Presentation Mode</span>
+            </button>
+
+            <button id="secondaryOpenFile" class="secondaryToolbarButton openFile visibleLargeView" title="Open File" tabindex="52" data-l10n-id="open_file">
+              <span data-l10n-id="open_file_label">Open</span>
+            </button>
+
+            <button id="secondaryPrint" class="secondaryToolbarButton print visibleMediumView" title="Print" tabindex="53" data-l10n-id="print">
+              <span data-l10n-id="print_label">Print</span>
+            </button>
+
+            <button id="secondaryDownload" class="secondaryToolbarButton download visibleMediumView" title="Download" tabindex="54" data-l10n-id="download">
+              <span data-l10n-id="download_label">Download</span>
+            </button>
+
+            <a href="#" id="secondaryViewBookmark" class="secondaryToolbarButton bookmark visibleSmallView" title="Current view (copy or open in new window)" tabindex="55" data-l10n-id="bookmark">
+              <span data-l10n-id="bookmark_label">Current View</span>
+            </a>
+
+            <div class="horizontalToolbarSeparator visibleLargeView"></div>
+
+            <button id="firstPage" class="secondaryToolbarButton firstPage" title="Go to First Page" tabindex="56" data-l10n-id="first_page">
+              <span data-l10n-id="first_page_label">Go to First Page</span>
+            </button>
+            <button id="lastPage" class="secondaryToolbarButton lastPage" title="Go to Last Page" tabindex="57" data-l10n-id="last_page">
+              <span data-l10n-id="last_page_label">Go to Last Page</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator"></div>
+
+            <button id="pageRotateCw" class="secondaryToolbarButton rotateCw" title="Rotate Clockwise" tabindex="58" data-l10n-id="page_rotate_cw">
+              <span data-l10n-id="page_rotate_cw_label">Rotate Clockwise</span>
+            </button>
+            <button id="pageRotateCcw" class="secondaryToolbarButton rotateCcw" title="Rotate Counterclockwise" tabindex="59" data-l10n-id="page_rotate_ccw">
+              <span data-l10n-id="page_rotate_ccw_label">Rotate Counterclockwise</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator"></div>
+
+            <button id="toggleHandTool" class="secondaryToolbarButton handTool" title="Enable hand tool" tabindex="60" data-l10n-id="hand_tool_enable">
+              <span data-l10n-id="hand_tool_enable_label">Enable hand tool</span>
+            </button>
+
+            <div class="horizontalToolbarSeparator"></div>
+
+            <button id="documentProperties" class="secondaryToolbarButton documentProperties" title="Document Properties…" tabindex="61" data-l10n-id="document_properties">
+              <span data-l10n-id="document_properties_label">Document Properties…</span>
+            </button>
+          </div>
+        </div>  <!-- secondaryToolbar -->
+
+        <div class="toolbar">
+          <div id="toolbarContainer">
+            <div id="toolbarViewer">
+              <div id="toolbarViewerLeft">
+                <button id="sidebarToggle" class="toolbarButton" title="Toggle Sidebar" tabindex="11" data-l10n-id="toggle_sidebar">
+                  <span data-l10n-id="toggle_sidebar_label">Toggle Sidebar</span>
+                </button>
+                <div class="toolbarButtonSpacer"></div>
+                <button id="viewFind" class="toolbarButton group hiddenSmallView" title="Find in Document" tabindex="12" data-l10n-id="findbar">
+                   <span data-l10n-id="findbar_label">Find</span>
+                </button>
+                <div class="splitToolbarButton">
+                  <button class="toolbarButton pageUp" title="Previous Page" id="previous" tabindex="13" data-l10n-id="previous">
+                    <span data-l10n-id="previous_label">Previous</span>
+                  </button>
+                  <div class="splitToolbarButtonSeparator"></div>
+                  <button class="toolbarButton pageDown" title="Next Page" id="next" tabindex="14" data-l10n-id="next">
+                    <span data-l10n-id="next_label">Next</span>
+                  </button>
+                </div>
+                <input type="number" id="pageNumber" class="toolbarField pageNumber" title="Page" value="1" size="4" min="1" tabindex="15" data-l10n-id="page">
+                <span id="numPages" class="toolbarLabel"></span>
+              </div>
+              <div id="toolbarViewerRight">
+                <button id="presentationMode" class="toolbarButton presentationMode hiddenLargeView" title="Switch to Presentation Mode" tabindex="31" data-l10n-id="presentation_mode">
+                  <span data-l10n-id="presentation_mode_label">Presentation Mode</span>
+                </button>
+
+                <button id="openFile" class="toolbarButton openFile hiddenLargeView" title="Open File" tabindex="32" data-l10n-id="open_file">
+                  <span data-l10n-id="open_file_label">Open</span>
+                </button>
+
+                <button id="print" class="toolbarButton print hiddenMediumView" title="Print" tabindex="33" data-l10n-id="print">
+                  <span data-l10n-id="print_label">Print</span>
+                </button>
+
+                <button id="download" class="toolbarButton download hiddenMediumView" title="Download" tabindex="34" data-l10n-id="download">
+                  <span data-l10n-id="download_label">Download</span>
+                </button>
+                <a href="#" id="viewBookmark" class="toolbarButton bookmark hiddenSmallView" title="Current view (copy or open in new window)" tabindex="35" data-l10n-id="bookmark">
+                  <span data-l10n-id="bookmark_label">Current View</span>
+                </a>
+
+                <div class="verticalToolbarSeparator hiddenSmallView"></div>
+
+                <button id="secondaryToolbarToggle" class="toolbarButton" title="Tools" tabindex="36" data-l10n-id="tools">
+                  <span data-l10n-id="tools_label">Tools</span>
+                </button>
+              </div>
+              <div id="toolbarViewerMiddle">
+                <div class="splitToolbarButton">
+                  <button id="zoomOut" class="toolbarButton zoomOut" title="Zoom Out" tabindex="21" data-l10n-id="zoom_out">
+                    <span data-l10n-id="zoom_out_label">Zoom Out</span>
+                  </button>
+                  <div class="splitToolbarButtonSeparator"></div>
+                  <button id="zoomIn" class="toolbarButton zoomIn" title="Zoom In" tabindex="22" data-l10n-id="zoom_in">
+                    <span data-l10n-id="zoom_in_label">Zoom In</span>
+                   </button>
+                </div>
+                <span id="scaleSelectContainer" class="dropdownToolbarButton">
+                  <select id="scaleSelect" title="Zoom" tabindex="23" data-l10n-id="zoom">
+                    <option id="pageAutoOption" title="" value="auto" selected="selected" data-l10n-id="page_scale_auto">Automatic Zoom</option>
+                    <option id="pageActualOption" title="" value="page-actual" data-l10n-id="page_scale_actual">Actual Size</option>
+                    <option id="pageFitOption" title="" value="page-fit" data-l10n-id="page_scale_fit">Fit Page</option>
+                    <option id="pageWidthOption" title="" value="page-width" data-l10n-id="page_scale_width">Full Width</option>
+                    <option id="customScaleOption" title="" value="custom" disabled="disabled" hidden="true"></option>
+                    <option title="" value="0.5" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 50 }'>50%</option>
+                    <option title="" value="0.75" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 75 }'>75%</option>
+                    <option title="" value="1" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 100 }'>100%</option>
+                    <option title="" value="1.25" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 125 }'>125%</option>
+                    <option title="" value="1.5" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 150 }'>150%</option>
+                    <option title="" value="2" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 200 }'>200%</option>
+                    <option title="" value="3" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 300 }'>300%</option>
+                    <option title="" value="4" data-l10n-id="page_scale_percent" data-l10n-args='{ "scale": 400 }'>400%</option>
+                  </select>
+                </span>
+              </div>
+            </div>
+            <div id="loadingBar">
+              <div class="progress">
+                <div class="glimmer">
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <menu type="context" id="viewerContextMenu">
+          <menuitem id="contextFirstPage" label="First Page"
+                    data-l10n-id="first_page"></menuitem>
+          <menuitem id="contextLastPage" label="Last Page"
+                    data-l10n-id="last_page"></menuitem>
+          <menuitem id="contextPageRotateCw" label="Rotate Clockwise"
+                    data-l10n-id="page_rotate_cw"></menuitem>
+          <menuitem id="contextPageRotateCcw" label="Rotate Counter-Clockwise"
+                    data-l10n-id="page_rotate_ccw"></menuitem>
+        </menu>
+
+        <div id="viewerContainer" tabindex="0">
+          <div id="viewer" class="pdfViewer"></div>
+        </div>
+
+        <div id="errorWrapper" hidden='true'>
+          <div id="errorMessageLeft">
+            <span id="errorMessage"></span>
+            <button id="errorShowMore" data-l10n-id="error_more_info">
+              More Information
+            </button>
+            <button id="errorShowLess" data-l10n-id="error_less_info" hidden='true'>
+              Less Information
+            </button>
+          </div>
+          <div id="errorMessageRight">
+            <button id="errorClose" data-l10n-id="error_close">
+              Close
+            </button>
+          </div>
+          <div class="clearBoth"></div>
+          <textarea id="errorMoreInfo" hidden='true' readonly="readonly"></textarea>
+        </div>
+      </div> <!-- mainContainer -->
+
+      <div id="overlayContainer" class="hidden">
+        <div id="passwordOverlay" class="container hidden">
+          <div class="dialog">
+            <div class="row">
+              <p id="passwordText" data-l10n-id="password_label">Enter the password to open this PDF file:</p>
+            </div>
+            <div class="row">
+              <!-- The type="password" attribute is set via script, to prevent warnings in Firefox for all http:// documents. -->
+              <input id="password" class="toolbarField">
+            </div>
+            <div class="buttonRow">
+              <button id="passwordCancel" class="overlayButton"><span data-l10n-id="password_cancel">Cancel</span></button>
+              <button id="passwordSubmit" class="overlayButton"><span data-l10n-id="password_ok">OK</span></button>
+            </div>
+          </div>
+        </div>
+        <div id="documentPropertiesOverlay" class="container hidden">
+          <div class="dialog">
+            <div class="row">
+              <span data-l10n-id="document_properties_file_name">File name:</span> <p id="fileNameField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_file_size">File size:</span> <p id="fileSizeField">-</p>
+            </div>
+            <div class="separator"></div>
+            <div class="row">
+              <span data-l10n-id="document_properties_title">Title:</span> <p id="titleField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_author">Author:</span> <p id="authorField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_subject">Subject:</span> <p id="subjectField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_keywords">Keywords:</span> <p id="keywordsField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_creation_date">Creation Date:</span> <p id="creationDateField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_modification_date">Modification Date:</span> <p id="modificationDateField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_creator">Creator:</span> <p id="creatorField">-</p>
+            </div>
+            <div class="separator"></div>
+            <div class="row">
+              <span data-l10n-id="document_properties_producer">PDF Producer:</span> <p id="producerField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_version">PDF Version:</span> <p id="versionField">-</p>
+            </div>
+            <div class="row">
+              <span data-l10n-id="document_properties_page_count">Page Count:</span> <p id="pageCountField">-</p>
+            </div>
+            <div class="buttonRow">
+              <button id="documentPropertiesClose" class="overlayButton"><span data-l10n-id="document_properties_close">Close</span></button>
+            </div>
+          </div>
+        </div>
+      </div>  <!-- overlayContainer -->
+
+    </div> <!-- outerContainer -->
+    <div id="printContainer"></div>
+  </body>
+</html>
+
diff --git a/application/basilisk/extensions/pdfjs/content/web/viewer.js b/application/basilisk/extensions/pdfjs/content/web/viewer.js
new file mode 100644
index 000000000..35fef2cd0
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/content/web/viewer.js
@@ -0,0 +1,8671 @@
+/* Copyright 2016 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.
+ */
+'use strict';
+var DEFAULT_URL = 'compressed.tracemonkey-pldi-09.pdf';
+;
+var pdfjsWebLibs;
+{
+  pdfjsWebLibs = { pdfjsWebPDFJS: window.pdfjsDistBuildPdf };
+  (function () {
+    (function (root, factory) {
+      factory(root.pdfjsWebGrabToPan = {});
+    }(this, function (exports) {
+      /**
+       * Construct a GrabToPan instance for a given HTML element.
+       * @param options.element {Element}
+       * @param options.ignoreTarget {function} optional. See `ignoreTarget(node)`
+       * @param options.onActiveChanged {function(boolean)} optional. Called
+       *  when grab-to-pan is (de)activated. The first argument is a boolean that
+       *  shows whether grab-to-pan is activated.
+       */
+      function GrabToPan(options) {
+        this.element = options.element;
+        this.document = options.element.ownerDocument;
+        if (typeof options.ignoreTarget === 'function') {
+          this.ignoreTarget = options.ignoreTarget;
+        }
+        this.onActiveChanged = options.onActiveChanged;
+        // Bind the contexts to ensure that `this` always points to
+        // the GrabToPan instance.
+        this.activate = this.activate.bind(this);
+        this.deactivate = this.deactivate.bind(this);
+        this.toggle = this.toggle.bind(this);
+        this._onmousedown = this._onmousedown.bind(this);
+        this._onmousemove = this._onmousemove.bind(this);
+        this._endPan = this._endPan.bind(this);
+        // This overlay will be inserted in the document when the mouse moves during
+        // a grab operation, to ensure that the cursor has the desired appearance.
+        var overlay = this.overlay = document.createElement('div');
+        overlay.className = 'grab-to-pan-grabbing';
+      }
+      GrabToPan.prototype = {
+        /**
+         * Class name of element which can be grabbed
+         */
+        CSS_CLASS_GRAB: 'grab-to-pan-grab',
+        /**
+         * Bind a mousedown event to the element to enable grab-detection.
+         */
+        activate: function GrabToPan_activate() {
+          if (!this.active) {
+            this.active = true;
+            this.element.addEventListener('mousedown', this._onmousedown, true);
+            this.element.classList.add(this.CSS_CLASS_GRAB);
+            if (this.onActiveChanged) {
+              this.onActiveChanged(true);
+            }
+          }
+        },
+        /**
+         * Removes all events. Any pending pan session is immediately stopped.
+         */
+        deactivate: function GrabToPan_deactivate() {
+          if (this.active) {
+            this.active = false;
+            this.element.removeEventListener('mousedown', this._onmousedown, true);
+            this._endPan();
+            this.element.classList.remove(this.CSS_CLASS_GRAB);
+            if (this.onActiveChanged) {
+              this.onActiveChanged(false);
+            }
+          }
+        },
+        toggle: function GrabToPan_toggle() {
+          if (this.active) {
+            this.deactivate();
+          } else {
+            this.activate();
+          }
+        },
+        /**
+         * Whether to not pan if the target element is clicked.
+         * Override this method to change the default behaviour.
+         *
+         * @param node {Element} The target of the event
+         * @return {boolean} Whether to not react to the click event.
+         */
+        ignoreTarget: function GrabToPan_ignoreTarget(node) {
+          // Use matchesSelector to check whether the clicked element
+          // is (a child of) an input element / link
+          return node[matchesSelector]('a[href], a[href] *, input, textarea, button, button *, select, option');
+        },
+        /**
+         * @private
+         */
+        _onmousedown: function GrabToPan__onmousedown(event) {
+          if (event.button !== 0 || this.ignoreTarget(event.target)) {
+            return;
+          }
+          if (event.originalTarget) {
+            try {
+              event.originalTarget.tagName;
+            } catch (e) {
+              // Mozilla-specific: element is a scrollbar (XUL element)
+              return;
+            }
+          }
+          this.scrollLeftStart = this.element.scrollLeft;
+          this.scrollTopStart = this.element.scrollTop;
+          this.clientXStart = event.clientX;
+          this.clientYStart = event.clientY;
+          this.document.addEventListener('mousemove', this._onmousemove, true);
+          this.document.addEventListener('mouseup', this._endPan, true);
+          // When a scroll event occurs before a mousemove, assume that the user
+          // dragged a scrollbar (necessary for Opera Presto, Safari and IE)
+          // (not needed for Chrome/Firefox)
+          this.element.addEventListener('scroll', this._endPan, true);
+          event.preventDefault();
+          event.stopPropagation();
+          var focusedElement = document.activeElement;
+          if (focusedElement && !focusedElement.contains(event.target)) {
+            focusedElement.blur();
+          }
+        },
+        /**
+         * @private
+         */
+        _onmousemove: function GrabToPan__onmousemove(event) {
+          this.element.removeEventListener('scroll', this._endPan, true);
+          if (isLeftMouseReleased(event)) {
+            this._endPan();
+            return;
+          }
+          var xDiff = event.clientX - this.clientXStart;
+          var yDiff = event.clientY - this.clientYStart;
+          var scrollTop = this.scrollTopStart - yDiff;
+          var scrollLeft = this.scrollLeftStart - xDiff;
+          if (this.element.scrollTo) {
+            this.element.scrollTo({
+              top: scrollTop,
+              left: scrollLeft,
+              behavior: 'instant'
+            });
+          } else {
+            this.element.scrollTop = scrollTop;
+            this.element.scrollLeft = scrollLeft;
+          }
+          if (!this.overlay.parentNode) {
+            document.body.appendChild(this.overlay);
+          }
+        },
+        /**
+         * @private
+         */
+        _endPan: function GrabToPan__endPan() {
+          this.element.removeEventListener('scroll', this._endPan, true);
+          this.document.removeEventListener('mousemove', this._onmousemove, true);
+          this.document.removeEventListener('mouseup', this._endPan, true);
+          if (this.overlay.parentNode) {
+            this.overlay.parentNode.removeChild(this.overlay);
+          }
+        }
+      };
+      // Get the correct (vendor-prefixed) name of the matches method.
+      var matchesSelector;
+      [
+        'webkitM',
+        'mozM',
+        'msM',
+        'oM',
+        'm'
+      ].some(function (prefix) {
+        var name = prefix + 'atches';
+        if (name in document.documentElement) {
+          matchesSelector = name;
+        }
+        name += 'Selector';
+        if (name in document.documentElement) {
+          matchesSelector = name;
+        }
+        return matchesSelector;
+      });
+      // If found, then truthy, and [].some() ends.
+      // Browser sniffing because it's impossible to feature-detect
+      // whether event.which for onmousemove is reliable
+      var isNotIEorIsIE10plus = !document.documentMode || document.documentMode > 9;
+      var chrome = window.chrome;
+      var isChrome15OrOpera15plus = chrome && (chrome.webstore || chrome.app);
+      //                                       ^ Chrome 15+       ^ Opera 15+
+      var isSafari6plus = /Apple/.test(navigator.vendor) && /Version\/([6-9]\d*|[1-5]\d+)/.test(navigator.userAgent);
+      /**
+       * Whether the left mouse is not pressed.
+       * @param event {MouseEvent}
+       * @return {boolean} True if the left mouse button is not pressed.
+       *                   False if unsure or if the left mouse button is pressed.
+       */
+      function isLeftMouseReleased(event) {
+        if ('buttons' in event && isNotIEorIsIE10plus) {
+          // http://www.w3.org/TR/DOM-Level-3-Events/#events-MouseEvent-buttons
+          // Firefox 15+
+          // Internet Explorer 10+
+          return !(event.buttons & 1);
+        }
+        if (isChrome15OrOpera15plus || isSafari6plus) {
+          // Chrome 14+
+          // Opera 15+
+          // Safari 6.0+
+          return event.which === 0;
+        }
+      }
+      exports.GrabToPan = GrabToPan;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebOverlayManager = {});
+    }(this, function (exports) {
+      var OverlayManager = {
+        overlays: {},
+        active: null,
+        /**
+         * @param {string} name The name of the overlay that is registered.
+         * @param {HTMLDivElement} element The overlay's DOM element.
+         * @param {function} callerCloseMethod (optional) The method that, if present,
+         *                   will call OverlayManager.close from the Object
+         *                   registering the overlay. Access to this method is
+         *                   necessary in order to run cleanup code when e.g.
+         *                   the overlay is force closed. The default is null.
+         * @param {boolean} canForceClose (optional) Indicates if opening the overlay
+         *                  will close an active overlay. The default is false.
+         * @returns {Promise} A promise that is resolved when the overlay has been
+         *                    registered.
+         */
+        register: function overlayManagerRegister(name, element, callerCloseMethod, canForceClose) {
+          return new Promise(function (resolve) {
+            var container;
+            if (!name || !element || !(container = element.parentNode)) {
+              throw new Error('Not enough parameters.');
+            } else if (this.overlays[name]) {
+              throw new Error('The overlay is already registered.');
+            }
+            this.overlays[name] = {
+              element: element,
+              container: container,
+              callerCloseMethod: callerCloseMethod || null,
+              canForceClose: canForceClose || false
+            };
+            resolve();
+          }.bind(this));
+        },
+        /**
+         * @param {string} name The name of the overlay that is unregistered.
+         * @returns {Promise} A promise that is resolved when the overlay has been
+         *                    unregistered.
+         */
+        unregister: function overlayManagerUnregister(name) {
+          return new Promise(function (resolve) {
+            if (!this.overlays[name]) {
+              throw new Error('The overlay does not exist.');
+            } else if (this.active === name) {
+              throw new Error('The overlay cannot be removed while it is active.');
+            }
+            delete this.overlays[name];
+            resolve();
+          }.bind(this));
+        },
+        /**
+         * @param {string} name The name of the overlay that should be opened.
+         * @returns {Promise} A promise that is resolved when the overlay has been
+         *                    opened.
+         */
+        open: function overlayManagerOpen(name) {
+          return new Promise(function (resolve) {
+            if (!this.overlays[name]) {
+              throw new Error('The overlay does not exist.');
+            } else if (this.active) {
+              if (this.overlays[name].canForceClose) {
+                this._closeThroughCaller();
+              } else if (this.active === name) {
+                throw new Error('The overlay is already active.');
+              } else {
+                throw new Error('Another overlay is currently active.');
+              }
+            }
+            this.active = name;
+            this.overlays[this.active].element.classList.remove('hidden');
+            this.overlays[this.active].container.classList.remove('hidden');
+            window.addEventListener('keydown', this._keyDown);
+            resolve();
+          }.bind(this));
+        },
+        /**
+         * @param {string} name The name of the overlay that should be closed.
+         * @returns {Promise} A promise that is resolved when the overlay has been
+         *                    closed.
+         */
+        close: function overlayManagerClose(name) {
+          return new Promise(function (resolve) {
+            if (!this.overlays[name]) {
+              throw new Error('The overlay does not exist.');
+            } else if (!this.active) {
+              throw new Error('The overlay is currently not active.');
+            } else if (this.active !== name) {
+              throw new Error('Another overlay is currently active.');
+            }
+            this.overlays[this.active].container.classList.add('hidden');
+            this.overlays[this.active].element.classList.add('hidden');
+            this.active = null;
+            window.removeEventListener('keydown', this._keyDown);
+            resolve();
+          }.bind(this));
+        },
+        /**
+         * @private
+         */
+        _keyDown: function overlayManager_keyDown(evt) {
+          var self = OverlayManager;
+          if (self.active && evt.keyCode === 27) {
+            // Esc key.
+            self._closeThroughCaller();
+            evt.preventDefault();
+          }
+        },
+        /**
+         * @private
+         */
+        _closeThroughCaller: function overlayManager_closeThroughCaller() {
+          if (this.overlays[this.active].callerCloseMethod) {
+            this.overlays[this.active].callerCloseMethod();
+          }
+          if (this.active) {
+            this.close(this.active);
+          }
+        }
+      };
+      exports.OverlayManager = OverlayManager;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFRenderingQueue = {});
+    }(this, function (exports) {
+      var CLEANUP_TIMEOUT = 30000;
+      var RenderingStates = {
+        INITIAL: 0,
+        RUNNING: 1,
+        PAUSED: 2,
+        FINISHED: 3
+      };
+      /**
+       * Controls rendering of the views for pages and thumbnails.
+       * @class
+       */
+      var PDFRenderingQueue = function PDFRenderingQueueClosure() {
+        /**
+         * @constructs
+         */
+        function PDFRenderingQueue() {
+          this.pdfViewer = null;
+          this.pdfThumbnailViewer = null;
+          this.onIdle = null;
+          this.highestPriorityPage = null;
+          this.idleTimeout = null;
+          this.printing = false;
+          this.isThumbnailViewEnabled = false;
+        }
+        PDFRenderingQueue.prototype = /** @lends PDFRenderingQueue.prototype */
+        {
+          /**
+           * @param {PDFViewer} pdfViewer
+           */
+          setViewer: function PDFRenderingQueue_setViewer(pdfViewer) {
+            this.pdfViewer = pdfViewer;
+          },
+          /**
+           * @param {PDFThumbnailViewer} pdfThumbnailViewer
+           */
+          setThumbnailViewer: function PDFRenderingQueue_setThumbnailViewer(pdfThumbnailViewer) {
+            this.pdfThumbnailViewer = pdfThumbnailViewer;
+          },
+          /**
+           * @param {IRenderableView} view
+           * @returns {boolean}
+           */
+          isHighestPriority: function PDFRenderingQueue_isHighestPriority(view) {
+            return this.highestPriorityPage === view.renderingId;
+          },
+          renderHighestPriority: function PDFRenderingQueue_renderHighestPriority(currentlyVisiblePages) {
+            if (this.idleTimeout) {
+              clearTimeout(this.idleTimeout);
+              this.idleTimeout = null;
+            }
+            // Pages have a higher priority than thumbnails, so check them first.
+            if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
+              return;
+            }
+            // No pages needed rendering so check thumbnails.
+            if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
+              if (this.pdfThumbnailViewer.forceRendering()) {
+                return;
+              }
+            }
+            if (this.printing) {
+              // If printing is currently ongoing do not reschedule cleanup.
+              return;
+            }
+            if (this.onIdle) {
+              this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);
+            }
+          },
+          getHighestPriority: function PDFRenderingQueue_getHighestPriority(visible, views, scrolledDown) {
+            // The state has changed figure out which page has the highest priority to
+            // render next (if any).
+            // Priority:
+            // 1 visible pages
+            // 2 if last scrolled down page after the visible pages
+            // 2 if last scrolled up page before the visible pages
+            var visibleViews = visible.views;
+            var numVisible = visibleViews.length;
+            if (numVisible === 0) {
+              return false;
+            }
+            for (var i = 0; i < numVisible; ++i) {
+              var view = visibleViews[i].view;
+              if (!this.isViewFinished(view)) {
+                return view;
+              }
+            }
+            // All the visible views have rendered, try to render next/previous pages.
+            if (scrolledDown) {
+              var nextPageIndex = visible.last.id;
+              // ID's start at 1 so no need to add 1.
+              if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {
+                return views[nextPageIndex];
+              }
+            } else {
+              var previousPageIndex = visible.first.id - 2;
+              if (views[previousPageIndex] && !this.isViewFinished(views[previousPageIndex])) {
+                return views[previousPageIndex];
+              }
+            }
+            // Everything that needs to be rendered has been.
+            return null;
+          },
+          /**
+           * @param {IRenderableView} view
+           * @returns {boolean}
+           */
+          isViewFinished: function PDFRenderingQueue_isViewFinished(view) {
+            return view.renderingState === RenderingStates.FINISHED;
+          },
+          /**
+           * Render a page or thumbnail view. This calls the appropriate function
+           * based on the views state. If the view is already rendered it will return
+           * false.
+           * @param {IRenderableView} view
+           */
+          renderView: function PDFRenderingQueue_renderView(view) {
+            var state = view.renderingState;
+            switch (state) {
+            case RenderingStates.FINISHED:
+              return false;
+            case RenderingStates.PAUSED:
+              this.highestPriorityPage = view.renderingId;
+              view.resume();
+              break;
+            case RenderingStates.RUNNING:
+              this.highestPriorityPage = view.renderingId;
+              break;
+            case RenderingStates.INITIAL:
+              this.highestPriorityPage = view.renderingId;
+              var continueRendering = function () {
+                this.renderHighestPriority();
+              }.bind(this);
+              view.draw().then(continueRendering, continueRendering);
+              break;
+            }
+            return true;
+          }
+        };
+        return PDFRenderingQueue;
+      }();
+      exports.RenderingStates = RenderingStates;
+      exports.PDFRenderingQueue = PDFRenderingQueue;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPreferences = {});
+    }(this, function (exports) {
+      var defaultPreferences;
+      defaultPreferences = Promise.resolve({
+        "showPreviousViewOnLoad": true,
+        "defaultZoomValue": "",
+        "sidebarViewOnLoad": 0,
+        "enableHandToolOnLoad": false,
+        "enableWebGL": false,
+        "pdfBugEnabled": false,
+        "disableRange": false,
+        "disableStream": false,
+        "disableAutoFetch": false,
+        "disableFontFace": false,
+        "disableTextLayer": false,
+        "useOnlyCssZoom": false,
+        "externalLinkTarget": 0,
+        "enhanceTextSelection": false,
+        "renderInteractiveForms": false,
+        "disablePageLabels": false
+      });
+      function cloneObj(obj) {
+        var result = {};
+        for (var i in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, i)) {
+            result[i] = obj[i];
+          }
+        }
+        return result;
+      }
+      /**
+       * Preferences - Utility for storing persistent settings.
+       *   Used for settings that should be applied to all opened documents,
+       *   or every time the viewer is loaded.
+       */
+      var Preferences = {
+        prefs: null,
+        isInitializedPromiseResolved: false,
+        initializedPromise: null,
+        /**
+         * Initialize and fetch the current preference values from storage.
+         * @return {Promise} A promise that is resolved when the preferences
+         *                   have been initialized.
+         */
+        initialize: function preferencesInitialize() {
+          return this.initializedPromise = defaultPreferences.then(function (defaults) {
+            Object.defineProperty(this, 'defaults', {
+              value: Object.freeze(defaults),
+              writable: false,
+              enumerable: true,
+              configurable: false
+            });
+            this.prefs = cloneObj(defaults);
+            return this._readFromStorage(defaults);
+          }.bind(this)).then(function (prefObj) {
+            this.isInitializedPromiseResolved = true;
+            if (prefObj) {
+              this.prefs = prefObj;
+            }
+          }.bind(this));
+        },
+        /**
+         * Stub function for writing preferences to storage.
+         * NOTE: This should be overridden by a build-specific function defined below.
+         * @param {Object} prefObj The preferences that should be written to storage.
+         * @return {Promise} A promise that is resolved when the preference values
+         *                   have been written.
+         */
+        _writeToStorage: function preferences_writeToStorage(prefObj) {
+          return Promise.resolve();
+        },
+        /**
+         * Stub function for reading preferences from storage.
+         * NOTE: This should be overridden by a build-specific function defined below.
+         * @param {Object} prefObj The preferences that should be read from storage.
+         * @return {Promise} A promise that is resolved with an {Object} containing
+         *                   the preferences that have been read.
+         */
+        _readFromStorage: function preferences_readFromStorage(prefObj) {
+          return Promise.resolve();
+        },
+        /**
+         * Reset the preferences to their default values and update storage.
+         * @return {Promise} A promise that is resolved when the preference values
+         *                   have been reset.
+         */
+        reset: function preferencesReset() {
+          return this.initializedPromise.then(function () {
+            this.prefs = cloneObj(this.defaults);
+            return this._writeToStorage(this.defaults);
+          }.bind(this));
+        },
+        /**
+         * Replace the current preference values with the ones from storage.
+         * @return {Promise} A promise that is resolved when the preference values
+         *                   have been updated.
+         */
+        reload: function preferencesReload() {
+          return this.initializedPromise.then(function () {
+            this._readFromStorage(this.defaults).then(function (prefObj) {
+              if (prefObj) {
+                this.prefs = prefObj;
+              }
+            }.bind(this));
+          }.bind(this));
+        },
+        /**
+         * Set the value of a preference.
+         * @param {string} name The name of the preference that should be changed.
+         * @param {boolean|number|string} value The new value of the preference.
+         * @return {Promise} A promise that is resolved when the value has been set,
+         *                   provided that the preference exists and the types match.
+         */
+        set: function preferencesSet(name, value) {
+          return this.initializedPromise.then(function () {
+            if (this.defaults[name] === undefined) {
+              throw new Error('preferencesSet: \'' + name + '\' is undefined.');
+            } else if (value === undefined) {
+              throw new Error('preferencesSet: no value is specified.');
+            }
+            var valueType = typeof value;
+            var defaultType = typeof this.defaults[name];
+            if (valueType !== defaultType) {
+              if (valueType === 'number' && defaultType === 'string') {
+                value = value.toString();
+              } else {
+                throw new Error('Preferences_set: \'' + value + '\' is a \"' + valueType + '\", expected \"' + defaultType + '\".');
+              }
+            } else {
+              if (valueType === 'number' && (value | 0) !== value) {
+                throw new Error('Preferences_set: \'' + value + '\' must be an \"integer\".');
+              }
+            }
+            this.prefs[name] = value;
+            return this._writeToStorage(this.prefs);
+          }.bind(this));
+        },
+        /**
+         * Get the value of a preference.
+         * @param {string} name The name of the preference whose value is requested.
+         * @return {Promise} A promise that is resolved with a {boolean|number|string}
+         *                   containing the value of the preference.
+         */
+        get: function preferencesGet(name) {
+          return this.initializedPromise.then(function () {
+            var defaultValue = this.defaults[name];
+            if (defaultValue === undefined) {
+              throw new Error('preferencesGet: \'' + name + '\' is undefined.');
+            } else {
+              var prefValue = this.prefs[name];
+              if (prefValue !== undefined) {
+                return prefValue;
+              }
+            }
+            return defaultValue;
+          }.bind(this));
+        }
+      };
+      exports.Preferences = Preferences;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebViewHistory = {});
+    }(this, function (exports) {
+      var DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;
+      /**
+       * View History - This is a utility for saving various view parameters for
+       *                recently opened files.
+       *
+       * The way that the view parameters are stored depends on how PDF.js is built,
+       * for 'gulp <flag>' the following cases exist:
+       *  - FIREFOX or MOZCENTRAL - uses sessionStorage.
+       *  - GENERIC or CHROME     - uses localStorage, if it is available.
+       */
+      var ViewHistory = function ViewHistoryClosure() {
+        function ViewHistory(fingerprint, cacheSize) {
+          this.fingerprint = fingerprint;
+          this.cacheSize = cacheSize || DEFAULT_VIEW_HISTORY_CACHE_SIZE;
+          this.isInitializedPromiseResolved = false;
+          this.initializedPromise = this._readFromStorage().then(function (databaseStr) {
+            this.isInitializedPromiseResolved = true;
+            var database = JSON.parse(databaseStr || '{}');
+            if (!('files' in database)) {
+              database.files = [];
+            }
+            if (database.files.length >= this.cacheSize) {
+              database.files.shift();
+            }
+            var index;
+            for (var i = 0, length = database.files.length; i < length; i++) {
+              var branch = database.files[i];
+              if (branch.fingerprint === this.fingerprint) {
+                index = i;
+                break;
+              }
+            }
+            if (typeof index !== 'number') {
+              index = database.files.push({ fingerprint: this.fingerprint }) - 1;
+            }
+            this.file = database.files[index];
+            this.database = database;
+          }.bind(this));
+        }
+        ViewHistory.prototype = {
+          _writeToStorage: function ViewHistory_writeToStorage() {
+            return new Promise(function (resolve) {
+              var databaseStr = JSON.stringify(this.database);
+              sessionStorage.setItem('pdfjsHistory', databaseStr);
+              resolve();
+            }.bind(this));
+          },
+          _readFromStorage: function ViewHistory_readFromStorage() {
+            return new Promise(function (resolve) {
+              resolve(sessionStorage.getItem('pdfjsHistory'));
+            });
+          },
+          set: function ViewHistory_set(name, val) {
+            if (!this.isInitializedPromiseResolved) {
+              return;
+            }
+            this.file[name] = val;
+            return this._writeToStorage();
+          },
+          setMultiple: function ViewHistory_setMultiple(properties) {
+            if (!this.isInitializedPromiseResolved) {
+              return;
+            }
+            for (var name in properties) {
+              this.file[name] = properties[name];
+            }
+            return this._writeToStorage();
+          },
+          get: function ViewHistory_get(name, defaultValue) {
+            if (!this.isInitializedPromiseResolved) {
+              return defaultValue;
+            }
+            return this.file[name] || defaultValue;
+          }
+        };
+        return ViewHistory;
+      }();
+      exports.ViewHistory = ViewHistory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebDownloadManager = {}, root.pdfjsWebPDFJS);
+    }(this, function (exports, pdfjsLib) {
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebHandTool = {}, root.pdfjsWebGrabToPan, root.pdfjsWebPreferences);
+    }(this, function (exports, grabToPan, preferences) {
+      var GrabToPan = grabToPan.GrabToPan;
+      var Preferences = preferences.Preferences;
+      /**
+       * @typedef {Object} HandToolOptions
+       * @property {HTMLDivElement} container - The document container.
+       * @property {EventBus} eventBus - The application event bus.
+       */
+      /**
+       * @class
+       */
+      var HandTool = function HandToolClosure() {
+        /**
+         * @constructs HandTool
+         * @param {HandToolOptions} options
+         */
+        function HandTool(options) {
+          this.container = options.container;
+          this.eventBus = options.eventBus;
+          this.wasActive = false;
+          this.handTool = new GrabToPan({
+            element: this.container,
+            onActiveChanged: function (isActive) {
+              this.eventBus.dispatch('handtoolchanged', { isActive: isActive });
+            }.bind(this)
+          });
+          this.eventBus.on('togglehandtool', this.toggle.bind(this));
+          this.eventBus.on('localized', function (e) {
+            Preferences.get('enableHandToolOnLoad').then(function resolved(value) {
+              if (value) {
+                this.handTool.activate();
+              }
+            }.bind(this), function rejected(reason) {
+            });
+          }.bind(this));
+          this.eventBus.on('presentationmodechanged', function (e) {
+            if (e.switchInProgress) {
+              return;
+            }
+            if (e.active) {
+              this.enterPresentationMode();
+            } else {
+              this.exitPresentationMode();
+            }
+          }.bind(this));
+        }
+        HandTool.prototype = {
+          /**
+           * @return {boolean}
+           */
+          get isActive() {
+            return !!this.handTool.active;
+          },
+          toggle: function HandTool_toggle() {
+            this.handTool.toggle();
+          },
+          enterPresentationMode: function HandTool_enterPresentationMode() {
+            if (this.isActive) {
+              this.wasActive = true;
+              this.handTool.deactivate();
+            }
+          },
+          exitPresentationMode: function HandTool_exitPresentationMode() {
+            if (this.wasActive) {
+              this.wasActive = false;
+              this.handTool.activate();
+            }
+          }
+        };
+        return HandTool;
+      }();
+      exports.HandTool = HandTool;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFAttachmentViewer = {}, root.pdfjsWebPDFJS);
+    }(this, function (exports, pdfjsLib) {
+      /**
+       * @typedef {Object} PDFAttachmentViewerOptions
+       * @property {HTMLDivElement} container - The viewer element.
+       * @property {EventBus} eventBus - The application event bus.
+       * @property {DownloadManager} downloadManager - The download manager.
+       */
+      /**
+       * @typedef {Object} PDFAttachmentViewerRenderParameters
+       * @property {Array|null} attachments - An array of attachment objects.
+       */
+      /**
+       * @class
+       */
+      var PDFAttachmentViewer = function PDFAttachmentViewerClosure() {
+        /**
+         * @constructs PDFAttachmentViewer
+         * @param {PDFAttachmentViewerOptions} options
+         */
+        function PDFAttachmentViewer(options) {
+          this.attachments = null;
+          this.container = options.container;
+          this.eventBus = options.eventBus;
+          this.downloadManager = options.downloadManager;
+        }
+        PDFAttachmentViewer.prototype = {
+          reset: function PDFAttachmentViewer_reset() {
+            this.attachments = null;
+            var container = this.container;
+            while (container.firstChild) {
+              container.removeChild(container.firstChild);
+            }
+          },
+          /**
+           * @private
+           */
+          _dispatchEvent: function PDFAttachmentViewer_dispatchEvent(attachmentsCount) {
+            this.eventBus.dispatch('attachmentsloaded', {
+              source: this,
+              attachmentsCount: attachmentsCount
+            });
+          },
+          /**
+           * @private
+           */
+          _bindLink: function PDFAttachmentViewer_bindLink(button, content, filename) {
+            button.onclick = function downloadFile(e) {
+              this.downloadManager.downloadData(content, filename, '');
+              return false;
+            }.bind(this);
+          },
+          /**
+           * @param {PDFAttachmentViewerRenderParameters} params
+           */
+          render: function PDFAttachmentViewer_render(params) {
+            var attachments = params && params.attachments || null;
+            var attachmentsCount = 0;
+            if (this.attachments) {
+              this.reset();
+            }
+            this.attachments = attachments;
+            if (!attachments) {
+              this._dispatchEvent(attachmentsCount);
+              return;
+            }
+            var names = Object.keys(attachments).sort(function (a, b) {
+              return a.toLowerCase().localeCompare(b.toLowerCase());
+            });
+            attachmentsCount = names.length;
+            for (var i = 0; i < attachmentsCount; i++) {
+              var item = attachments[names[i]];
+              var filename = pdfjsLib.getFilenameFromUrl(item.filename);
+              var div = document.createElement('div');
+              div.className = 'attachmentsItem';
+              var button = document.createElement('button');
+              this._bindLink(button, item.content, filename);
+              button.textContent = pdfjsLib.removeNullCharacters(filename);
+              div.appendChild(button);
+              this.container.appendChild(div);
+            }
+            this._dispatchEvent(attachmentsCount);
+          }
+        };
+        return PDFAttachmentViewer;
+      }();
+      exports.PDFAttachmentViewer = PDFAttachmentViewer;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFOutlineViewer = {}, root.pdfjsWebPDFJS);
+    }(this, function (exports, pdfjsLib) {
+      var PDFJS = pdfjsLib.PDFJS;
+      var DEFAULT_TITLE = '\u2013';
+      /**
+       * @typedef {Object} PDFOutlineViewerOptions
+       * @property {HTMLDivElement} container - The viewer element.
+       * @property {IPDFLinkService} linkService - The navigation/linking service.
+       * @property {EventBus} eventBus - The application event bus.
+       */
+      /**
+       * @typedef {Object} PDFOutlineViewerRenderParameters
+       * @property {Array|null} outline - An array of outline objects.
+       */
+      /**
+       * @class
+       */
+      var PDFOutlineViewer = function PDFOutlineViewerClosure() {
+        /**
+         * @constructs PDFOutlineViewer
+         * @param {PDFOutlineViewerOptions} options
+         */
+        function PDFOutlineViewer(options) {
+          this.outline = null;
+          this.lastToggleIsShow = true;
+          this.container = options.container;
+          this.linkService = options.linkService;
+          this.eventBus = options.eventBus;
+        }
+        PDFOutlineViewer.prototype = {
+          reset: function PDFOutlineViewer_reset() {
+            this.outline = null;
+            this.lastToggleIsShow = true;
+            var container = this.container;
+            while (container.firstChild) {
+              container.removeChild(container.firstChild);
+            }
+          },
+          /**
+           * @private
+           */
+          _dispatchEvent: function PDFOutlineViewer_dispatchEvent(outlineCount) {
+            this.eventBus.dispatch('outlineloaded', {
+              source: this,
+              outlineCount: outlineCount
+            });
+          },
+          /**
+           * @private
+           */
+          _bindLink: function PDFOutlineViewer_bindLink(element, item) {
+            if (item.url) {
+              pdfjsLib.addLinkAttributes(element, {
+                url: item.url,
+                target: item.newWindow ? PDFJS.LinkTarget.BLANK : undefined
+              });
+              return;
+            }
+            var self = this, destination = item.dest;
+            element.href = self.linkService.getDestinationHash(destination);
+            element.onclick = function () {
+              if (destination) {
+                self.linkService.navigateTo(destination);
+              }
+              return false;
+            };
+          },
+          /**
+           * @private
+           */
+          _setStyles: function PDFOutlineViewer_setStyles(element, item) {
+            var styleStr = '';
+            if (item.bold) {
+              styleStr += 'font-weight: bold;';
+            }
+            if (item.italic) {
+              styleStr += 'font-style: italic;';
+            }
+            if (styleStr) {
+              element.setAttribute('style', styleStr);
+            }
+          },
+          /**
+           * Prepend a button before an outline item which allows the user to toggle
+           * the visibility of all outline items at that level.
+           *
+           * @private
+           */
+          _addToggleButton: function PDFOutlineViewer_addToggleButton(div) {
+            var toggler = document.createElement('div');
+            toggler.className = 'outlineItemToggler';
+            toggler.onclick = function (event) {
+              event.stopPropagation();
+              toggler.classList.toggle('outlineItemsHidden');
+              if (event.shiftKey) {
+                var shouldShowAll = !toggler.classList.contains('outlineItemsHidden');
+                this._toggleOutlineItem(div, shouldShowAll);
+              }
+            }.bind(this);
+            div.insertBefore(toggler, div.firstChild);
+          },
+          /**
+           * Toggle the visibility of the subtree of an outline item.
+           *
+           * @param {Element} root - the root of the outline (sub)tree.
+           * @param {boolean} show - whether to show the outline (sub)tree. If false,
+           *   the outline subtree rooted at |root| will be collapsed.
+           *
+           * @private
+           */
+          _toggleOutlineItem: function PDFOutlineViewer_toggleOutlineItem(root, show) {
+            this.lastToggleIsShow = show;
+            var togglers = root.querySelectorAll('.outlineItemToggler');
+            for (var i = 0, ii = togglers.length; i < ii; ++i) {
+              togglers[i].classList[show ? 'remove' : 'add']('outlineItemsHidden');
+            }
+          },
+          /**
+           * Collapse or expand all subtrees of the outline.
+           */
+          toggleOutlineTree: function PDFOutlineViewer_toggleOutlineTree() {
+            if (!this.outline) {
+              return;
+            }
+            this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
+          },
+          /**
+           * @param {PDFOutlineViewerRenderParameters} params
+           */
+          render: function PDFOutlineViewer_render(params) {
+            var outline = params && params.outline || null;
+            var outlineCount = 0;
+            if (this.outline) {
+              this.reset();
+            }
+            this.outline = outline;
+            if (!outline) {
+              this._dispatchEvent(outlineCount);
+              return;
+            }
+            var fragment = document.createDocumentFragment();
+            var queue = [{
+                parent: fragment,
+                items: this.outline
+              }];
+            var hasAnyNesting = false;
+            while (queue.length > 0) {
+              var levelData = queue.shift();
+              for (var i = 0, len = levelData.items.length; i < len; i++) {
+                var item = levelData.items[i];
+                var div = document.createElement('div');
+                div.className = 'outlineItem';
+                var element = document.createElement('a');
+                this._bindLink(element, item);
+                this._setStyles(element, item);
+                element.textContent = pdfjsLib.removeNullCharacters(item.title) || DEFAULT_TITLE;
+                div.appendChild(element);
+                if (item.items.length > 0) {
+                  hasAnyNesting = true;
+                  this._addToggleButton(div);
+                  var itemsDiv = document.createElement('div');
+                  itemsDiv.className = 'outlineItems';
+                  div.appendChild(itemsDiv);
+                  queue.push({
+                    parent: itemsDiv,
+                    items: item.items
+                  });
+                }
+                levelData.parent.appendChild(div);
+                outlineCount++;
+              }
+            }
+            if (hasAnyNesting) {
+              this.container.classList.add('outlineWithDeepNesting');
+            }
+            this.container.appendChild(fragment);
+            this._dispatchEvent(outlineCount);
+          }
+        };
+        return PDFOutlineViewer;
+      }();
+      exports.PDFOutlineViewer = PDFOutlineViewer;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFSidebar = {}, root.pdfjsWebPDFRenderingQueue);
+    }(this, function (exports, pdfRenderingQueue) {
+      var RenderingStates = pdfRenderingQueue.RenderingStates;
+      var SidebarView = {
+        NONE: 0,
+        THUMBS: 1,
+        OUTLINE: 2,
+        ATTACHMENTS: 3
+      };
+      /**
+       * @typedef {Object} PDFSidebarOptions
+       * @property {PDFViewer} pdfViewer - The document viewer.
+       * @property {PDFThumbnailViewer} pdfThumbnailViewer - The thumbnail viewer.
+       * @property {PDFOutlineViewer} pdfOutlineViewer - The outline viewer.
+       * @property {HTMLDivElement} mainContainer - The main container
+       *   (in which the viewer element is placed).
+       * @property {HTMLDivElement} outerContainer - The outer container
+       *   (encasing both the viewer and sidebar elements).
+       * @property {EventBus} eventBus - The application event bus.
+       * @property {HTMLButtonElement} toggleButton - The button used for
+       *   opening/closing the sidebar.
+       * @property {HTMLButtonElement} thumbnailButton - The button used to show
+       *   the thumbnail view.
+       * @property {HTMLButtonElement} outlineButton - The button used to show
+       *   the outline view.
+       * @property {HTMLButtonElement} attachmentsButton - The button used to show
+       *   the attachments view.
+       * @property {HTMLDivElement} thumbnailView - The container in which
+       *   the thumbnails are placed.
+       * @property {HTMLDivElement} outlineView - The container in which
+       *   the outline is placed.
+       * @property {HTMLDivElement} attachmentsView - The container in which
+       *   the attachments are placed.
+       */
+      /**
+       * @class
+       */
+      var PDFSidebar = function PDFSidebarClosure() {
+        /**
+         * @constructs PDFSidebar
+         * @param {PDFSidebarOptions} options
+         */
+        function PDFSidebar(options) {
+          this.isOpen = false;
+          this.active = SidebarView.THUMBS;
+          this.isInitialViewSet = false;
+          /**
+           * Callback used when the sidebar has been opened/closed, to ensure that
+           * the viewers (PDFViewer/PDFThumbnailViewer) are updated correctly.
+           */
+          this.onToggled = null;
+          this.pdfViewer = options.pdfViewer;
+          this.pdfThumbnailViewer = options.pdfThumbnailViewer;
+          this.pdfOutlineViewer = options.pdfOutlineViewer;
+          this.mainContainer = options.mainContainer;
+          this.outerContainer = options.outerContainer;
+          this.eventBus = options.eventBus;
+          this.toggleButton = options.toggleButton;
+          this.thumbnailButton = options.thumbnailButton;
+          this.outlineButton = options.outlineButton;
+          this.attachmentsButton = options.attachmentsButton;
+          this.thumbnailView = options.thumbnailView;
+          this.outlineView = options.outlineView;
+          this.attachmentsView = options.attachmentsView;
+          this._addEventListeners();
+        }
+        PDFSidebar.prototype = {
+          reset: function PDFSidebar_reset() {
+            this.isInitialViewSet = false;
+            this.close();
+            this.switchView(SidebarView.THUMBS);
+            this.outlineButton.disabled = false;
+            this.attachmentsButton.disabled = false;
+          },
+          /**
+           * @returns {number} One of the values in {SidebarView}.
+           */
+          get visibleView() {
+            return this.isOpen ? this.active : SidebarView.NONE;
+          },
+          get isThumbnailViewVisible() {
+            return this.isOpen && this.active === SidebarView.THUMBS;
+          },
+          get isOutlineViewVisible() {
+            return this.isOpen && this.active === SidebarView.OUTLINE;
+          },
+          get isAttachmentsViewVisible() {
+            return this.isOpen && this.active === SidebarView.ATTACHMENTS;
+          },
+          /**
+           * @param {number} view - The sidebar view that should become visible,
+           *                        must be one of the values in {SidebarView}.
+           */
+          setInitialView: function PDFSidebar_setInitialView(view) {
+            if (this.isInitialViewSet) {
+              return;
+            }
+            this.isInitialViewSet = true;
+            if (this.isOpen && view === SidebarView.NONE) {
+              this._dispatchEvent();
+              // If the user has already manually opened the sidebar,
+              // immediately closing it would be bad UX.
+              return;
+            }
+            var isViewPreserved = view === this.visibleView;
+            this.switchView(view, /* forceOpen */
+            true);
+            if (isViewPreserved) {
+              // Prevent dispatching two back-to-back `sidebarviewchanged` events,
+              // since `this.switchView` dispatched the event if the view changed.
+              this._dispatchEvent();
+            }
+          },
+          /**
+           * @param {number} view - The sidebar view that should be switched to,
+           *                        must be one of the values in {SidebarView}.
+           * @param {boolean} forceOpen - (optional) Ensure that the sidebar is open.
+           *                              The default value is false.
+           */
+          switchView: function PDFSidebar_switchView(view, forceOpen) {
+            if (view === SidebarView.NONE) {
+              this.close();
+              return;
+            }
+            var isViewChanged = view !== this.active;
+            var shouldForceRendering = false;
+            switch (view) {
+            case SidebarView.THUMBS:
+              this.thumbnailButton.classList.add('toggled');
+              this.outlineButton.classList.remove('toggled');
+              this.attachmentsButton.classList.remove('toggled');
+              this.thumbnailView.classList.remove('hidden');
+              this.outlineView.classList.add('hidden');
+              this.attachmentsView.classList.add('hidden');
+              if (this.isOpen && isViewChanged) {
+                this._updateThumbnailViewer();
+                shouldForceRendering = true;
+              }
+              break;
+            case SidebarView.OUTLINE:
+              if (this.outlineButton.disabled) {
+                return;
+              }
+              this.thumbnailButton.classList.remove('toggled');
+              this.outlineButton.classList.add('toggled');
+              this.attachmentsButton.classList.remove('toggled');
+              this.thumbnailView.classList.add('hidden');
+              this.outlineView.classList.remove('hidden');
+              this.attachmentsView.classList.add('hidden');
+              break;
+            case SidebarView.ATTACHMENTS:
+              if (this.attachmentsButton.disabled) {
+                return;
+              }
+              this.thumbnailButton.classList.remove('toggled');
+              this.outlineButton.classList.remove('toggled');
+              this.attachmentsButton.classList.add('toggled');
+              this.thumbnailView.classList.add('hidden');
+              this.outlineView.classList.add('hidden');
+              this.attachmentsView.classList.remove('hidden');
+              break;
+            default:
+              console.error('PDFSidebar_switchView: "' + view + '" is an unsupported value.');
+              return;
+            }
+            // Update the active view *after* it has been validated above,
+            // in order to prevent setting it to an invalid state.
+            this.active = view | 0;
+            if (forceOpen && !this.isOpen) {
+              this.open();
+              // NOTE: `this.open` will trigger rendering, and dispatch the event.
+              return;
+            }
+            if (shouldForceRendering) {
+              this._forceRendering();
+            }
+            if (isViewChanged) {
+              this._dispatchEvent();
+            }
+          },
+          open: function PDFSidebar_open() {
+            if (this.isOpen) {
+              return;
+            }
+            this.isOpen = true;
+            this.toggleButton.classList.add('toggled');
+            this.outerContainer.classList.add('sidebarMoving');
+            this.outerContainer.classList.add('sidebarOpen');
+            if (this.active === SidebarView.THUMBS) {
+              this._updateThumbnailViewer();
+            }
+            this._forceRendering();
+            this._dispatchEvent();
+          },
+          close: function PDFSidebar_close() {
+            if (!this.isOpen) {
+              return;
+            }
+            this.isOpen = false;
+            this.toggleButton.classList.remove('toggled');
+            this.outerContainer.classList.add('sidebarMoving');
+            this.outerContainer.classList.remove('sidebarOpen');
+            this._forceRendering();
+            this._dispatchEvent();
+          },
+          toggle: function PDFSidebar_toggle() {
+            if (this.isOpen) {
+              this.close();
+            } else {
+              this.open();
+            }
+          },
+          /**
+           * @private
+           */
+          _dispatchEvent: function PDFSidebar_dispatchEvent() {
+            this.eventBus.dispatch('sidebarviewchanged', {
+              source: this,
+              view: this.visibleView
+            });
+          },
+          /**
+           * @private
+           */
+          _forceRendering: function PDFSidebar_forceRendering() {
+            if (this.onToggled) {
+              this.onToggled();
+            } else {
+              // Fallback
+              this.pdfViewer.forceRendering();
+              this.pdfThumbnailViewer.forceRendering();
+            }
+          },
+          /**
+           * @private
+           */
+          _updateThumbnailViewer: function PDFSidebar_updateThumbnailViewer() {
+            var pdfViewer = this.pdfViewer;
+            var thumbnailViewer = this.pdfThumbnailViewer;
+            // Use the rendered pages to set the corresponding thumbnail images.
+            var pagesCount = pdfViewer.pagesCount;
+            for (var pageIndex = 0; pageIndex < pagesCount; pageIndex++) {
+              var pageView = pdfViewer.getPageView(pageIndex);
+              if (pageView && pageView.renderingState === RenderingStates.FINISHED) {
+                var thumbnailView = thumbnailViewer.getThumbnail(pageIndex);
+                thumbnailView.setImage(pageView);
+              }
+            }
+            thumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
+          },
+          /**
+           * @private
+           */
+          _addEventListeners: function PDFSidebar_addEventListeners() {
+            var self = this;
+            self.mainContainer.addEventListener('transitionend', function (evt) {
+              if (evt.target === /* mainContainer */
+                this) {
+                self.outerContainer.classList.remove('sidebarMoving');
+              }
+            });
+            // Buttons for switching views.
+            self.thumbnailButton.addEventListener('click', function () {
+              self.switchView(SidebarView.THUMBS);
+            });
+            self.outlineButton.addEventListener('click', function () {
+              self.switchView(SidebarView.OUTLINE);
+            });
+            self.outlineButton.addEventListener('dblclick', function () {
+              self.pdfOutlineViewer.toggleOutlineTree();
+            });
+            self.attachmentsButton.addEventListener('click', function () {
+              self.switchView(SidebarView.ATTACHMENTS);
+            });
+            // Disable/enable views.
+            self.eventBus.on('outlineloaded', function (e) {
+              var outlineCount = e.outlineCount;
+              self.outlineButton.disabled = !outlineCount;
+              if (!outlineCount && self.active === SidebarView.OUTLINE) {
+                self.switchView(SidebarView.THUMBS);
+              }
+            });
+            self.eventBus.on('attachmentsloaded', function (e) {
+              var attachmentsCount = e.attachmentsCount;
+              self.attachmentsButton.disabled = !attachmentsCount;
+              if (!attachmentsCount && self.active === SidebarView.ATTACHMENTS) {
+                self.switchView(SidebarView.THUMBS);
+              }
+            });
+            // Update the thumbnailViewer, if visible, when exiting presentation mode.
+            self.eventBus.on('presentationmodechanged', function (e) {
+              if (!e.active && !e.switchInProgress && self.isThumbnailViewVisible) {
+                self._updateThumbnailViewer();
+              }
+            });
+          }
+        };
+        return PDFSidebar;
+      }();
+      exports.SidebarView = SidebarView;
+      exports.PDFSidebar = PDFSidebar;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebUIUtils = {}, root.pdfjsWebPDFJS);
+    }(this, function (exports, pdfjsLib) {
+      var CSS_UNITS = 96.0 / 72.0;
+      var DEFAULT_SCALE_VALUE = 'auto';
+      var DEFAULT_SCALE = 1.0;
+      var UNKNOWN_SCALE = 0;
+      var MAX_AUTO_SCALE = 1.25;
+      var SCROLLBAR_PADDING = 40;
+      var VERTICAL_PADDING = 5;
+      var mozL10n = document.mozL10n || document.webL10n;
+      var PDFJS = pdfjsLib.PDFJS;
+      /**
+       * Disables fullscreen support, and by extension Presentation Mode,
+       * in browsers which support the fullscreen API.
+       * @var {boolean}
+       */
+      PDFJS.disableFullscreen = PDFJS.disableFullscreen === undefined ? false : PDFJS.disableFullscreen;
+      /**
+       * Enables CSS only zooming.
+       * @var {boolean}
+       */
+      PDFJS.useOnlyCssZoom = PDFJS.useOnlyCssZoom === undefined ? false : PDFJS.useOnlyCssZoom;
+      /**
+       * The maximum supported canvas size in total pixels e.g. width * height.
+       * The default value is 4096 * 4096. Use -1 for no limit.
+       * @var {number}
+       */
+      PDFJS.maxCanvasPixels = PDFJS.maxCanvasPixels === undefined ? 16777216 : PDFJS.maxCanvasPixels;
+      /**
+       * Disables saving of the last position of the viewed PDF.
+       * @var {boolean}
+       */
+      PDFJS.disableHistory = PDFJS.disableHistory === undefined ? false : PDFJS.disableHistory;
+      /**
+       * Disables creation of the text layer that used for text selection and search.
+       * @var {boolean}
+       */
+      PDFJS.disableTextLayer = PDFJS.disableTextLayer === undefined ? false : PDFJS.disableTextLayer;
+      /**
+       * Disables maintaining the current position in the document when zooming.
+       */
+      PDFJS.ignoreCurrentPositionOnZoom = PDFJS.ignoreCurrentPositionOnZoom === undefined ? false : PDFJS.ignoreCurrentPositionOnZoom;
+      /**
+       * Returns scale factor for the canvas. It makes sense for the HiDPI displays.
+       * @return {Object} The object with horizontal (sx) and vertical (sy)
+                          scales. The scaled property is set to false if scaling is
+                          not required, true otherwise.
+       */
+      function getOutputScale(ctx) {
+        var devicePixelRatio = window.devicePixelRatio || 1;
+        var backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.msBackingStorePixelRatio || ctx.oBackingStorePixelRatio || ctx.backingStorePixelRatio || 1;
+        var pixelRatio = devicePixelRatio / backingStoreRatio;
+        return {
+          sx: pixelRatio,
+          sy: pixelRatio,
+          scaled: pixelRatio !== 1
+        };
+      }
+      /**
+       * Scrolls specified element into view of its parent.
+       * @param {Object} element - The element to be visible.
+       * @param {Object} spot - An object with optional top and left properties,
+       *   specifying the offset from the top left edge.
+       * @param {boolean} skipOverflowHiddenElements - Ignore elements that have
+       *   the CSS rule `overflow: hidden;` set. The default is false.
+       */
+      function scrollIntoView(element, spot, skipOverflowHiddenElements) {
+        // Assuming offsetParent is available (it's not available when viewer is in
+        // hidden iframe or object). We have to scroll: if the offsetParent is not set
+        // producing the error. See also animationStartedClosure.
+        var parent = element.offsetParent;
+        if (!parent) {
+          console.error('offsetParent is not set -- cannot scroll');
+          return;
+        }
+        var checkOverflow = skipOverflowHiddenElements || false;
+        var offsetY = element.offsetTop + element.clientTop;
+        var offsetX = element.offsetLeft + element.clientLeft;
+        while (parent.clientHeight === parent.scrollHeight || checkOverflow && getComputedStyle(parent).overflow === 'hidden') {
+          if (parent.dataset._scaleY) {
+            offsetY /= parent.dataset._scaleY;
+            offsetX /= parent.dataset._scaleX;
+          }
+          offsetY += parent.offsetTop;
+          offsetX += parent.offsetLeft;
+          parent = parent.offsetParent;
+          if (!parent) {
+            return;
+          }
+        }
+        // no need to scroll
+        if (spot) {
+          if (spot.top !== undefined) {
+            offsetY += spot.top;
+          }
+          if (spot.left !== undefined) {
+            offsetX += spot.left;
+            parent.scrollLeft = offsetX;
+          }
+        }
+        parent.scrollTop = offsetY;
+      }
+      /**
+       * Helper function to start monitoring the scroll event and converting them into
+       * PDF.js friendly one: with scroll debounce and scroll direction.
+       */
+      function watchScroll(viewAreaElement, callback) {
+        var debounceScroll = function debounceScroll(evt) {
+          if (rAF) {
+            return;
+          }
+          // schedule an invocation of scroll for next animation frame.
+          rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
+            rAF = null;
+            var currentY = viewAreaElement.scrollTop;
+            var lastY = state.lastY;
+            if (currentY !== lastY) {
+              state.down = currentY > lastY;
+            }
+            state.lastY = currentY;
+            callback(state);
+          });
+        };
+        var state = {
+          down: true,
+          lastY: viewAreaElement.scrollTop,
+          _eventHandler: debounceScroll
+        };
+        var rAF = null;
+        viewAreaElement.addEventListener('scroll', debounceScroll, true);
+        return state;
+      }
+      /**
+       * Helper function to parse query string (e.g. ?param1=value&parm2=...).
+       */
+      function parseQueryString(query) {
+        var parts = query.split('&');
+        var params = {};
+        for (var i = 0, ii = parts.length; i < ii; ++i) {
+          var param = parts[i].split('=');
+          var key = param[0].toLowerCase();
+          var value = param.length > 1 ? param[1] : null;
+          params[decodeURIComponent(key)] = decodeURIComponent(value);
+        }
+        return params;
+      }
+      /**
+       * Use binary search to find the index of the first item in a given array which
+       * passes a given condition. The items are expected to be sorted in the sense
+       * that if the condition is true for one item in the array, then it is also true
+       * for all following items.
+       *
+       * @returns {Number} Index of the first array element to pass the test,
+       *                   or |items.length| if no such element exists.
+       */
+      function binarySearchFirstItem(items, condition) {
+        var minIndex = 0;
+        var maxIndex = items.length - 1;
+        if (items.length === 0 || !condition(items[maxIndex])) {
+          return items.length;
+        }
+        if (condition(items[minIndex])) {
+          return minIndex;
+        }
+        while (minIndex < maxIndex) {
+          var currentIndex = minIndex + maxIndex >> 1;
+          var currentItem = items[currentIndex];
+          if (condition(currentItem)) {
+            maxIndex = currentIndex;
+          } else {
+            minIndex = currentIndex + 1;
+          }
+        }
+        return minIndex;
+      }
+      /* === maxIndex */
+      /**
+       *  Approximates float number as a fraction using Farey sequence (max order
+       *  of 8).
+       *  @param {number} x - Positive float number.
+       *  @returns {Array} Estimated fraction: the first array item is a numerator,
+       *                   the second one is a denominator.
+       */
+      function approximateFraction(x) {
+        // Fast paths for int numbers or their inversions.
+        if (Math.floor(x) === x) {
+          return [
+            x,
+            1
+          ];
+        }
+        var xinv = 1 / x;
+        var limit = 8;
+        if (xinv > limit) {
+          return [
+            1,
+            limit
+          ];
+        } else if (Math.floor(xinv) === xinv) {
+          return [
+            1,
+            xinv
+          ];
+        }
+        var x_ = x > 1 ? xinv : x;
+        // a/b and c/d are neighbours in Farey sequence.
+        var a = 0, b = 1, c = 1, d = 1;
+        // Limiting search to order 8.
+        while (true) {
+          // Generating next term in sequence (order of q).
+          var p = a + c, q = b + d;
+          if (q > limit) {
+            break;
+          }
+          if (x_ <= p / q) {
+            c = p;
+            d = q;
+          } else {
+            a = p;
+            b = q;
+          }
+        }
+        // Select closest of the neighbours to x.
+        if (x_ - a / b < c / d - x_) {
+          return x_ === x ? [
+            a,
+            b
+          ] : [
+            b,
+            a
+          ];
+        } else {
+          return x_ === x ? [
+            c,
+            d
+          ] : [
+            d,
+            c
+          ];
+        }
+      }
+      function roundToDivide(x, div) {
+        var r = x % div;
+        return r === 0 ? x : Math.round(x - r + div);
+      }
+      /**
+       * Generic helper to find out what elements are visible within a scroll pane.
+       */
+      function getVisibleElements(scrollEl, views, sortByVisibility) {
+        var top = scrollEl.scrollTop, bottom = top + scrollEl.clientHeight;
+        var left = scrollEl.scrollLeft, right = left + scrollEl.clientWidth;
+        function isElementBottomBelowViewTop(view) {
+          var element = view.div;
+          var elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
+          return elementBottom > top;
+        }
+        var visible = [], view, element;
+        var currentHeight, viewHeight, hiddenHeight, percentHeight;
+        var currentWidth, viewWidth;
+        var firstVisibleElementInd = views.length === 0 ? 0 : binarySearchFirstItem(views, isElementBottomBelowViewTop);
+        for (var i = firstVisibleElementInd, ii = views.length; i < ii; i++) {
+          view = views[i];
+          element = view.div;
+          currentHeight = element.offsetTop + element.clientTop;
+          viewHeight = element.clientHeight;
+          if (currentHeight > bottom) {
+            break;
+          }
+          currentWidth = element.offsetLeft + element.clientLeft;
+          viewWidth = element.clientWidth;
+          if (currentWidth + viewWidth < left || currentWidth > right) {
+            continue;
+          }
+          hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, currentHeight + viewHeight - bottom);
+          percentHeight = (viewHeight - hiddenHeight) * 100 / viewHeight | 0;
+          visible.push({
+            id: view.id,
+            x: currentWidth,
+            y: currentHeight,
+            view: view,
+            percent: percentHeight
+          });
+        }
+        var first = visible[0];
+        var last = visible[visible.length - 1];
+        if (sortByVisibility) {
+          visible.sort(function (a, b) {
+            var pc = a.percent - b.percent;
+            if (Math.abs(pc) > 0.001) {
+              return -pc;
+            }
+            return a.id - b.id;
+          });
+        }
+        // ensure stability
+        return {
+          first: first,
+          last: last,
+          views: visible
+        };
+      }
+      /**
+       * Event handler to suppress context menu.
+       */
+      function noContextMenuHandler(e) {
+        e.preventDefault();
+      }
+      /**
+       * Returns the filename or guessed filename from the url (see issue 3455).
+       * url {String} The original PDF location.
+       * @return {String} Guessed PDF file name.
+       */
+      function getPDFFileNameFromURL(url) {
+        var reURI = /^(?:([^:]+:)?\/\/[^\/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
+        //            SCHEME      HOST         1.PATH  2.QUERY   3.REF
+        // Pattern to get last matching NAME.pdf
+        var reFilename = /[^\/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
+        var splitURI = reURI.exec(url);
+        var suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
+        if (suggestedFilename) {
+          suggestedFilename = suggestedFilename[0];
+          if (suggestedFilename.indexOf('%') !== -1) {
+            // URL-encoded %2Fpath%2Fto%2Ffile.pdf should be file.pdf
+            try {
+              suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
+            } catch (e) {
+            }
+          }
+        }
+        return suggestedFilename || 'document.pdf';
+      }
+      function normalizeWheelEventDelta(evt) {
+        var delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);
+        var angle = Math.atan2(evt.deltaY, evt.deltaX);
+        if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
+          // All that is left-up oriented has to change the sign.
+          delta = -delta;
+        }
+        var MOUSE_DOM_DELTA_PIXEL_MODE = 0;
+        var MOUSE_DOM_DELTA_LINE_MODE = 1;
+        var MOUSE_PIXELS_PER_LINE = 30;
+        var MOUSE_LINES_PER_PAGE = 30;
+        // Converts delta to per-page units
+        if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
+          delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
+        } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
+          delta /= MOUSE_LINES_PER_PAGE;
+        }
+        return delta;
+      }
+      /**
+       * Simple event bus for an application. Listeners are attached using the
+       * `on` and `off` methods. To raise an event, the `dispatch` method shall be
+       * used.
+       */
+      var EventBus = function EventBusClosure() {
+        function EventBus() {
+          this._listeners = Object.create(null);
+        }
+        EventBus.prototype = {
+          on: function EventBus_on(eventName, listener) {
+            var eventListeners = this._listeners[eventName];
+            if (!eventListeners) {
+              eventListeners = [];
+              this._listeners[eventName] = eventListeners;
+            }
+            eventListeners.push(listener);
+          },
+          off: function EventBus_on(eventName, listener) {
+            var eventListeners = this._listeners[eventName];
+            var i;
+            if (!eventListeners || (i = eventListeners.indexOf(listener)) < 0) {
+              return;
+            }
+            eventListeners.splice(i, 1);
+          },
+          dispatch: function EventBus_dispath(eventName) {
+            var eventListeners = this._listeners[eventName];
+            if (!eventListeners || eventListeners.length === 0) {
+              return;
+            }
+            // Passing all arguments after the eventName to the listeners.
+            var args = Array.prototype.slice.call(arguments, 1);
+            // Making copy of the listeners array in case if it will be modified
+            // during dispatch.
+            eventListeners.slice(0).forEach(function (listener) {
+              listener.apply(null, args);
+            });
+          }
+        };
+        return EventBus;
+      }();
+      var ProgressBar = function ProgressBarClosure() {
+        function clamp(v, min, max) {
+          return Math.min(Math.max(v, min), max);
+        }
+        function ProgressBar(id, opts) {
+          this.visible = true;
+          // Fetch the sub-elements for later.
+          this.div = document.querySelector(id + ' .progress');
+          // Get the loading bar element, so it can be resized to fit the viewer.
+          this.bar = this.div.parentNode;
+          // Get options, with sensible defaults.
+          this.height = opts.height || 100;
+          this.width = opts.width || 100;
+          this.units = opts.units || '%';
+          // Initialize heights.
+          this.div.style.height = this.height + this.units;
+          this.percent = 0;
+        }
+        ProgressBar.prototype = {
+          updateBar: function ProgressBar_updateBar() {
+            if (this._indeterminate) {
+              this.div.classList.add('indeterminate');
+              this.div.style.width = this.width + this.units;
+              return;
+            }
+            this.div.classList.remove('indeterminate');
+            var progressSize = this.width * this._percent / 100;
+            this.div.style.width = progressSize + this.units;
+          },
+          get percent() {
+            return this._percent;
+          },
+          set percent(val) {
+            this._indeterminate = isNaN(val);
+            this._percent = clamp(val, 0, 100);
+            this.updateBar();
+          },
+          setWidth: function ProgressBar_setWidth(viewer) {
+            if (viewer) {
+              var container = viewer.parentNode;
+              var scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
+              if (scrollbarWidth > 0) {
+                this.bar.setAttribute('style', 'width: calc(100% - ' + scrollbarWidth + 'px);');
+              }
+            }
+          },
+          hide: function ProgressBar_hide() {
+            if (!this.visible) {
+              return;
+            }
+            this.visible = false;
+            this.bar.classList.add('hidden');
+            document.body.classList.remove('loadingInProgress');
+          },
+          show: function ProgressBar_show() {
+            if (this.visible) {
+              return;
+            }
+            this.visible = true;
+            document.body.classList.add('loadingInProgress');
+            this.bar.classList.remove('hidden');
+          }
+        };
+        return ProgressBar;
+      }();
+      exports.CSS_UNITS = CSS_UNITS;
+      exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE;
+      exports.DEFAULT_SCALE = DEFAULT_SCALE;
+      exports.UNKNOWN_SCALE = UNKNOWN_SCALE;
+      exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE;
+      exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING;
+      exports.VERTICAL_PADDING = VERTICAL_PADDING;
+      exports.mozL10n = mozL10n;
+      exports.EventBus = EventBus;
+      exports.ProgressBar = ProgressBar;
+      exports.getPDFFileNameFromURL = getPDFFileNameFromURL;
+      exports.noContextMenuHandler = noContextMenuHandler;
+      exports.parseQueryString = parseQueryString;
+      exports.getVisibleElements = getVisibleElements;
+      exports.roundToDivide = roundToDivide;
+      exports.approximateFraction = approximateFraction;
+      exports.getOutputScale = getOutputScale;
+      exports.scrollIntoView = scrollIntoView;
+      exports.watchScroll = watchScroll;
+      exports.binarySearchFirstItem = binarySearchFirstItem;
+      exports.normalizeWheelEventDelta = normalizeWheelEventDelta;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebDOMEvents = {}, root.pdfjsWebUIUtils);
+    }(this, function (exports, uiUtils) {
+      var EventBus = uiUtils.EventBus;
+      // Attaching to the application event bus to dispatch events to the DOM for
+      // backwards viewer API compatibility.
+      function attachDOMEventsToEventBus(eventBus) {
+        eventBus.on('documentload', function () {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('documentload', true, true, {});
+          window.dispatchEvent(event);
+        });
+        eventBus.on('pagerendered', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('pagerendered', true, true, {
+            pageNumber: e.pageNumber,
+            cssTransform: e.cssTransform
+          });
+          e.source.div.dispatchEvent(event);
+        });
+        eventBus.on('textlayerrendered', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('textlayerrendered', true, true, { pageNumber: e.pageNumber });
+          e.source.textLayerDiv.dispatchEvent(event);
+        });
+        eventBus.on('pagechange', function (e) {
+          var event = document.createEvent('UIEvents');
+          event.initUIEvent('pagechange', true, true, window, 0);
+          event.pageNumber = e.pageNumber;
+          e.source.container.dispatchEvent(event);
+        });
+        eventBus.on('pagesinit', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('pagesinit', true, true, null);
+          e.source.container.dispatchEvent(event);
+        });
+        eventBus.on('pagesloaded', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('pagesloaded', true, true, { pagesCount: e.pagesCount });
+          e.source.container.dispatchEvent(event);
+        });
+        eventBus.on('scalechange', function (e) {
+          var event = document.createEvent('UIEvents');
+          event.initUIEvent('scalechange', true, true, window, 0);
+          event.scale = e.scale;
+          event.presetValue = e.presetValue;
+          e.source.container.dispatchEvent(event);
+        });
+        eventBus.on('updateviewarea', function (e) {
+          var event = document.createEvent('UIEvents');
+          event.initUIEvent('updateviewarea', true, true, window, 0);
+          event.location = e.location;
+          e.source.container.dispatchEvent(event);
+        });
+        eventBus.on('find', function (e) {
+          if (e.source === window) {
+            return;
+          }
+          // event comes from FirefoxCom, no need to replicate
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('find' + e.type, true, true, {
+            query: e.query,
+            phraseSearch: e.phraseSearch,
+            caseSensitive: e.caseSensitive,
+            highlightAll: e.highlightAll,
+            findPrevious: e.findPrevious
+          });
+          window.dispatchEvent(event);
+        });
+        eventBus.on('attachmentsloaded', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('attachmentsloaded', true, true, { attachmentsCount: e.attachmentsCount });
+          e.source.container.dispatchEvent(event);
+        });
+        eventBus.on('sidebarviewchanged', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('sidebarviewchanged', true, true, { view: e.view });
+          e.source.outerContainer.dispatchEvent(event);
+        });
+        eventBus.on('pagemode', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('pagemode', true, true, { mode: e.mode });
+          e.source.pdfViewer.container.dispatchEvent(event);
+        });
+        eventBus.on('namedaction', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('namedaction', true, true, { action: e.action });
+          e.source.pdfViewer.container.dispatchEvent(event);
+        });
+        eventBus.on('presentationmodechanged', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('presentationmodechanged', true, true, {
+            active: e.active,
+            switchInProgress: e.switchInProgress
+          });
+          window.dispatchEvent(event);
+        });
+        eventBus.on('outlineloaded', function (e) {
+          var event = document.createEvent('CustomEvent');
+          event.initCustomEvent('outlineloaded', true, true, { outlineCount: e.outlineCount });
+          e.source.container.dispatchEvent(event);
+        });
+      }
+      var globalEventBus = null;
+      function getGlobalEventBus() {
+        if (globalEventBus) {
+          return globalEventBus;
+        }
+        globalEventBus = new EventBus();
+        attachDOMEventsToEventBus(globalEventBus);
+        return globalEventBus;
+      }
+      exports.attachDOMEventsToEventBus = attachDOMEventsToEventBus;
+      exports.getGlobalEventBus = getGlobalEventBus;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPasswordPrompt = {}, root.pdfjsWebUIUtils, root.pdfjsWebOverlayManager, root.pdfjsWebPDFJS);
+    }(this, function (exports, uiUtils, overlayManager, pdfjsLib) {
+      var mozL10n = uiUtils.mozL10n;
+      var OverlayManager = overlayManager.OverlayManager;
+      /**
+       * @typedef {Object} PasswordPromptOptions
+       * @property {string} overlayName - Name of the overlay for the overlay manager.
+       * @property {HTMLDivElement} container - Div container for the overlay.
+       * @property {HTMLParagraphElement} label - Label containing instructions for
+       *                                          entering the password.
+       * @property {HTMLInputElement} input - Input field for entering the password.
+       * @property {HTMLButtonElement} submitButton - Button for submitting the
+       *                                              password.
+       * @property {HTMLButtonElement} cancelButton - Button for cancelling password
+       *                                              entry.
+       */
+      /**
+       * @class
+       */
+      var PasswordPrompt = function PasswordPromptClosure() {
+        /**
+         * @constructs PasswordPrompt
+         * @param {PasswordPromptOptions} options
+         */
+        function PasswordPrompt(options) {
+          this.overlayName = options.overlayName;
+          this.container = options.container;
+          this.label = options.label;
+          this.input = options.input;
+          this.submitButton = options.submitButton;
+          this.cancelButton = options.cancelButton;
+          this.updateCallback = null;
+          this.reason = null;
+          // Attach the event listeners.
+          this.submitButton.addEventListener('click', this.verify.bind(this));
+          this.cancelButton.addEventListener('click', this.close.bind(this));
+          this.input.addEventListener('keydown', function (e) {
+            if (e.keyCode === 13) {
+              // Enter key
+              this.verify();
+            }
+          }.bind(this));
+          OverlayManager.register(this.overlayName, this.container, this.close.bind(this), true);
+        }
+        PasswordPrompt.prototype = {
+          open: function PasswordPrompt_open() {
+            OverlayManager.open(this.overlayName).then(function () {
+              this.input.type = 'password';
+              this.input.focus();
+              var promptString = mozL10n.get('password_label', null, 'Enter the password to open this PDF file.');
+              if (this.reason === pdfjsLib.PasswordResponses.INCORRECT_PASSWORD) {
+                promptString = mozL10n.get('password_invalid', null, 'Invalid password. Please try again.');
+              }
+              this.label.textContent = promptString;
+            }.bind(this));
+          },
+          close: function PasswordPrompt_close() {
+            OverlayManager.close(this.overlayName).then(function () {
+              this.input.value = '';
+              this.input.type = '';
+            }.bind(this));
+          },
+          verify: function PasswordPrompt_verify() {
+            var password = this.input.value;
+            if (password && password.length > 0) {
+              this.close();
+              return this.updateCallback(password);
+            }
+          },
+          setUpdateCallback: function PasswordPrompt_setUpdateCallback(updateCallback, reason) {
+            this.updateCallback = updateCallback;
+            this.reason = reason;
+          }
+        };
+        return PasswordPrompt;
+      }();
+      exports.PasswordPrompt = PasswordPrompt;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFDocumentProperties = {}, root.pdfjsWebUIUtils, root.pdfjsWebOverlayManager);
+    }(this, function (exports, uiUtils, overlayManager) {
+      var getPDFFileNameFromURL = uiUtils.getPDFFileNameFromURL;
+      var mozL10n = uiUtils.mozL10n;
+      var OverlayManager = overlayManager.OverlayManager;
+      /**
+       * @typedef {Object} PDFDocumentPropertiesOptions
+       * @property {string} overlayName - Name/identifier for the overlay.
+       * @property {Object} fields - Names and elements of the overlay's fields.
+       * @property {HTMLButtonElement} closeButton - Button for closing the overlay.
+       */
+      /**
+       * @class
+       */
+      var PDFDocumentProperties = function PDFDocumentPropertiesClosure() {
+        /**
+         * @constructs PDFDocumentProperties
+         * @param {PDFDocumentPropertiesOptions} options
+         */
+        function PDFDocumentProperties(options) {
+          this.fields = options.fields;
+          this.overlayName = options.overlayName;
+          this.container = options.container;
+          this.rawFileSize = 0;
+          this.url = null;
+          this.pdfDocument = null;
+          // Bind the event listener for the Close button.
+          if (options.closeButton) {
+            options.closeButton.addEventListener('click', this.close.bind(this));
+          }
+          this.dataAvailablePromise = new Promise(function (resolve) {
+            this.resolveDataAvailable = resolve;
+          }.bind(this));
+          OverlayManager.register(this.overlayName, this.container, this.close.bind(this));
+        }
+        PDFDocumentProperties.prototype = {
+          /**
+           * Open the document properties overlay.
+           */
+          open: function PDFDocumentProperties_open() {
+            Promise.all([
+              OverlayManager.open(this.overlayName),
+              this.dataAvailablePromise
+            ]).then(function () {
+              this._getProperties();
+            }.bind(this));
+          },
+          /**
+           * Close the document properties overlay.
+           */
+          close: function PDFDocumentProperties_close() {
+            OverlayManager.close(this.overlayName);
+          },
+          /**
+           * Set the file size of the PDF document. This method is used to
+           * update the file size in the document properties overlay once it
+           * is known so we do not have to wait until the entire file is loaded.
+           *
+           * @param {number} fileSize - The file size of the PDF document.
+           */
+          setFileSize: function PDFDocumentProperties_setFileSize(fileSize) {
+            if (fileSize > 0) {
+              this.rawFileSize = fileSize;
+            }
+          },
+          /**
+           * Set a reference to the PDF document and the URL in order
+           * to populate the overlay fields with the document properties.
+           * Note that the overlay will contain no information if this method
+           * is not called.
+           *
+           * @param {Object} pdfDocument - A reference to the PDF document.
+           * @param {string} url - The URL of the document.
+           */
+          setDocumentAndUrl: function PDFDocumentProperties_setDocumentAndUrl(pdfDocument, url) {
+            this.pdfDocument = pdfDocument;
+            this.url = url;
+            this.resolveDataAvailable();
+          },
+          /**
+           * @private
+           */
+          _getProperties: function PDFDocumentProperties_getProperties() {
+            if (!OverlayManager.active) {
+              // If the dialog was closed before dataAvailablePromise was resolved,
+              // don't bother updating the properties.
+              return;
+            }
+            // Get the file size (if it hasn't already been set).
+            this.pdfDocument.getDownloadInfo().then(function (data) {
+              if (data.length === this.rawFileSize) {
+                return;
+              }
+              this.setFileSize(data.length);
+              this._updateUI(this.fields['fileSize'], this._parseFileSize());
+            }.bind(this));
+            // Get the document properties.
+            this.pdfDocument.getMetadata().then(function (data) {
+              var content = {
+                'fileName': getPDFFileNameFromURL(this.url),
+                'fileSize': this._parseFileSize(),
+                'title': data.info.Title,
+                'author': data.info.Author,
+                'subject': data.info.Subject,
+                'keywords': data.info.Keywords,
+                'creationDate': this._parseDate(data.info.CreationDate),
+                'modificationDate': this._parseDate(data.info.ModDate),
+                'creator': data.info.Creator,
+                'producer': data.info.Producer,
+                'version': data.info.PDFFormatVersion,
+                'pageCount': this.pdfDocument.numPages
+              };
+              // Show the properties in the dialog.
+              for (var identifier in content) {
+                this._updateUI(this.fields[identifier], content[identifier]);
+              }
+            }.bind(this));
+          },
+          /**
+           * @private
+           */
+          _updateUI: function PDFDocumentProperties_updateUI(field, content) {
+            if (field && content !== undefined && content !== '') {
+              field.textContent = content;
+            }
+          },
+          /**
+           * @private
+           */
+          _parseFileSize: function PDFDocumentProperties_parseFileSize() {
+            var fileSize = this.rawFileSize, kb = fileSize / 1024;
+            if (!kb) {
+              return;
+            } else if (kb < 1024) {
+              return mozL10n.get('document_properties_kb', {
+                size_kb: (+kb.toPrecision(3)).toLocaleString(),
+                size_b: fileSize.toLocaleString()
+              }, '{{size_kb}} KB ({{size_b}} bytes)');
+            } else {
+              return mozL10n.get('document_properties_mb', {
+                size_mb: (+(kb / 1024).toPrecision(3)).toLocaleString(),
+                size_b: fileSize.toLocaleString()
+              }, '{{size_mb}} MB ({{size_b}} bytes)');
+            }
+          },
+          /**
+           * @private
+           */
+          _parseDate: function PDFDocumentProperties_parseDate(inputDate) {
+            // This is implemented according to the PDF specification, but note that
+            // Adobe Reader doesn't handle changing the date to universal time
+            // and doesn't use the user's time zone (they're effectively ignoring
+            // the HH' and mm' parts of the date string).
+            var dateToParse = inputDate;
+            if (dateToParse === undefined) {
+              return '';
+            }
+            // Remove the D: prefix if it is available.
+            if (dateToParse.substring(0, 2) === 'D:') {
+              dateToParse = dateToParse.substring(2);
+            }
+            // Get all elements from the PDF date string.
+            // JavaScript's Date object expects the month to be between
+            // 0 and 11 instead of 1 and 12, so we're correcting for this.
+            var year = parseInt(dateToParse.substring(0, 4), 10);
+            var month = parseInt(dateToParse.substring(4, 6), 10) - 1;
+            var day = parseInt(dateToParse.substring(6, 8), 10);
+            var hours = parseInt(dateToParse.substring(8, 10), 10);
+            var minutes = parseInt(dateToParse.substring(10, 12), 10);
+            var seconds = parseInt(dateToParse.substring(12, 14), 10);
+            var utRel = dateToParse.substring(14, 15);
+            var offsetHours = parseInt(dateToParse.substring(15, 17), 10);
+            var offsetMinutes = parseInt(dateToParse.substring(18, 20), 10);
+            // As per spec, utRel = 'Z' means equal to universal time.
+            // The other cases ('-' and '+') have to be handled here.
+            if (utRel === '-') {
+              hours += offsetHours;
+              minutes += offsetMinutes;
+            } else if (utRel === '+') {
+              hours -= offsetHours;
+              minutes -= offsetMinutes;
+            }
+            // Return the new date format from the user's locale.
+            var date = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+            var dateString = date.toLocaleDateString();
+            var timeString = date.toLocaleTimeString();
+            return mozL10n.get('document_properties_date_string', {
+              date: dateString,
+              time: timeString
+            }, '{{date}}, {{time}}');
+          }
+        };
+        return PDFDocumentProperties;
+      }();
+      exports.PDFDocumentProperties = PDFDocumentProperties;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFFindController = {}, root.pdfjsWebUIUtils);
+    }(this, function (exports, uiUtils) {
+      var scrollIntoView = uiUtils.scrollIntoView;
+      var FindStates = {
+        FIND_FOUND: 0,
+        FIND_NOTFOUND: 1,
+        FIND_WRAPPED: 2,
+        FIND_PENDING: 3
+      };
+      var FIND_SCROLL_OFFSET_TOP = -50;
+      var FIND_SCROLL_OFFSET_LEFT = -400;
+      var CHARACTERS_TO_NORMALIZE = {
+        '\u2018': '\'',
+        // Left single quotation mark
+        '\u2019': '\'',
+        // Right single quotation mark
+        '\u201A': '\'',
+        // Single low-9 quotation mark
+        '\u201B': '\'',
+        // Single high-reversed-9 quotation mark
+        '\u201C': '"',
+        // Left double quotation mark
+        '\u201D': '"',
+        // Right double quotation mark
+        '\u201E': '"',
+        // Double low-9 quotation mark
+        '\u201F': '"',
+        // Double high-reversed-9 quotation mark
+        '\u00BC': '1/4',
+        // Vulgar fraction one quarter
+        '\u00BD': '1/2',
+        // Vulgar fraction one half
+        '\u00BE': '3/4'
+      };
+      // Vulgar fraction three quarters
+      /**
+       * Provides "search" or "find" functionality for the PDF.
+       * This object actually performs the search for a given string.
+       */
+      var PDFFindController = function PDFFindControllerClosure() {
+        function PDFFindController(options) {
+          this.pdfViewer = options.pdfViewer || null;
+          this.onUpdateResultsCount = null;
+          this.onUpdateState = null;
+          this.reset();
+          // Compile the regular expression for text normalization once.
+          var replace = Object.keys(CHARACTERS_TO_NORMALIZE).join('');
+          this.normalizationRegex = new RegExp('[' + replace + ']', 'g');
+        }
+        PDFFindController.prototype = {
+          reset: function PDFFindController_reset() {
+            this.startedTextExtraction = false;
+            this.extractTextPromises = [];
+            this.pendingFindMatches = Object.create(null);
+            this.active = false;
+            // If active, find results will be highlighted.
+            this.pageContents = [];
+            // Stores the text for each page.
+            this.pageMatches = [];
+            this.pageMatchesLength = null;
+            this.matchCount = 0;
+            this.selected = {
+              // Currently selected match.
+              pageIdx: -1,
+              matchIdx: -1
+            };
+            this.offset = {
+              // Where the find algorithm currently is in the document.
+              pageIdx: null,
+              matchIdx: null
+            };
+            this.pagesToSearch = null;
+            this.resumePageIdx = null;
+            this.state = null;
+            this.dirtyMatch = false;
+            this.findTimeout = null;
+            this.firstPagePromise = new Promise(function (resolve) {
+              this.resolveFirstPage = resolve;
+            }.bind(this));
+          },
+          normalize: function PDFFindController_normalize(text) {
+            return text.replace(this.normalizationRegex, function (ch) {
+              return CHARACTERS_TO_NORMALIZE[ch];
+            });
+          },
+          // Helper for multiple search - fills matchesWithLength array
+          // and takes into account cases when one search term
+          // include another search term (for example, "tamed tame" or "this is").
+          // Looking for intersecting terms in the 'matches' and
+          // leave elements with a longer match-length.
+          _prepareMatches: function PDFFindController_prepareMatches(matchesWithLength, matches, matchesLength) {
+            function isSubTerm(matchesWithLength, currentIndex) {
+              var currentElem, prevElem, nextElem;
+              currentElem = matchesWithLength[currentIndex];
+              nextElem = matchesWithLength[currentIndex + 1];
+              // checking for cases like "TAMEd TAME"
+              if (currentIndex < matchesWithLength.length - 1 && currentElem.match === nextElem.match) {
+                currentElem.skipped = true;
+                return true;
+              }
+              // checking for cases like "thIS IS"
+              for (var i = currentIndex - 1; i >= 0; i--) {
+                prevElem = matchesWithLength[i];
+                if (prevElem.skipped) {
+                  continue;
+                }
+                if (prevElem.match + prevElem.matchLength < currentElem.match) {
+                  break;
+                }
+                if (prevElem.match + prevElem.matchLength >= currentElem.match + currentElem.matchLength) {
+                  currentElem.skipped = true;
+                  return true;
+                }
+              }
+              return false;
+            }
+            var i, len;
+            // Sorting array of objects { match: <match>, matchLength: <matchLength> }
+            // in increasing index first and then the lengths.
+            matchesWithLength.sort(function (a, b) {
+              return a.match === b.match ? a.matchLength - b.matchLength : a.match - b.match;
+            });
+            for (i = 0, len = matchesWithLength.length; i < len; i++) {
+              if (isSubTerm(matchesWithLength, i)) {
+                continue;
+              }
+              matches.push(matchesWithLength[i].match);
+              matchesLength.push(matchesWithLength[i].matchLength);
+            }
+          },
+          calcFindPhraseMatch: function PDFFindController_calcFindPhraseMatch(query, pageIndex, pageContent) {
+            var matches = [];
+            var queryLen = query.length;
+            var matchIdx = -queryLen;
+            while (true) {
+              matchIdx = pageContent.indexOf(query, matchIdx + queryLen);
+              if (matchIdx === -1) {
+                break;
+              }
+              matches.push(matchIdx);
+            }
+            this.pageMatches[pageIndex] = matches;
+          },
+          calcFindWordMatch: function PDFFindController_calcFindWordMatch(query, pageIndex, pageContent) {
+            var matchesWithLength = [];
+            // Divide the query into pieces and search for text on each piece.
+            var queryArray = query.match(/\S+/g);
+            var subquery, subqueryLen, matchIdx;
+            for (var i = 0, len = queryArray.length; i < len; i++) {
+              subquery = queryArray[i];
+              subqueryLen = subquery.length;
+              matchIdx = -subqueryLen;
+              while (true) {
+                matchIdx = pageContent.indexOf(subquery, matchIdx + subqueryLen);
+                if (matchIdx === -1) {
+                  break;
+                }
+                // Other searches do not, so we store the length.
+                matchesWithLength.push({
+                  match: matchIdx,
+                  matchLength: subqueryLen,
+                  skipped: false
+                });
+              }
+            }
+            // Prepare arrays for store the matches.
+            if (!this.pageMatchesLength) {
+              this.pageMatchesLength = [];
+            }
+            this.pageMatchesLength[pageIndex] = [];
+            this.pageMatches[pageIndex] = [];
+            // Sort matchesWithLength, clean up intersecting terms
+            // and put the result into the two arrays.
+            this._prepareMatches(matchesWithLength, this.pageMatches[pageIndex], this.pageMatchesLength[pageIndex]);
+          },
+          calcFindMatch: function PDFFindController_calcFindMatch(pageIndex) {
+            var pageContent = this.normalize(this.pageContents[pageIndex]);
+            var query = this.normalize(this.state.query);
+            var caseSensitive = this.state.caseSensitive;
+            var phraseSearch = this.state.phraseSearch;
+            var queryLen = query.length;
+            if (queryLen === 0) {
+              // Do nothing: the matches should be wiped out already.
+              return;
+            }
+            if (!caseSensitive) {
+              pageContent = pageContent.toLowerCase();
+              query = query.toLowerCase();
+            }
+            if (phraseSearch) {
+              this.calcFindPhraseMatch(query, pageIndex, pageContent);
+            } else {
+              this.calcFindWordMatch(query, pageIndex, pageContent);
+            }
+            this.updatePage(pageIndex);
+            if (this.resumePageIdx === pageIndex) {
+              this.resumePageIdx = null;
+              this.nextPageMatch();
+            }
+            // Update the matches count
+            if (this.pageMatches[pageIndex].length > 0) {
+              this.matchCount += this.pageMatches[pageIndex].length;
+              this.updateUIResultsCount();
+            }
+          },
+          extractText: function PDFFindController_extractText() {
+            if (this.startedTextExtraction) {
+              return;
+            }
+            this.startedTextExtraction = true;
+            this.pageContents = [];
+            var extractTextPromisesResolves = [];
+            var numPages = this.pdfViewer.pagesCount;
+            for (var i = 0; i < numPages; i++) {
+              this.extractTextPromises.push(new Promise(function (resolve) {
+                extractTextPromisesResolves.push(resolve);
+              }));
+            }
+            var self = this;
+            function extractPageText(pageIndex) {
+              self.pdfViewer.getPageTextContent(pageIndex).then(function textContentResolved(textContent) {
+                var textItems = textContent.items;
+                var str = [];
+                for (var i = 0, len = textItems.length; i < len; i++) {
+                  str.push(textItems[i].str);
+                }
+                // Store the pageContent as a string.
+                self.pageContents.push(str.join(''));
+                extractTextPromisesResolves[pageIndex](pageIndex);
+                if (pageIndex + 1 < self.pdfViewer.pagesCount) {
+                  extractPageText(pageIndex + 1);
+                }
+              });
+            }
+            extractPageText(0);
+          },
+          executeCommand: function PDFFindController_executeCommand(cmd, state) {
+            if (this.state === null || cmd !== 'findagain') {
+              this.dirtyMatch = true;
+            }
+            this.state = state;
+            this.updateUIState(FindStates.FIND_PENDING);
+            this.firstPagePromise.then(function () {
+              this.extractText();
+              clearTimeout(this.findTimeout);
+              if (cmd === 'find') {
+                // Only trigger the find action after 250ms of silence.
+                this.findTimeout = setTimeout(this.nextMatch.bind(this), 250);
+              } else {
+                this.nextMatch();
+              }
+            }.bind(this));
+          },
+          updatePage: function PDFFindController_updatePage(index) {
+            if (this.selected.pageIdx === index) {
+              // If the page is selected, scroll the page into view, which triggers
+              // rendering the page, which adds the textLayer. Once the textLayer is
+              // build, it will scroll onto the selected match.
+              this.pdfViewer.currentPageNumber = index + 1;
+            }
+            var page = this.pdfViewer.getPageView(index);
+            if (page.textLayer) {
+              page.textLayer.updateMatches();
+            }
+          },
+          nextMatch: function PDFFindController_nextMatch() {
+            var previous = this.state.findPrevious;
+            var currentPageIndex = this.pdfViewer.currentPageNumber - 1;
+            var numPages = this.pdfViewer.pagesCount;
+            this.active = true;
+            if (this.dirtyMatch) {
+              // Need to recalculate the matches, reset everything.
+              this.dirtyMatch = false;
+              this.selected.pageIdx = this.selected.matchIdx = -1;
+              this.offset.pageIdx = currentPageIndex;
+              this.offset.matchIdx = null;
+              this.hadMatch = false;
+              this.resumePageIdx = null;
+              this.pageMatches = [];
+              this.matchCount = 0;
+              this.pageMatchesLength = null;
+              var self = this;
+              for (var i = 0; i < numPages; i++) {
+                // Wipe out any previous highlighted matches.
+                this.updatePage(i);
+                // As soon as the text is extracted start finding the matches.
+                if (!(i in this.pendingFindMatches)) {
+                  this.pendingFindMatches[i] = true;
+                  this.extractTextPromises[i].then(function (pageIdx) {
+                    delete self.pendingFindMatches[pageIdx];
+                    self.calcFindMatch(pageIdx);
+                  });
+                }
+              }
+            }
+            // If there's no query there's no point in searching.
+            if (this.state.query === '') {
+              this.updateUIState(FindStates.FIND_FOUND);
+              return;
+            }
+            // If we're waiting on a page, we return since we can't do anything else.
+            if (this.resumePageIdx) {
+              return;
+            }
+            var offset = this.offset;
+            // Keep track of how many pages we should maximally iterate through.
+            this.pagesToSearch = numPages;
+            // If there's already a matchIdx that means we are iterating through a
+            // page's matches.
+            if (offset.matchIdx !== null) {
+              var numPageMatches = this.pageMatches[offset.pageIdx].length;
+              if (!previous && offset.matchIdx + 1 < numPageMatches || previous && offset.matchIdx > 0) {
+                // The simple case; we just have advance the matchIdx to select
+                // the next match on the page.
+                this.hadMatch = true;
+                offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1;
+                this.updateMatch(true);
+                return;
+              }
+              // We went beyond the current page's matches, so we advance to
+              // the next page.
+              this.advanceOffsetPage(previous);
+            }
+            // Start searching through the page.
+            this.nextPageMatch();
+          },
+          matchesReady: function PDFFindController_matchesReady(matches) {
+            var offset = this.offset;
+            var numMatches = matches.length;
+            var previous = this.state.findPrevious;
+            if (numMatches) {
+              // There were matches for the page, so initialize the matchIdx.
+              this.hadMatch = true;
+              offset.matchIdx = previous ? numMatches - 1 : 0;
+              this.updateMatch(true);
+              return true;
+            } else {
+              // No matches, so attempt to search the next page.
+              this.advanceOffsetPage(previous);
+              if (offset.wrapped) {
+                offset.matchIdx = null;
+                if (this.pagesToSearch < 0) {
+                  // No point in wrapping again, there were no matches.
+                  this.updateMatch(false);
+                  // while matches were not found, searching for a page
+                  // with matches should nevertheless halt.
+                  return true;
+                }
+              }
+              // Matches were not found (and searching is not done).
+              return false;
+            }
+          },
+          /**
+           * The method is called back from the text layer when match presentation
+           * is updated.
+           * @param {number} pageIndex - page index.
+           * @param {number} index - match index.
+           * @param {Array} elements - text layer div elements array.
+           * @param {number} beginIdx - start index of the div array for the match.
+           */
+          updateMatchPosition: function PDFFindController_updateMatchPosition(pageIndex, index, elements, beginIdx) {
+            if (this.selected.matchIdx === index && this.selected.pageIdx === pageIndex) {
+              var spot = {
+                top: FIND_SCROLL_OFFSET_TOP,
+                left: FIND_SCROLL_OFFSET_LEFT
+              };
+              scrollIntoView(elements[beginIdx], spot, /* skipOverflowHiddenElements = */
+              true);
+            }
+          },
+          nextPageMatch: function PDFFindController_nextPageMatch() {
+            if (this.resumePageIdx !== null) {
+              console.error('There can only be one pending page.');
+            }
+            do {
+              var pageIdx = this.offset.pageIdx;
+              var matches = this.pageMatches[pageIdx];
+              if (!matches) {
+                // The matches don't exist yet for processing by "matchesReady",
+                // so set a resume point for when they do exist.
+                this.resumePageIdx = pageIdx;
+                break;
+              }
+            } while (!this.matchesReady(matches));
+          },
+          advanceOffsetPage: function PDFFindController_advanceOffsetPage(previous) {
+            var offset = this.offset;
+            var numPages = this.extractTextPromises.length;
+            offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;
+            offset.matchIdx = null;
+            this.pagesToSearch--;
+            if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
+              offset.pageIdx = previous ? numPages - 1 : 0;
+              offset.wrapped = true;
+            }
+          },
+          updateMatch: function PDFFindController_updateMatch(found) {
+            var state = FindStates.FIND_NOTFOUND;
+            var wrapped = this.offset.wrapped;
+            this.offset.wrapped = false;
+            if (found) {
+              var previousPage = this.selected.pageIdx;
+              this.selected.pageIdx = this.offset.pageIdx;
+              this.selected.matchIdx = this.offset.matchIdx;
+              state = wrapped ? FindStates.FIND_WRAPPED : FindStates.FIND_FOUND;
+              // Update the currently selected page to wipe out any selected matches.
+              if (previousPage !== -1 && previousPage !== this.selected.pageIdx) {
+                this.updatePage(previousPage);
+              }
+            }
+            this.updateUIState(state, this.state.findPrevious);
+            if (this.selected.pageIdx !== -1) {
+              this.updatePage(this.selected.pageIdx);
+            }
+          },
+          updateUIResultsCount: function PDFFindController_updateUIResultsCount() {
+            if (this.onUpdateResultsCount) {
+              this.onUpdateResultsCount(this.matchCount);
+            }
+          },
+          updateUIState: function PDFFindController_updateUIState(state, previous) {
+            if (this.onUpdateState) {
+              this.onUpdateState(state, previous, this.matchCount);
+            }
+          }
+        };
+        return PDFFindController;
+      }();
+      exports.FindStates = FindStates;
+      exports.PDFFindController = PDFFindController;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFPresentationMode = {}, root.pdfjsWebUIUtils);
+    }(this, function (exports, uiUtils) {
+      var normalizeWheelEventDelta = uiUtils.normalizeWheelEventDelta;
+      var DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
+      // in ms
+      var DELAY_BEFORE_HIDING_CONTROLS = 3000;
+      // in ms
+      var ACTIVE_SELECTOR = 'pdfPresentationMode';
+      var CONTROLS_SELECTOR = 'pdfPresentationModeControls';
+      /**
+       * @typedef {Object} PDFPresentationModeOptions
+       * @property {HTMLDivElement} container - The container for the viewer element.
+       * @property {HTMLDivElement} viewer - (optional) The viewer element.
+       * @property {PDFViewer} pdfViewer - The document viewer.
+       * @property {EventBus} eventBus - The application event bus.
+       * @property {Array} contextMenuItems - (optional) The menuitems that are added
+       *   to the context menu in Presentation Mode.
+       */
+      /**
+       * @class
+       */
+      var PDFPresentationMode = function PDFPresentationModeClosure() {
+        /**
+         * @constructs PDFPresentationMode
+         * @param {PDFPresentationModeOptions} options
+         */
+        function PDFPresentationMode(options) {
+          this.container = options.container;
+          this.viewer = options.viewer || options.container.firstElementChild;
+          this.pdfViewer = options.pdfViewer;
+          this.eventBus = options.eventBus;
+          var contextMenuItems = options.contextMenuItems || null;
+          this.active = false;
+          this.args = null;
+          this.contextMenuOpen = false;
+          this.mouseScrollTimeStamp = 0;
+          this.mouseScrollDelta = 0;
+          this.touchSwipeState = null;
+          if (contextMenuItems) {
+            contextMenuItems.contextFirstPage.addEventListener('click', function PDFPresentationMode_contextFirstPageClick(e) {
+              this.contextMenuOpen = false;
+              this.eventBus.dispatch('firstpage');
+            }.bind(this));
+            contextMenuItems.contextLastPage.addEventListener('click', function PDFPresentationMode_contextLastPageClick(e) {
+              this.contextMenuOpen = false;
+              this.eventBus.dispatch('lastpage');
+            }.bind(this));
+            contextMenuItems.contextPageRotateCw.addEventListener('click', function PDFPresentationMode_contextPageRotateCwClick(e) {
+              this.contextMenuOpen = false;
+              this.eventBus.dispatch('rotatecw');
+            }.bind(this));
+            contextMenuItems.contextPageRotateCcw.addEventListener('click', function PDFPresentationMode_contextPageRotateCcwClick(e) {
+              this.contextMenuOpen = false;
+              this.eventBus.dispatch('rotateccw');
+            }.bind(this));
+          }
+        }
+        PDFPresentationMode.prototype = {
+          /**
+           * Request the browser to enter fullscreen mode.
+           * @returns {boolean} Indicating if the request was successful.
+           */
+          request: function PDFPresentationMode_request() {
+            if (this.switchInProgress || this.active || !this.viewer.hasChildNodes()) {
+              return false;
+            }
+            this._addFullscreenChangeListeners();
+            this._setSwitchInProgress();
+            this._notifyStateChange();
+            if (this.container.requestFullscreen) {
+              this.container.requestFullscreen();
+            } else if (this.container.mozRequestFullScreen) {
+              this.container.mozRequestFullScreen();
+            } else if (this.container.webkitRequestFullscreen) {
+              this.container.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
+            } else if (this.container.msRequestFullscreen) {
+              this.container.msRequestFullscreen();
+            } else {
+              return false;
+            }
+            this.args = {
+              page: this.pdfViewer.currentPageNumber,
+              previousScale: this.pdfViewer.currentScaleValue
+            };
+            return true;
+          },
+          /**
+           * @private
+           */
+          _mouseWheel: function PDFPresentationMode_mouseWheel(evt) {
+            if (!this.active) {
+              return;
+            }
+            evt.preventDefault();
+            var delta = normalizeWheelEventDelta(evt);
+            var MOUSE_SCROLL_COOLDOWN_TIME = 50;
+            var PAGE_SWITCH_THRESHOLD = 0.1;
+            var currentTime = new Date().getTime();
+            var storedTime = this.mouseScrollTimeStamp;
+            // If we've already switched page, avoid accidentally switching again.
+            if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
+              return;
+            }
+            // If the scroll direction changed, reset the accumulated scroll delta.
+            if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta < 0 && delta > 0) {
+              this._resetMouseScrollState();
+            }
+            this.mouseScrollDelta += delta;
+            if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
+              var totalDelta = this.mouseScrollDelta;
+              this._resetMouseScrollState();
+              var success = totalDelta > 0 ? this._goToPreviousPage() : this._goToNextPage();
+              if (success) {
+                this.mouseScrollTimeStamp = currentTime;
+              }
+            }
+          },
+          get isFullscreen() {
+            return !!(document.fullscreenElement || document.mozFullScreen || document.webkitIsFullScreen || document.msFullscreenElement);
+          },
+          /**
+           * @private
+           */
+          _goToPreviousPage: function PDFPresentationMode_goToPreviousPage() {
+            var page = this.pdfViewer.currentPageNumber;
+            // If we're at the first page, we don't need to do anything.
+            if (page <= 1) {
+              return false;
+            }
+            this.pdfViewer.currentPageNumber = page - 1;
+            return true;
+          },
+          /**
+           * @private
+           */
+          _goToNextPage: function PDFPresentationMode_goToNextPage() {
+            var page = this.pdfViewer.currentPageNumber;
+            // If we're at the last page, we don't need to do anything.
+            if (page >= this.pdfViewer.pagesCount) {
+              return false;
+            }
+            this.pdfViewer.currentPageNumber = page + 1;
+            return true;
+          },
+          /**
+           * @private
+           */
+          _notifyStateChange: function PDFPresentationMode_notifyStateChange() {
+            this.eventBus.dispatch('presentationmodechanged', {
+              source: this,
+              active: this.active,
+              switchInProgress: !!this.switchInProgress
+            });
+          },
+          /**
+           * Used to initialize a timeout when requesting Presentation Mode,
+           * i.e. when the browser is requested to enter fullscreen mode.
+           * This timeout is used to prevent the current page from being scrolled
+           * partially, or completely, out of view when entering Presentation Mode.
+           * NOTE: This issue seems limited to certain zoom levels (e.g. page-width).
+           * @private
+           */
+          _setSwitchInProgress: function PDFPresentationMode_setSwitchInProgress() {
+            if (this.switchInProgress) {
+              clearTimeout(this.switchInProgress);
+            }
+            this.switchInProgress = setTimeout(function switchInProgressTimeout() {
+              this._removeFullscreenChangeListeners();
+              delete this.switchInProgress;
+              this._notifyStateChange();
+            }.bind(this), DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
+          },
+          /**
+           * @private
+           */
+          _resetSwitchInProgress: function PDFPresentationMode_resetSwitchInProgress() {
+            if (this.switchInProgress) {
+              clearTimeout(this.switchInProgress);
+              delete this.switchInProgress;
+            }
+          },
+          /**
+           * @private
+           */
+          _enter: function PDFPresentationMode_enter() {
+            this.active = true;
+            this._resetSwitchInProgress();
+            this._notifyStateChange();
+            this.container.classList.add(ACTIVE_SELECTOR);
+            // Ensure that the correct page is scrolled into view when entering
+            // Presentation Mode, by waiting until fullscreen mode in enabled.
+            setTimeout(function enterPresentationModeTimeout() {
+              this.pdfViewer.currentPageNumber = this.args.page;
+              this.pdfViewer.currentScaleValue = 'page-fit';
+            }.bind(this), 0);
+            this._addWindowListeners();
+            this._showControls();
+            this.contextMenuOpen = false;
+            this.container.setAttribute('contextmenu', 'viewerContextMenu');
+            // Text selection is disabled in Presentation Mode, thus it's not possible
+            // for the user to deselect text that is selected (e.g. with "Select all")
+            // when entering Presentation Mode, hence we remove any active selection.
+            window.getSelection().removeAllRanges();
+          },
+          /**
+           * @private
+           */
+          _exit: function PDFPresentationMode_exit() {
+            var page = this.pdfViewer.currentPageNumber;
+            this.container.classList.remove(ACTIVE_SELECTOR);
+            // Ensure that the correct page is scrolled into view when exiting
+            // Presentation Mode, by waiting until fullscreen mode is disabled.
+            setTimeout(function exitPresentationModeTimeout() {
+              this.active = false;
+              this._removeFullscreenChangeListeners();
+              this._notifyStateChange();
+              this.pdfViewer.currentScaleValue = this.args.previousScale;
+              this.pdfViewer.currentPageNumber = page;
+              this.args = null;
+            }.bind(this), 0);
+            this._removeWindowListeners();
+            this._hideControls();
+            this._resetMouseScrollState();
+            this.container.removeAttribute('contextmenu');
+            this.contextMenuOpen = false;
+          },
+          /**
+           * @private
+           */
+          _mouseDown: function PDFPresentationMode_mouseDown(evt) {
+            if (this.contextMenuOpen) {
+              this.contextMenuOpen = false;
+              evt.preventDefault();
+              return;
+            }
+            if (evt.button === 0) {
+              // Enable clicking of links in presentation mode. Please note:
+              // Only links pointing to destinations in the current PDF document work.
+              var isInternalLink = evt.target.href && evt.target.classList.contains('internalLink');
+              if (!isInternalLink) {
+                // Unless an internal link was clicked, advance one page.
+                evt.preventDefault();
+                this.pdfViewer.currentPageNumber += evt.shiftKey ? -1 : 1;
+              }
+            }
+          },
+          /**
+           * @private
+           */
+          _contextMenu: function PDFPresentationMode_contextMenu() {
+            this.contextMenuOpen = true;
+          },
+          /**
+           * @private
+           */
+          _showControls: function PDFPresentationMode_showControls() {
+            if (this.controlsTimeout) {
+              clearTimeout(this.controlsTimeout);
+            } else {
+              this.container.classList.add(CONTROLS_SELECTOR);
+            }
+            this.controlsTimeout = setTimeout(function showControlsTimeout() {
+              this.container.classList.remove(CONTROLS_SELECTOR);
+              delete this.controlsTimeout;
+            }.bind(this), DELAY_BEFORE_HIDING_CONTROLS);
+          },
+          /**
+           * @private
+           */
+          _hideControls: function PDFPresentationMode_hideControls() {
+            if (!this.controlsTimeout) {
+              return;
+            }
+            clearTimeout(this.controlsTimeout);
+            this.container.classList.remove(CONTROLS_SELECTOR);
+            delete this.controlsTimeout;
+          },
+          /**
+           * Resets the properties used for tracking mouse scrolling events.
+           * @private
+           */
+          _resetMouseScrollState: function PDFPresentationMode_resetMouseScrollState() {
+            this.mouseScrollTimeStamp = 0;
+            this.mouseScrollDelta = 0;
+          },
+          /**
+           * @private
+           */
+          _touchSwipe: function PDFPresentationMode_touchSwipe(evt) {
+            if (!this.active) {
+              return;
+            }
+            // Must move at least these many CSS pixels for it to count as a swipe
+            var SWIPE_MIN_DISTANCE_THRESHOLD = 50;
+            // The swipe angle is allowed to deviate from the x or y axis by this much
+            // before it is not considered a swipe in that direction any more.
+            var SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
+            if (evt.touches.length > 1) {
+              // Multiple touch points detected, cancel the swipe.
+              this.touchSwipeState = null;
+              return;
+            }
+            switch (evt.type) {
+            case 'touchstart':
+              this.touchSwipeState = {
+                startX: evt.touches[0].pageX,
+                startY: evt.touches[0].pageY,
+                endX: evt.touches[0].pageX,
+                endY: evt.touches[0].pageY
+              };
+              break;
+            case 'touchmove':
+              if (this.touchSwipeState === null) {
+                return;
+              }
+              this.touchSwipeState.endX = evt.touches[0].pageX;
+              this.touchSwipeState.endY = evt.touches[0].pageY;
+              // Do a preventDefault to avoid the swipe from triggering browser
+              // gestures (Chrome in particular has some sort of swipe gesture in
+              // fullscreen mode).
+              evt.preventDefault();
+              break;
+            case 'touchend':
+              if (this.touchSwipeState === null) {
+                return;
+              }
+              var delta = 0;
+              var dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
+              var dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
+              var absAngle = Math.abs(Math.atan2(dy, dx));
+              if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <= SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
+                // horizontal swipe
+                delta = dx;
+              } else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
+                // vertical swipe
+                delta = dy;
+              }
+              if (delta > 0) {
+                this._goToPreviousPage();
+              } else if (delta < 0) {
+                this._goToNextPage();
+              }
+              break;
+            }
+          },
+          /**
+           * @private
+           */
+          _addWindowListeners: function PDFPresentationMode_addWindowListeners() {
+            this.showControlsBind = this._showControls.bind(this);
+            this.mouseDownBind = this._mouseDown.bind(this);
+            this.mouseWheelBind = this._mouseWheel.bind(this);
+            this.resetMouseScrollStateBind = this._resetMouseScrollState.bind(this);
+            this.contextMenuBind = this._contextMenu.bind(this);
+            this.touchSwipeBind = this._touchSwipe.bind(this);
+            window.addEventListener('mousemove', this.showControlsBind);
+            window.addEventListener('mousedown', this.mouseDownBind);
+            window.addEventListener('wheel', this.mouseWheelBind);
+            window.addEventListener('keydown', this.resetMouseScrollStateBind);
+            window.addEventListener('contextmenu', this.contextMenuBind);
+            window.addEventListener('touchstart', this.touchSwipeBind);
+            window.addEventListener('touchmove', this.touchSwipeBind);
+            window.addEventListener('touchend', this.touchSwipeBind);
+          },
+          /**
+           * @private
+           */
+          _removeWindowListeners: function PDFPresentationMode_removeWindowListeners() {
+            window.removeEventListener('mousemove', this.showControlsBind);
+            window.removeEventListener('mousedown', this.mouseDownBind);
+            window.removeEventListener('wheel', this.mouseWheelBind);
+            window.removeEventListener('keydown', this.resetMouseScrollStateBind);
+            window.removeEventListener('contextmenu', this.contextMenuBind);
+            window.removeEventListener('touchstart', this.touchSwipeBind);
+            window.removeEventListener('touchmove', this.touchSwipeBind);
+            window.removeEventListener('touchend', this.touchSwipeBind);
+            delete this.showControlsBind;
+            delete this.mouseDownBind;
+            delete this.mouseWheelBind;
+            delete this.resetMouseScrollStateBind;
+            delete this.contextMenuBind;
+            delete this.touchSwipeBind;
+          },
+          /**
+           * @private
+           */
+          _fullscreenChange: function PDFPresentationMode_fullscreenChange() {
+            if (this.isFullscreen) {
+              this._enter();
+            } else {
+              this._exit();
+            }
+          },
+          /**
+           * @private
+           */
+          _addFullscreenChangeListeners: function PDFPresentationMode_addFullscreenChangeListeners() {
+            this.fullscreenChangeBind = this._fullscreenChange.bind(this);
+            window.addEventListener('fullscreenchange', this.fullscreenChangeBind);
+            window.addEventListener('mozfullscreenchange', this.fullscreenChangeBind);
+          },
+          /**
+           * @private
+           */
+          _removeFullscreenChangeListeners: function PDFPresentationMode_removeFullscreenChangeListeners() {
+            window.removeEventListener('fullscreenchange', this.fullscreenChangeBind);
+            window.removeEventListener('mozfullscreenchange', this.fullscreenChangeBind);
+            delete this.fullscreenChangeBind;
+          }
+        };
+        return PDFPresentationMode;
+      }();
+      exports.PDFPresentationMode = PDFPresentationMode;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFThumbnailView = {}, root.pdfjsWebUIUtils, root.pdfjsWebPDFRenderingQueue);
+    }(this, function (exports, uiUtils, pdfRenderingQueue) {
+      var mozL10n = uiUtils.mozL10n;
+      var getOutputScale = uiUtils.getOutputScale;
+      var RenderingStates = pdfRenderingQueue.RenderingStates;
+      var THUMBNAIL_WIDTH = 98;
+      // px
+      var THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
+      // px
+      /**
+       * @typedef {Object} PDFThumbnailViewOptions
+       * @property {HTMLDivElement} container - The viewer element.
+       * @property {number} id - The thumbnail's unique ID (normally its number).
+       * @property {PageViewport} defaultViewport - The page viewport.
+       * @property {IPDFLinkService} linkService - The navigation/linking service.
+       * @property {PDFRenderingQueue} renderingQueue - The rendering queue object.
+       * @property {boolean} disableCanvasToImageConversion - (optional) Don't convert
+       *   the canvas thumbnails to images. This prevents `toDataURL` calls,
+       *   but increases the overall memory usage. The default value is false.
+       */
+      /**
+       * @class
+       * @implements {IRenderableView}
+       */
+      var PDFThumbnailView = function PDFThumbnailViewClosure() {
+        function getTempCanvas(width, height) {
+          var tempCanvas = PDFThumbnailView.tempImageCache;
+          if (!tempCanvas) {
+            tempCanvas = document.createElement('canvas');
+            PDFThumbnailView.tempImageCache = tempCanvas;
+          }
+          tempCanvas.width = width;
+          tempCanvas.height = height;
+          tempCanvas.mozOpaque = true;
+          var ctx = tempCanvas.getContext('2d', { alpha: false });
+          ctx.save();
+          ctx.fillStyle = 'rgb(255, 255, 255)';
+          ctx.fillRect(0, 0, width, height);
+          ctx.restore();
+          return tempCanvas;
+        }
+        /**
+         * @constructs PDFThumbnailView
+         * @param {PDFThumbnailViewOptions} options
+         */
+        function PDFThumbnailView(options) {
+          var container = options.container;
+          var id = options.id;
+          var defaultViewport = options.defaultViewport;
+          var linkService = options.linkService;
+          var renderingQueue = options.renderingQueue;
+          var disableCanvasToImageConversion = options.disableCanvasToImageConversion || false;
+          this.id = id;
+          this.renderingId = 'thumbnail' + id;
+          this.pageLabel = null;
+          this.pdfPage = null;
+          this.rotation = 0;
+          this.viewport = defaultViewport;
+          this.pdfPageRotate = defaultViewport.rotation;
+          this.linkService = linkService;
+          this.renderingQueue = renderingQueue;
+          this.renderTask = null;
+          this.renderingState = RenderingStates.INITIAL;
+          this.resume = null;
+          this.disableCanvasToImageConversion = disableCanvasToImageConversion;
+          this.pageWidth = this.viewport.width;
+          this.pageHeight = this.viewport.height;
+          this.pageRatio = this.pageWidth / this.pageHeight;
+          this.canvasWidth = THUMBNAIL_WIDTH;
+          this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
+          this.scale = this.canvasWidth / this.pageWidth;
+          var anchor = document.createElement('a');
+          anchor.href = linkService.getAnchorUrl('#page=' + id);
+          anchor.title = mozL10n.get('thumb_page_title', { page: id }, 'Page {{page}}');
+          anchor.onclick = function stopNavigation() {
+            linkService.page = id;
+            return false;
+          };
+          this.anchor = anchor;
+          var div = document.createElement('div');
+          div.id = 'thumbnailContainer' + id;
+          div.className = 'thumbnail';
+          this.div = div;
+          if (id === 1) {
+            // Highlight the thumbnail of the first page when no page number is
+            // specified (or exists in cache) when the document is loaded.
+            div.classList.add('selected');
+          }
+          var ring = document.createElement('div');
+          ring.className = 'thumbnailSelectionRing';
+          var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
+          ring.style.width = this.canvasWidth + borderAdjustment + 'px';
+          ring.style.height = this.canvasHeight + borderAdjustment + 'px';
+          this.ring = ring;
+          div.appendChild(ring);
+          anchor.appendChild(div);
+          container.appendChild(anchor);
+        }
+        PDFThumbnailView.prototype = {
+          setPdfPage: function PDFThumbnailView_setPdfPage(pdfPage) {
+            this.pdfPage = pdfPage;
+            this.pdfPageRotate = pdfPage.rotate;
+            var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+            this.viewport = pdfPage.getViewport(1, totalRotation);
+            this.reset();
+          },
+          reset: function PDFThumbnailView_reset() {
+            this.cancelRendering();
+            this.pageWidth = this.viewport.width;
+            this.pageHeight = this.viewport.height;
+            this.pageRatio = this.pageWidth / this.pageHeight;
+            this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
+            this.scale = this.canvasWidth / this.pageWidth;
+            this.div.removeAttribute('data-loaded');
+            var ring = this.ring;
+            var childNodes = ring.childNodes;
+            for (var i = childNodes.length - 1; i >= 0; i--) {
+              ring.removeChild(childNodes[i]);
+            }
+            var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
+            ring.style.width = this.canvasWidth + borderAdjustment + 'px';
+            ring.style.height = this.canvasHeight + borderAdjustment + 'px';
+            if (this.canvas) {
+              // Zeroing the width and height causes Firefox to release graphics
+              // resources immediately, which can greatly reduce memory consumption.
+              this.canvas.width = 0;
+              this.canvas.height = 0;
+              delete this.canvas;
+            }
+            if (this.image) {
+              this.image.removeAttribute('src');
+              delete this.image;
+            }
+          },
+          update: function PDFThumbnailView_update(rotation) {
+            if (typeof rotation !== 'undefined') {
+              this.rotation = rotation;
+            }
+            var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+            this.viewport = this.viewport.clone({
+              scale: 1,
+              rotation: totalRotation
+            });
+            this.reset();
+          },
+          cancelRendering: function PDFThumbnailView_cancelRendering() {
+            if (this.renderTask) {
+              this.renderTask.cancel();
+              this.renderTask = null;
+            }
+            this.renderingState = RenderingStates.INITIAL;
+            this.resume = null;
+          },
+          /**
+           * @private
+           */
+          _getPageDrawContext: function PDFThumbnailView_getPageDrawContext(noCtxScale) {
+            var canvas = document.createElement('canvas');
+            // Keep the no-thumbnail outline visible, i.e. `data-loaded === false`,
+            // until rendering/image conversion is complete, to avoid display issues.
+            this.canvas = canvas;
+            canvas.mozOpaque = true;
+            var ctx = canvas.getContext('2d', { alpha: false });
+            var outputScale = getOutputScale(ctx);
+            canvas.width = this.canvasWidth * outputScale.sx | 0;
+            canvas.height = this.canvasHeight * outputScale.sy | 0;
+            canvas.style.width = this.canvasWidth + 'px';
+            canvas.style.height = this.canvasHeight + 'px';
+            if (!noCtxScale && outputScale.scaled) {
+              ctx.scale(outputScale.sx, outputScale.sy);
+            }
+            return ctx;
+          },
+          /**
+           * @private
+           */
+          _convertCanvasToImage: function PDFThumbnailView_convertCanvasToImage() {
+            if (!this.canvas) {
+              return;
+            }
+            if (this.renderingState !== RenderingStates.FINISHED) {
+              return;
+            }
+            var id = this.renderingId;
+            var className = 'thumbnailImage';
+            var ariaLabel = mozL10n.get('thumb_page_canvas', { page: this.pageId }, 'Thumbnail of Page {{page}}');
+            if (this.disableCanvasToImageConversion) {
+              this.canvas.id = id;
+              this.canvas.className = className;
+              this.canvas.setAttribute('aria-label', ariaLabel);
+              this.div.setAttribute('data-loaded', true);
+              this.ring.appendChild(this.canvas);
+              return;
+            }
+            var image = document.createElement('img');
+            image.id = id;
+            image.className = className;
+            image.setAttribute('aria-label', ariaLabel);
+            image.style.width = this.canvasWidth + 'px';
+            image.style.height = this.canvasHeight + 'px';
+            image.src = this.canvas.toDataURL();
+            this.image = image;
+            this.div.setAttribute('data-loaded', true);
+            this.ring.appendChild(image);
+            // Zeroing the width and height causes Firefox to release graphics
+            // resources immediately, which can greatly reduce memory consumption.
+            this.canvas.width = 0;
+            this.canvas.height = 0;
+            delete this.canvas;
+          },
+          draw: function PDFThumbnailView_draw() {
+            if (this.renderingState !== RenderingStates.INITIAL) {
+              console.error('Must be in new state before drawing');
+              return Promise.resolve(undefined);
+            }
+            this.renderingState = RenderingStates.RUNNING;
+            var resolveRenderPromise, rejectRenderPromise;
+            var promise = new Promise(function (resolve, reject) {
+              resolveRenderPromise = resolve;
+              rejectRenderPromise = reject;
+            });
+            var self = this;
+            function thumbnailDrawCallback(error) {
+              // The renderTask may have been replaced by a new one, so only remove
+              // the reference to the renderTask if it matches the one that is
+              // triggering this callback.
+              if (renderTask === self.renderTask) {
+                self.renderTask = null;
+              }
+              if (error === 'cancelled') {
+                rejectRenderPromise(error);
+                return;
+              }
+              self.renderingState = RenderingStates.FINISHED;
+              self._convertCanvasToImage();
+              if (!error) {
+                resolveRenderPromise(undefined);
+              } else {
+                rejectRenderPromise(error);
+              }
+            }
+            var ctx = this._getPageDrawContext();
+            var drawViewport = this.viewport.clone({ scale: this.scale });
+            var renderContinueCallback = function renderContinueCallback(cont) {
+              if (!self.renderingQueue.isHighestPriority(self)) {
+                self.renderingState = RenderingStates.PAUSED;
+                self.resume = function resumeCallback() {
+                  self.renderingState = RenderingStates.RUNNING;
+                  cont();
+                };
+                return;
+              }
+              cont();
+            };
+            var renderContext = {
+              canvasContext: ctx,
+              viewport: drawViewport
+            };
+            var renderTask = this.renderTask = this.pdfPage.render(renderContext);
+            renderTask.onContinue = renderContinueCallback;
+            renderTask.promise.then(function pdfPageRenderCallback() {
+              thumbnailDrawCallback(null);
+            }, function pdfPageRenderError(error) {
+              thumbnailDrawCallback(error);
+            });
+            return promise;
+          },
+          setImage: function PDFThumbnailView_setImage(pageView) {
+            if (this.renderingState !== RenderingStates.INITIAL) {
+              return;
+            }
+            var img = pageView.canvas;
+            if (!img) {
+              return;
+            }
+            if (!this.pdfPage) {
+              this.setPdfPage(pageView.pdfPage);
+            }
+            this.renderingState = RenderingStates.FINISHED;
+            var ctx = this._getPageDrawContext(true);
+            var canvas = ctx.canvas;
+            if (img.width <= 2 * canvas.width) {
+              ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width, canvas.height);
+              this._convertCanvasToImage();
+              return;
+            }
+            // drawImage does an awful job of rescaling the image, doing it gradually.
+            var MAX_NUM_SCALING_STEPS = 3;
+            var reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
+            var reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;
+            var reducedImage = getTempCanvas(reducedWidth, reducedHeight);
+            var reducedImageCtx = reducedImage.getContext('2d');
+            while (reducedWidth > img.width || reducedHeight > img.height) {
+              reducedWidth >>= 1;
+              reducedHeight >>= 1;
+            }
+            reducedImageCtx.drawImage(img, 0, 0, img.width, img.height, 0, 0, reducedWidth, reducedHeight);
+            while (reducedWidth > 2 * canvas.width) {
+              reducedImageCtx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, reducedWidth >> 1, reducedHeight >> 1);
+              reducedWidth >>= 1;
+              reducedHeight >>= 1;
+            }
+            ctx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0, canvas.width, canvas.height);
+            this._convertCanvasToImage();
+          },
+          get pageId() {
+            return this.pageLabel !== null ? this.pageLabel : this.id;
+          },
+          /**
+           * @param {string|null} label
+           */
+          setPageLabel: function PDFThumbnailView_setPageLabel(label) {
+            this.pageLabel = typeof label === 'string' ? label : null;
+            this.anchor.title = mozL10n.get('thumb_page_title', { page: this.pageId }, 'Page {{page}}');
+            if (this.renderingState !== RenderingStates.FINISHED) {
+              return;
+            }
+            var ariaLabel = mozL10n.get('thumb_page_canvas', { page: this.pageId }, 'Thumbnail of Page {{page}}');
+            if (this.image) {
+              this.image.setAttribute('aria-label', ariaLabel);
+            } else if (this.disableCanvasToImageConversion && this.canvas) {
+              this.canvas.setAttribute('aria-label', ariaLabel);
+            }
+          }
+        };
+        return PDFThumbnailView;
+      }();
+      PDFThumbnailView.tempImageCache = null;
+      exports.PDFThumbnailView = PDFThumbnailView;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebSecondaryToolbar = {}, root.pdfjsWebUIUtils);
+    }(this, function (exports, uiUtils) {
+      var SCROLLBAR_PADDING = uiUtils.SCROLLBAR_PADDING;
+      var mozL10n = uiUtils.mozL10n;
+      /**
+       * @typedef {Object} SecondaryToolbarOptions
+       * @property {HTMLDivElement} toolbar - Container for the secondary toolbar.
+       * @property {HTMLButtonElement} toggleButton - Button to toggle the visibility
+       *   of the secondary toolbar.
+       * @property {HTMLDivElement} toolbarButtonContainer - Container where all the
+       *   toolbar buttons are placed. The maximum height of the toolbar is controlled
+       *   dynamically by adjusting the 'max-height' CSS property of this DOM element.
+       * @property {HTMLButtonElement} presentationModeButton - Button for entering
+       *   presentation mode.
+       * @property {HTMLButtonElement} openFileButton - Button to open a file.
+       * @property {HTMLButtonElement} printButton - Button to print the document.
+       * @property {HTMLButtonElement} downloadButton - Button to download the
+       *   document.
+       * @property {HTMLLinkElement} viewBookmarkButton - Button to obtain a bookmark
+       *   link to the current location in the document.
+       * @property {HTMLButtonElement} firstPageButton - Button to go to the first
+       *   page in the document.
+       * @property {HTMLButtonElement} lastPageButton - Button to go to the last page
+       *   in the document.
+       * @property {HTMLButtonElement} pageRotateCwButton - Button to rotate the pages
+       *   clockwise.
+       * @property {HTMLButtonElement} pageRotateCcwButton - Button to rotate the
+       *   pages counterclockwise.
+       * @property {HTMLButtonElement} toggleHandToolButton - Button to toggle the
+       *   hand tool.
+       * @property {HTMLButtonElement} documentPropertiesButton - Button for opening
+       *   the document properties dialog.
+       */
+      /**
+       * @class
+       */
+      var SecondaryToolbar = function SecondaryToolbarClosure() {
+        /**
+         * @constructs SecondaryToolbar
+         * @param {SecondaryToolbarOptions} options
+         * @param {HTMLDivElement} mainContainer
+         * @param {EventBus} eventBus
+         */
+        function SecondaryToolbar(options, mainContainer, eventBus) {
+          this.toolbar = options.toolbar;
+          this.toggleButton = options.toggleButton;
+          this.toolbarButtonContainer = options.toolbarButtonContainer;
+          this.buttons = [
+            {
+              element: options.presentationModeButton,
+              eventName: 'presentationmode',
+              close: true
+            },
+            {
+              element: options.openFileButton,
+              eventName: 'openfile',
+              close: true
+            },
+            {
+              element: options.printButton,
+              eventName: 'print',
+              close: true
+            },
+            {
+              element: options.downloadButton,
+              eventName: 'download',
+              close: true
+            },
+            {
+              element: options.viewBookmarkButton,
+              eventName: null,
+              close: true
+            },
+            {
+              element: options.firstPageButton,
+              eventName: 'firstpage',
+              close: true
+            },
+            {
+              element: options.lastPageButton,
+              eventName: 'lastpage',
+              close: true
+            },
+            {
+              element: options.pageRotateCwButton,
+              eventName: 'rotatecw',
+              close: false
+            },
+            {
+              element: options.pageRotateCcwButton,
+              eventName: 'rotateccw',
+              close: false
+            },
+            {
+              element: options.toggleHandToolButton,
+              eventName: 'togglehandtool',
+              close: true
+            },
+            {
+              element: options.documentPropertiesButton,
+              eventName: 'documentproperties',
+              close: true
+            }
+          ];
+          this.mainContainer = mainContainer;
+          this.eventBus = eventBus;
+          this.opened = false;
+          this.containerHeight = null;
+          this.previousContainerHeight = null;
+          // Bind the event listeners for click and hand tool actions.
+          this._bindClickListeners();
+          this._bindHandToolListener(options.toggleHandToolButton);
+          // Bind the event listener for adjusting the 'max-height' of the toolbar.
+          this.eventBus.on('resize', this._setMaxHeight.bind(this));
+        }
+        SecondaryToolbar.prototype = {
+          /**
+           * @return {boolean}
+           */
+          get isOpen() {
+            return this.opened;
+          },
+          _bindClickListeners: function SecondaryToolbar_bindClickListeners() {
+            // Button to toggle the visibility of the secondary toolbar.
+            this.toggleButton.addEventListener('click', this.toggle.bind(this));
+            // All items within the secondary toolbar.
+            for (var button in this.buttons) {
+              var element = this.buttons[button].element;
+              var eventName = this.buttons[button].eventName;
+              var close = this.buttons[button].close;
+              element.addEventListener('click', function (eventName, close) {
+                if (eventName !== null) {
+                  this.eventBus.dispatch(eventName, { source: this });
+                }
+                if (close) {
+                  this.close();
+                }
+              }.bind(this, eventName, close));
+            }
+          },
+          _bindHandToolListener: function SecondaryToolbar_bindHandToolListener(toggleHandToolButton) {
+            var isHandToolActive = false;
+            this.eventBus.on('handtoolchanged', function (e) {
+              if (isHandToolActive === e.isActive) {
+                return;
+              }
+              isHandToolActive = e.isActive;
+              if (isHandToolActive) {
+                toggleHandToolButton.title = mozL10n.get('hand_tool_disable.title', null, 'Disable hand tool');
+                toggleHandToolButton.firstElementChild.textContent = mozL10n.get('hand_tool_disable_label', null, 'Disable hand tool');
+              } else {
+                toggleHandToolButton.title = mozL10n.get('hand_tool_enable.title', null, 'Enable hand tool');
+                toggleHandToolButton.firstElementChild.textContent = mozL10n.get('hand_tool_enable_label', null, 'Enable hand tool');
+              }
+            }.bind(this));
+          },
+          open: function SecondaryToolbar_open() {
+            if (this.opened) {
+              return;
+            }
+            this.opened = true;
+            this._setMaxHeight();
+            this.toggleButton.classList.add('toggled');
+            this.toolbar.classList.remove('hidden');
+          },
+          close: function SecondaryToolbar_close() {
+            if (!this.opened) {
+              return;
+            }
+            this.opened = false;
+            this.toolbar.classList.add('hidden');
+            this.toggleButton.classList.remove('toggled');
+          },
+          toggle: function SecondaryToolbar_toggle() {
+            if (this.opened) {
+              this.close();
+            } else {
+              this.open();
+            }
+          },
+          /**
+           * @private
+           */
+          _setMaxHeight: function SecondaryToolbar_setMaxHeight() {
+            if (!this.opened) {
+              return;
+            }
+            // Only adjust the 'max-height' if the toolbar is visible.
+            this.containerHeight = this.mainContainer.clientHeight;
+            if (this.containerHeight === this.previousContainerHeight) {
+              return;
+            }
+            this.toolbarButtonContainer.setAttribute('style', 'max-height: ' + (this.containerHeight - SCROLLBAR_PADDING) + 'px;');
+            this.previousContainerHeight = this.containerHeight;
+          }
+        };
+        return SecondaryToolbar;
+      }();
+      exports.SecondaryToolbar = SecondaryToolbar;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFFindBar = {}, root.pdfjsWebUIUtils, root.pdfjsWebPDFFindController);
+    }(this, function (exports, uiUtils, pdfFindController) {
+      var mozL10n = uiUtils.mozL10n;
+      var FindStates = pdfFindController.FindStates;
+      /**
+       * Creates a "search bar" given a set of DOM elements that act as controls
+       * for searching or for setting search preferences in the UI. This object
+       * also sets up the appropriate events for the controls. Actual searching
+       * is done by PDFFindController.
+       */
+      var PDFFindBar = function PDFFindBarClosure() {
+        function PDFFindBar(options) {
+          this.opened = false;
+          this.bar = options.bar || null;
+          this.toggleButton = options.toggleButton || null;
+          this.findField = options.findField || null;
+          this.highlightAll = options.highlightAllCheckbox || null;
+          this.caseSensitive = options.caseSensitiveCheckbox || null;
+          this.findMsg = options.findMsg || null;
+          this.findResultsCount = options.findResultsCount || null;
+          this.findStatusIcon = options.findStatusIcon || null;
+          this.findPreviousButton = options.findPreviousButton || null;
+          this.findNextButton = options.findNextButton || null;
+          this.findController = options.findController || null;
+          this.eventBus = options.eventBus;
+          if (this.findController === null) {
+            throw new Error('PDFFindBar cannot be used without a ' + 'PDFFindController instance.');
+          }
+          // Add event listeners to the DOM elements.
+          var self = this;
+          this.toggleButton.addEventListener('click', function () {
+            self.toggle();
+          });
+          this.findField.addEventListener('input', function () {
+            self.dispatchEvent('');
+          });
+          this.bar.addEventListener('keydown', function (evt) {
+            switch (evt.keyCode) {
+            case 13:
+              // Enter
+              if (evt.target === self.findField) {
+                self.dispatchEvent('again', evt.shiftKey);
+              }
+              break;
+            case 27:
+              // Escape
+              self.close();
+              break;
+            }
+          });
+          this.findPreviousButton.addEventListener('click', function () {
+            self.dispatchEvent('again', true);
+          });
+          this.findNextButton.addEventListener('click', function () {
+            self.dispatchEvent('again', false);
+          });
+          this.highlightAll.addEventListener('click', function () {
+            self.dispatchEvent('highlightallchange');
+          });
+          this.caseSensitive.addEventListener('click', function () {
+            self.dispatchEvent('casesensitivitychange');
+          });
+        }
+        PDFFindBar.prototype = {
+          reset: function PDFFindBar_reset() {
+            this.updateUIState();
+          },
+          dispatchEvent: function PDFFindBar_dispatchEvent(type, findPrev) {
+            this.eventBus.dispatch('find', {
+              source: this,
+              type: type,
+              query: this.findField.value,
+              caseSensitive: this.caseSensitive.checked,
+              phraseSearch: true,
+              highlightAll: this.highlightAll.checked,
+              findPrevious: findPrev
+            });
+          },
+          updateUIState: function PDFFindBar_updateUIState(state, previous, matchCount) {
+            var notFound = false;
+            var findMsg = '';
+            var status = '';
+            switch (state) {
+            case FindStates.FIND_FOUND:
+              break;
+            case FindStates.FIND_PENDING:
+              status = 'pending';
+              break;
+            case FindStates.FIND_NOTFOUND:
+              findMsg = mozL10n.get('find_not_found', null, 'Phrase not found');
+              notFound = true;
+              break;
+            case FindStates.FIND_WRAPPED:
+              if (previous) {
+                findMsg = mozL10n.get('find_reached_top', null, 'Reached top of document, continued from bottom');
+              } else {
+                findMsg = mozL10n.get('find_reached_bottom', null, 'Reached end of document, continued from top');
+              }
+              break;
+            }
+            if (notFound) {
+              this.findField.classList.add('notFound');
+            } else {
+              this.findField.classList.remove('notFound');
+            }
+            this.findField.setAttribute('data-status', status);
+            this.findMsg.textContent = findMsg;
+            this.updateResultsCount(matchCount);
+          },
+          updateResultsCount: function (matchCount) {
+            if (!this.findResultsCount) {
+              return;
+            }
+            // no UI control is provided
+            // If there are no matches, hide the counter
+            if (!matchCount) {
+              this.findResultsCount.classList.add('hidden');
+              return;
+            }
+            // Create the match counter
+            this.findResultsCount.textContent = matchCount.toLocaleString();
+            // Show the counter
+            this.findResultsCount.classList.remove('hidden');
+          },
+          open: function PDFFindBar_open() {
+            if (!this.opened) {
+              this.opened = true;
+              this.toggleButton.classList.add('toggled');
+              this.bar.classList.remove('hidden');
+            }
+            this.findField.select();
+            this.findField.focus();
+          },
+          close: function PDFFindBar_close() {
+            if (!this.opened) {
+              return;
+            }
+            this.opened = false;
+            this.toggleButton.classList.remove('toggled');
+            this.bar.classList.add('hidden');
+            this.findController.active = false;
+          },
+          toggle: function PDFFindBar_toggle() {
+            if (this.opened) {
+              this.close();
+            } else {
+              this.open();
+            }
+          }
+        };
+        return PDFFindBar;
+      }();
+      exports.PDFFindBar = PDFFindBar;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFHistory = {}, root.pdfjsWebDOMEvents);
+    }(this, function (exports, domEvents) {
+      function PDFHistory(options) {
+        this.linkService = options.linkService;
+        this.eventBus = options.eventBus || domEvents.getGlobalEventBus();
+        this.initialized = false;
+        this.initialDestination = null;
+        this.initialBookmark = null;
+      }
+      PDFHistory.prototype = {
+        /**
+         * @param {string} fingerprint
+         */
+        initialize: function pdfHistoryInitialize(fingerprint) {
+          this.initialized = true;
+          this.reInitialized = false;
+          this.allowHashChange = true;
+          this.historyUnlocked = true;
+          this.isViewerInPresentationMode = false;
+          this.previousHash = window.location.hash.substring(1);
+          this.currentBookmark = '';
+          this.currentPage = 0;
+          this.updatePreviousBookmark = false;
+          this.previousBookmark = '';
+          this.previousPage = 0;
+          this.nextHashParam = '';
+          this.fingerprint = fingerprint;
+          this.currentUid = this.uid = 0;
+          this.current = {};
+          var state = window.history.state;
+          if (this._isStateObjectDefined(state)) {
+            // This corresponds to navigating back to the document
+            // from another page in the browser history.
+            if (state.target.dest) {
+              this.initialDestination = state.target.dest;
+            } else {
+              this.initialBookmark = state.target.hash;
+            }
+            this.currentUid = state.uid;
+            this.uid = state.uid + 1;
+            this.current = state.target;
+          } else {
+            // This corresponds to the loading of a new document.
+            if (state && state.fingerprint && this.fingerprint !== state.fingerprint) {
+              // Reinitialize the browsing history when a new document
+              // is opened in the web viewer.
+              this.reInitialized = true;
+            }
+            this._pushOrReplaceState({ fingerprint: this.fingerprint }, true);
+          }
+          var self = this;
+          window.addEventListener('popstate', function pdfHistoryPopstate(evt) {
+            if (!self.historyUnlocked) {
+              return;
+            }
+            if (evt.state) {
+              // Move back/forward in the history.
+              self._goTo(evt.state);
+              return;
+            }
+            // If the state is not set, then the user tried to navigate to a
+            // different hash by manually editing the URL and pressing Enter, or by
+            // clicking on an in-page link (e.g. the "current view" link).
+            // Save the current view state to the browser history.
+            // Note: In Firefox, history.null could also be null after an in-page
+            // navigation to the same URL, and without dispatching the popstate
+            // event: https://bugzilla.mozilla.org/show_bug.cgi?id=1183881
+            if (self.uid === 0) {
+              // Replace the previous state if it was not explicitly set.
+              var previousParams = self.previousHash && self.currentBookmark && self.previousHash !== self.currentBookmark ? {
+                hash: self.currentBookmark,
+                page: self.currentPage
+              } : { page: 1 };
+              replacePreviousHistoryState(previousParams, function () {
+                updateHistoryWithCurrentHash();
+              });
+            } else {
+              updateHistoryWithCurrentHash();
+            }
+          }, false);
+          function updateHistoryWithCurrentHash() {
+            self.previousHash = window.location.hash.slice(1);
+            self._pushToHistory({ hash: self.previousHash }, false, true);
+            self._updatePreviousBookmark();
+          }
+          function replacePreviousHistoryState(params, callback) {
+            // To modify the previous history entry, the following happens:
+            // 1. history.back()
+            // 2. _pushToHistory, which calls history.replaceState( ... )
+            // 3. history.forward()
+            // Because a navigation via the history API does not immediately update
+            // the history state, the popstate event is used for synchronization.
+            self.historyUnlocked = false;
+            // Suppress the hashchange event to avoid side effects caused by
+            // navigating back and forward.
+            self.allowHashChange = false;
+            window.addEventListener('popstate', rewriteHistoryAfterBack);
+            history.back();
+            function rewriteHistoryAfterBack() {
+              window.removeEventListener('popstate', rewriteHistoryAfterBack);
+              window.addEventListener('popstate', rewriteHistoryAfterForward);
+              self._pushToHistory(params, false, true);
+              history.forward();
+            }
+            function rewriteHistoryAfterForward() {
+              window.removeEventListener('popstate', rewriteHistoryAfterForward);
+              self.allowHashChange = true;
+              self.historyUnlocked = true;
+              callback();
+            }
+          }
+          function pdfHistoryBeforeUnload() {
+            var previousParams = self._getPreviousParams(null, true);
+            if (previousParams) {
+              var replacePrevious = !self.current.dest && self.current.hash !== self.previousHash;
+              self._pushToHistory(previousParams, false, replacePrevious);
+              self._updatePreviousBookmark();
+            }
+            // Remove the event listener when navigating away from the document,
+            // since 'beforeunload' prevents Firefox from caching the document.
+            window.removeEventListener('beforeunload', pdfHistoryBeforeUnload, false);
+          }
+          window.addEventListener('beforeunload', pdfHistoryBeforeUnload, false);
+          window.addEventListener('pageshow', function pdfHistoryPageShow(evt) {
+            // If the entire viewer (including the PDF file) is cached in
+            // the browser, we need to reattach the 'beforeunload' event listener
+            // since the 'DOMContentLoaded' event is not fired on 'pageshow'.
+            window.addEventListener('beforeunload', pdfHistoryBeforeUnload, false);
+          }, false);
+          self.eventBus.on('presentationmodechanged', function (e) {
+            self.isViewerInPresentationMode = e.active;
+          });
+        },
+        clearHistoryState: function pdfHistory_clearHistoryState() {
+          this._pushOrReplaceState(null, true);
+        },
+        _isStateObjectDefined: function pdfHistory_isStateObjectDefined(state) {
+          return state && state.uid >= 0 && state.fingerprint && this.fingerprint === state.fingerprint && state.target && state.target.hash ? true : false;
+        },
+        _pushOrReplaceState: function pdfHistory_pushOrReplaceState(stateObj, replace) {
+          if (replace) {
+            window.history.replaceState(stateObj, '');
+          } else {
+            window.history.pushState(stateObj, '');
+          }
+        },
+        get isHashChangeUnlocked() {
+          if (!this.initialized) {
+            return true;
+          }
+          return this.allowHashChange;
+        },
+        _updatePreviousBookmark: function pdfHistory_updatePreviousBookmark() {
+          if (this.updatePreviousBookmark && this.currentBookmark && this.currentPage) {
+            this.previousBookmark = this.currentBookmark;
+            this.previousPage = this.currentPage;
+            this.updatePreviousBookmark = false;
+          }
+        },
+        updateCurrentBookmark: function pdfHistoryUpdateCurrentBookmark(bookmark, pageNum) {
+          if (this.initialized) {
+            this.currentBookmark = bookmark.substring(1);
+            this.currentPage = pageNum | 0;
+            this._updatePreviousBookmark();
+          }
+        },
+        updateNextHashParam: function pdfHistoryUpdateNextHashParam(param) {
+          if (this.initialized) {
+            this.nextHashParam = param;
+          }
+        },
+        push: function pdfHistoryPush(params, isInitialBookmark) {
+          if (!(this.initialized && this.historyUnlocked)) {
+            return;
+          }
+          if (params.dest && !params.hash) {
+            params.hash = this.current.hash && this.current.dest && this.current.dest === params.dest ? this.current.hash : this.linkService.getDestinationHash(params.dest).split('#')[1];
+          }
+          if (params.page) {
+            params.page |= 0;
+          }
+          if (isInitialBookmark) {
+            var target = window.history.state.target;
+            if (!target) {
+              // Invoked when the user specifies an initial bookmark,
+              // thus setting initialBookmark, when the document is loaded.
+              this._pushToHistory(params, false);
+              this.previousHash = window.location.hash.substring(1);
+            }
+            this.updatePreviousBookmark = this.nextHashParam ? false : true;
+            if (target) {
+              // If the current document is reloaded,
+              // avoid creating duplicate entries in the history.
+              this._updatePreviousBookmark();
+            }
+            return;
+          }
+          if (this.nextHashParam) {
+            if (this.nextHashParam === params.hash) {
+              this.nextHashParam = null;
+              this.updatePreviousBookmark = true;
+              return;
+            } else {
+              this.nextHashParam = null;
+            }
+          }
+          if (params.hash) {
+            if (this.current.hash) {
+              if (this.current.hash !== params.hash) {
+                this._pushToHistory(params, true);
+              } else {
+                if (!this.current.page && params.page) {
+                  this._pushToHistory(params, false, true);
+                }
+                this.updatePreviousBookmark = true;
+              }
+            } else {
+              this._pushToHistory(params, true);
+            }
+          } else if (this.current.page && params.page && this.current.page !== params.page) {
+            this._pushToHistory(params, true);
+          }
+        },
+        _getPreviousParams: function pdfHistory_getPreviousParams(onlyCheckPage, beforeUnload) {
+          if (!(this.currentBookmark && this.currentPage)) {
+            return null;
+          } else if (this.updatePreviousBookmark) {
+            this.updatePreviousBookmark = false;
+          }
+          if (this.uid > 0 && !(this.previousBookmark && this.previousPage)) {
+            // Prevent the history from getting stuck in the current state,
+            // effectively preventing the user from going back/forward in
+            // the history.
+            //
+            // This happens if the current position in the document didn't change
+            // when the history was previously updated. The reasons for this are
+            // either:
+            // 1. The current zoom value is such that the document does not need to,
+            //    or cannot, be scrolled to display the destination.
+            // 2. The previous destination is broken, and doesn't actally point to a
+            //    position within the document.
+            //    (This is either due to a bad PDF generator, or the user making a
+            //     mistake when entering a destination in the hash parameters.)
+            return null;
+          }
+          if (!this.current.dest && !onlyCheckPage || beforeUnload) {
+            if (this.previousBookmark === this.currentBookmark) {
+              return null;
+            }
+          } else if (this.current.page || onlyCheckPage) {
+            if (this.previousPage === this.currentPage) {
+              return null;
+            }
+          } else {
+            return null;
+          }
+          var params = {
+            hash: this.currentBookmark,
+            page: this.currentPage
+          };
+          if (this.isViewerInPresentationMode) {
+            params.hash = null;
+          }
+          return params;
+        },
+        _stateObj: function pdfHistory_stateObj(params) {
+          return {
+            fingerprint: this.fingerprint,
+            uid: this.uid,
+            target: params
+          };
+        },
+        _pushToHistory: function pdfHistory_pushToHistory(params, addPrevious, overwrite) {
+          if (!this.initialized) {
+            return;
+          }
+          if (!params.hash && params.page) {
+            params.hash = 'page=' + params.page;
+          }
+          if (addPrevious && !overwrite) {
+            var previousParams = this._getPreviousParams();
+            if (previousParams) {
+              var replacePrevious = !this.current.dest && this.current.hash !== this.previousHash;
+              this._pushToHistory(previousParams, false, replacePrevious);
+            }
+          }
+          this._pushOrReplaceState(this._stateObj(params), overwrite || this.uid === 0);
+          this.currentUid = this.uid++;
+          this.current = params;
+          this.updatePreviousBookmark = true;
+        },
+        _goTo: function pdfHistory_goTo(state) {
+          if (!(this.initialized && this.historyUnlocked && this._isStateObjectDefined(state))) {
+            return;
+          }
+          if (!this.reInitialized && state.uid < this.currentUid) {
+            var previousParams = this._getPreviousParams(true);
+            if (previousParams) {
+              this._pushToHistory(this.current, false);
+              this._pushToHistory(previousParams, false);
+              this.currentUid = state.uid;
+              window.history.back();
+              return;
+            }
+          }
+          this.historyUnlocked = false;
+          if (state.target.dest) {
+            this.linkService.navigateTo(state.target.dest);
+          } else {
+            this.linkService.setHash(state.target.hash);
+          }
+          this.currentUid = state.uid;
+          if (state.uid > this.uid) {
+            this.uid = state.uid;
+          }
+          this.current = state.target;
+          this.updatePreviousBookmark = true;
+          var currentHash = window.location.hash.substring(1);
+          if (this.previousHash !== currentHash) {
+            this.allowHashChange = false;
+          }
+          this.previousHash = currentHash;
+          this.historyUnlocked = true;
+        },
+        back: function pdfHistoryBack() {
+          this.go(-1);
+        },
+        forward: function pdfHistoryForward() {
+          this.go(1);
+        },
+        go: function pdfHistoryGo(direction) {
+          if (this.initialized && this.historyUnlocked) {
+            var state = window.history.state;
+            if (direction === -1 && state && state.uid > 0) {
+              window.history.back();
+            } else if (direction === 1 && state && state.uid < this.uid - 1) {
+              window.history.forward();
+            }
+          }
+        }
+      };
+      exports.PDFHistory = PDFHistory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFLinkService = {}, root.pdfjsWebUIUtils, root.pdfjsWebDOMEvents);
+    }(this, function (exports, uiUtils, domEvents) {
+      var parseQueryString = uiUtils.parseQueryString;
+      var PageNumberRegExp = /^\d+$/;
+      function isPageNumber(str) {
+        return PageNumberRegExp.test(str);
+      }
+      /**
+       * @typedef {Object} PDFLinkServiceOptions
+       * @property {EventBus} eventBus - The application event bus.
+       */
+      /**
+       * Performs navigation functions inside PDF, such as opening specified page,
+       * or destination.
+       * @class
+       * @implements {IPDFLinkService}
+       */
+      var PDFLinkService = function PDFLinkServiceClosure() {
+        /**
+         * @constructs PDFLinkService
+         * @param {PDFLinkServiceOptions} options
+         */
+        function PDFLinkService(options) {
+          options = options || {};
+          this.eventBus = options.eventBus || domEvents.getGlobalEventBus();
+          this.baseUrl = null;
+          this.pdfDocument = null;
+          this.pdfViewer = null;
+          this.pdfHistory = null;
+          this._pagesRefCache = null;
+        }
+        PDFLinkService.prototype = {
+          setDocument: function PDFLinkService_setDocument(pdfDocument, baseUrl) {
+            this.baseUrl = baseUrl;
+            this.pdfDocument = pdfDocument;
+            this._pagesRefCache = Object.create(null);
+          },
+          setViewer: function PDFLinkService_setViewer(pdfViewer) {
+            this.pdfViewer = pdfViewer;
+          },
+          setHistory: function PDFLinkService_setHistory(pdfHistory) {
+            this.pdfHistory = pdfHistory;
+          },
+          /**
+           * @returns {number}
+           */
+          get pagesCount() {
+            return this.pdfDocument ? this.pdfDocument.numPages : 0;
+          },
+          /**
+           * @returns {number}
+           */
+          get page() {
+            return this.pdfViewer.currentPageNumber;
+          },
+          /**
+           * @param {number} value
+           */
+          set page(value) {
+            this.pdfViewer.currentPageNumber = value;
+          },
+          /**
+           * @param dest - The PDF destination object.
+           */
+          navigateTo: function PDFLinkService_navigateTo(dest) {
+            var destString = '';
+            var self = this;
+            var goToDestination = function (destRef) {
+              // dest array looks like that: <page-ref> </XYZ|/FitXXX> <args..>
+              var pageNumber;
+              if (destRef instanceof Object) {
+                pageNumber = self._cachedPageNumber(destRef);
+              } else if ((destRef | 0) === destRef) {
+                // Integer
+                pageNumber = destRef + 1;
+              } else {
+                console.error('PDFLinkService_navigateTo: "' + destRef + '" is not a valid destination reference.');
+                return;
+              }
+              if (pageNumber) {
+                if (pageNumber < 1 || pageNumber > self.pagesCount) {
+                  console.error('PDFLinkService_navigateTo: "' + pageNumber + '" is a non-existent page number.');
+                  return;
+                }
+                self.pdfViewer.scrollPageIntoView({
+                  pageNumber: pageNumber,
+                  destArray: dest
+                });
+                if (self.pdfHistory) {
+                  // Update the browsing history.
+                  self.pdfHistory.push({
+                    dest: dest,
+                    hash: destString,
+                    page: pageNumber
+                  });
+                }
+              } else {
+                self.pdfDocument.getPageIndex(destRef).then(function (pageIndex) {
+                  self.cachePageRef(pageIndex + 1, destRef);
+                  goToDestination(destRef);
+                }).catch(function () {
+                  console.error('PDFLinkService_navigateTo: "' + destRef + '" is not a valid page reference.');
+                  return;
+                });
+              }
+            };
+            var destinationPromise;
+            if (typeof dest === 'string') {
+              destString = dest;
+              destinationPromise = this.pdfDocument.getDestination(dest);
+            } else {
+              destinationPromise = Promise.resolve(dest);
+            }
+            destinationPromise.then(function (destination) {
+              dest = destination;
+              if (!(destination instanceof Array)) {
+                console.error('PDFLinkService_navigateTo: "' + destination + '" is not a valid destination array.');
+                return;
+              }
+              goToDestination(destination[0]);
+            });
+          },
+          /**
+           * @param dest - The PDF destination object.
+           * @returns {string} The hyperlink to the PDF object.
+           */
+          getDestinationHash: function PDFLinkService_getDestinationHash(dest) {
+            if (typeof dest === 'string') {
+              // In practice, a named destination may contain only a number.
+              // If that happens, use the '#nameddest=' form to avoid the link
+              // redirecting to a page, instead of the correct destination.
+              return this.getAnchorUrl('#' + (isPageNumber(dest) ? 'nameddest=' : '') + escape(dest));
+            }
+            if (dest instanceof Array) {
+              var str = JSON.stringify(dest);
+              return this.getAnchorUrl('#' + escape(str));
+            }
+            return this.getAnchorUrl('');
+          },
+          /**
+           * Prefix the full url on anchor links to make sure that links are resolved
+           * relative to the current URL instead of the one defined in <base href>.
+           * @param {String} anchor The anchor hash, including the #.
+           * @returns {string} The hyperlink to the PDF object.
+           */
+          getAnchorUrl: function PDFLinkService_getAnchorUrl(anchor) {
+            return (this.baseUrl || '') + anchor;
+          },
+          /**
+           * @param {string} hash
+           */
+          setHash: function PDFLinkService_setHash(hash) {
+            var pageNumber, dest;
+            if (hash.indexOf('=') >= 0) {
+              var params = parseQueryString(hash);
+              if ('search' in params) {
+                this.eventBus.dispatch('findfromurlhash', {
+                  source: this,
+                  query: params['search'].replace(/"/g, ''),
+                  phraseSearch: params['phrase'] === 'true'
+                });
+              }
+              // borrowing syntax from "Parameters for Opening PDF Files"
+              if ('nameddest' in params) {
+                if (this.pdfHistory) {
+                  this.pdfHistory.updateNextHashParam(params.nameddest);
+                }
+                this.navigateTo(params.nameddest);
+                return;
+              }
+              if ('page' in params) {
+                pageNumber = params.page | 0 || 1;
+              }
+              if ('zoom' in params) {
+                // Build the destination array.
+                var zoomArgs = params.zoom.split(',');
+                // scale,left,top
+                var zoomArg = zoomArgs[0];
+                var zoomArgNumber = parseFloat(zoomArg);
+                if (zoomArg.indexOf('Fit') === -1) {
+                  // If the zoomArg is a number, it has to get divided by 100. If it's
+                  // a string, it should stay as it is.
+                  dest = [
+                    null,
+                    { name: 'XYZ' },
+                    zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
+                    zoomArgs.length > 2 ? zoomArgs[2] | 0 : null,
+                    zoomArgNumber ? zoomArgNumber / 100 : zoomArg
+                  ];
+                } else {
+                  if (zoomArg === 'Fit' || zoomArg === 'FitB') {
+                    dest = [
+                      null,
+                      { name: zoomArg }
+                    ];
+                  } else if (zoomArg === 'FitH' || zoomArg === 'FitBH' || (zoomArg === 'FitV' || zoomArg === 'FitBV')) {
+                    dest = [
+                      null,
+                      { name: zoomArg },
+                      zoomArgs.length > 1 ? zoomArgs[1] | 0 : null
+                    ];
+                  } else if (zoomArg === 'FitR') {
+                    if (zoomArgs.length !== 5) {
+                      console.error('PDFLinkService_setHash: ' + 'Not enough parameters for \'FitR\'.');
+                    } else {
+                      dest = [
+                        null,
+                        { name: zoomArg },
+                        zoomArgs[1] | 0,
+                        zoomArgs[2] | 0,
+                        zoomArgs[3] | 0,
+                        zoomArgs[4] | 0
+                      ];
+                    }
+                  } else {
+                    console.error('PDFLinkService_setHash: \'' + zoomArg + '\' is not a valid zoom value.');
+                  }
+                }
+              }
+              if (dest) {
+                this.pdfViewer.scrollPageIntoView({
+                  pageNumber: pageNumber || this.page,
+                  destArray: dest,
+                  allowNegativeOffset: true
+                });
+              } else if (pageNumber) {
+                this.page = pageNumber;
+              }
+              // simple page
+              if ('pagemode' in params) {
+                this.eventBus.dispatch('pagemode', {
+                  source: this,
+                  mode: params.pagemode
+                });
+              }
+            } else {
+              dest = unescape(hash);
+              try {
+                dest = JSON.parse(dest);
+                if (!(dest instanceof Array)) {
+                  // Avoid incorrectly rejecting a valid named destination, such as
+                  // e.g. "4.3" or "true", because `JSON.parse` converted its type.
+                  dest = dest.toString();
+                }
+              } catch (ex) {
+              }
+              if (typeof dest === 'string' || isValidExplicitDestination(dest)) {
+                if (this.pdfHistory) {
+                  this.pdfHistory.updateNextHashParam(dest);
+                }
+                this.navigateTo(dest);
+                return;
+              }
+              console.error('PDFLinkService_setHash: \'' + unescape(hash) + '\' is not a valid destination.');
+            }
+          },
+          /**
+           * @param {string} action
+           */
+          executeNamedAction: function PDFLinkService_executeNamedAction(action) {
+            // See PDF reference, table 8.45 - Named action
+            switch (action) {
+            case 'GoBack':
+              if (this.pdfHistory) {
+                this.pdfHistory.back();
+              }
+              break;
+            case 'GoForward':
+              if (this.pdfHistory) {
+                this.pdfHistory.forward();
+              }
+              break;
+            case 'NextPage':
+              if (this.page < this.pagesCount) {
+                this.page++;
+              }
+              break;
+            case 'PrevPage':
+              if (this.page > 1) {
+                this.page--;
+              }
+              break;
+            case 'LastPage':
+              this.page = this.pagesCount;
+              break;
+            case 'FirstPage':
+              this.page = 1;
+              break;
+            default:
+              break;
+            }
+            // No action according to spec
+            this.eventBus.dispatch('namedaction', {
+              source: this,
+              action: action
+            });
+          },
+          /**
+           * @param {number} pageNum - page number.
+           * @param {Object} pageRef - reference to the page.
+           */
+          cachePageRef: function PDFLinkService_cachePageRef(pageNum, pageRef) {
+            var refStr = pageRef.num + ' ' + pageRef.gen + ' R';
+            this._pagesRefCache[refStr] = pageNum;
+          },
+          _cachedPageNumber: function PDFLinkService_cachedPageNumber(pageRef) {
+            var refStr = pageRef.num + ' ' + pageRef.gen + ' R';
+            return this._pagesRefCache && this._pagesRefCache[refStr] || null;
+          }
+        };
+        function isValidExplicitDestination(dest) {
+          if (!(dest instanceof Array)) {
+            return false;
+          }
+          var destLength = dest.length, allowNull = true;
+          if (destLength < 2) {
+            return false;
+          }
+          var page = dest[0];
+          if (!(typeof page === 'object' && typeof page.num === 'number' && (page.num | 0) === page.num && typeof page.gen === 'number' && (page.gen | 0) === page.gen) && !(typeof page === 'number' && (page | 0) === page && page >= 0)) {
+            return false;
+          }
+          var zoom = dest[1];
+          if (!(typeof zoom === 'object' && typeof zoom.name === 'string')) {
+            return false;
+          }
+          switch (zoom.name) {
+          case 'XYZ':
+            if (destLength !== 5) {
+              return false;
+            }
+            break;
+          case 'Fit':
+          case 'FitB':
+            return destLength === 2;
+          case 'FitH':
+          case 'FitBH':
+          case 'FitV':
+          case 'FitBV':
+            if (destLength !== 3) {
+              return false;
+            }
+            break;
+          case 'FitR':
+            if (destLength !== 6) {
+              return false;
+            }
+            allowNull = false;
+            break;
+          default:
+            return false;
+          }
+          for (var i = 2; i < destLength; i++) {
+            var param = dest[i];
+            if (!(typeof param === 'number' || allowNull && param === null)) {
+              return false;
+            }
+          }
+          return true;
+        }
+        return PDFLinkService;
+      }();
+      var SimpleLinkService = function SimpleLinkServiceClosure() {
+        function SimpleLinkService() {
+        }
+        SimpleLinkService.prototype = {
+          /**
+           * @returns {number}
+           */
+          get page() {
+            return 0;
+          },
+          /**
+           * @param {number} value
+           */
+          set page(value) {
+          },
+          /**
+           * @param dest - The PDF destination object.
+           */
+          navigateTo: function (dest) {
+          },
+          /**
+           * @param dest - The PDF destination object.
+           * @returns {string} The hyperlink to the PDF object.
+           */
+          getDestinationHash: function (dest) {
+            return '#';
+          },
+          /**
+           * @param hash - The PDF parameters/hash.
+           * @returns {string} The hyperlink to the PDF object.
+           */
+          getAnchorUrl: function (hash) {
+            return '#';
+          },
+          /**
+           * @param {string} hash
+           */
+          setHash: function (hash) {
+          },
+          /**
+           * @param {string} action
+           */
+          executeNamedAction: function (action) {
+          },
+          /**
+           * @param {number} pageNum - page number.
+           * @param {Object} pageRef - reference to the page.
+           */
+          cachePageRef: function (pageNum, pageRef) {
+          }
+        };
+        return SimpleLinkService;
+      }();
+      exports.PDFLinkService = PDFLinkService;
+      exports.SimpleLinkService = SimpleLinkService;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFPageView = {}, root.pdfjsWebUIUtils, root.pdfjsWebPDFRenderingQueue, root.pdfjsWebDOMEvents, root.pdfjsWebPDFJS);
+    }(this, function (exports, uiUtils, pdfRenderingQueue, domEvents, pdfjsLib) {
+      var CSS_UNITS = uiUtils.CSS_UNITS;
+      var DEFAULT_SCALE = uiUtils.DEFAULT_SCALE;
+      var getOutputScale = uiUtils.getOutputScale;
+      var approximateFraction = uiUtils.approximateFraction;
+      var roundToDivide = uiUtils.roundToDivide;
+      var RenderingStates = pdfRenderingQueue.RenderingStates;
+      var TEXT_LAYER_RENDER_DELAY = 200;
+      // ms
+      /**
+       * @typedef {Object} PDFPageViewOptions
+       * @property {HTMLDivElement} container - The viewer element.
+       * @property {EventBus} eventBus - The application event bus.
+       * @property {number} id - The page unique ID (normally its number).
+       * @property {number} scale - The page scale display.
+       * @property {PageViewport} defaultViewport - The page viewport.
+       * @property {PDFRenderingQueue} renderingQueue - The rendering queue object.
+       * @property {IPDFTextLayerFactory} textLayerFactory
+       * @property {IPDFAnnotationLayerFactory} annotationLayerFactory
+       * @property {boolean} enhanceTextSelection - Turns on the text selection
+       *   enhancement. The default is `false`.
+       * @property {boolean} renderInteractiveForms - Turns on rendering of
+       *   interactive form elements. The default is `false`.
+       */
+      /**
+       * @class
+       * @implements {IRenderableView}
+       */
+      var PDFPageView = function PDFPageViewClosure() {
+        /**
+         * @constructs PDFPageView
+         * @param {PDFPageViewOptions} options
+         */
+        function PDFPageView(options) {
+          var container = options.container;
+          var id = options.id;
+          var scale = options.scale;
+          var defaultViewport = options.defaultViewport;
+          var renderingQueue = options.renderingQueue;
+          var textLayerFactory = options.textLayerFactory;
+          var annotationLayerFactory = options.annotationLayerFactory;
+          var enhanceTextSelection = options.enhanceTextSelection || false;
+          var renderInteractiveForms = options.renderInteractiveForms || false;
+          this.id = id;
+          this.renderingId = 'page' + id;
+          this.pageLabel = null;
+          this.rotation = 0;
+          this.scale = scale || DEFAULT_SCALE;
+          this.viewport = defaultViewport;
+          this.pdfPageRotate = defaultViewport.rotation;
+          this.hasRestrictedScaling = false;
+          this.enhanceTextSelection = enhanceTextSelection;
+          this.renderInteractiveForms = renderInteractiveForms;
+          this.eventBus = options.eventBus || domEvents.getGlobalEventBus();
+          this.renderingQueue = renderingQueue;
+          this.textLayerFactory = textLayerFactory;
+          this.annotationLayerFactory = annotationLayerFactory;
+          this.renderTask = null;
+          this.renderingState = RenderingStates.INITIAL;
+          this.resume = null;
+          this.onBeforeDraw = null;
+          this.onAfterDraw = null;
+          this.textLayer = null;
+          this.zoomLayer = null;
+          this.annotationLayer = null;
+          var div = document.createElement('div');
+          div.id = 'pageContainer' + this.id;
+          div.className = 'page';
+          div.style.width = Math.floor(this.viewport.width) + 'px';
+          div.style.height = Math.floor(this.viewport.height) + 'px';
+          div.setAttribute('data-page-number', this.id);
+          this.div = div;
+          container.appendChild(div);
+        }
+        PDFPageView.prototype = {
+          setPdfPage: function PDFPageView_setPdfPage(pdfPage) {
+            this.pdfPage = pdfPage;
+            this.pdfPageRotate = pdfPage.rotate;
+            var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+            this.viewport = pdfPage.getViewport(this.scale * CSS_UNITS, totalRotation);
+            this.stats = pdfPage.stats;
+            this.reset();
+          },
+          destroy: function PDFPageView_destroy() {
+            this.zoomLayer = null;
+            this.reset();
+            if (this.pdfPage) {
+              this.pdfPage.cleanup();
+            }
+          },
+          reset: function PDFPageView_reset(keepZoomLayer, keepAnnotations) {
+            this.cancelRendering();
+            var div = this.div;
+            div.style.width = Math.floor(this.viewport.width) + 'px';
+            div.style.height = Math.floor(this.viewport.height) + 'px';
+            var childNodes = div.childNodes;
+            var currentZoomLayerNode = keepZoomLayer && this.zoomLayer || null;
+            var currentAnnotationNode = keepAnnotations && this.annotationLayer && this.annotationLayer.div || null;
+            for (var i = childNodes.length - 1; i >= 0; i--) {
+              var node = childNodes[i];
+              if (currentZoomLayerNode === node || currentAnnotationNode === node) {
+                continue;
+              }
+              div.removeChild(node);
+            }
+            div.removeAttribute('data-loaded');
+            if (currentAnnotationNode) {
+              // Hide annotationLayer until all elements are resized
+              // so they are not displayed on the already-resized page
+              this.annotationLayer.hide();
+            } else {
+              this.annotationLayer = null;
+            }
+            if (this.canvas && !currentZoomLayerNode) {
+              // Zeroing the width and height causes Firefox to release graphics
+              // resources immediately, which can greatly reduce memory consumption.
+              this.canvas.width = 0;
+              this.canvas.height = 0;
+              delete this.canvas;
+            }
+            this.loadingIconDiv = document.createElement('div');
+            this.loadingIconDiv.className = 'loadingIcon';
+            div.appendChild(this.loadingIconDiv);
+          },
+          update: function PDFPageView_update(scale, rotation) {
+            this.scale = scale || this.scale;
+            if (typeof rotation !== 'undefined') {
+              this.rotation = rotation;
+            }
+            var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
+            this.viewport = this.viewport.clone({
+              scale: this.scale * CSS_UNITS,
+              rotation: totalRotation
+            });
+            var isScalingRestricted = false;
+            if (this.canvas && pdfjsLib.PDFJS.maxCanvasPixels > 0) {
+              var outputScale = this.outputScale;
+              if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math.floor(this.viewport.height) * outputScale.sy | 0) > pdfjsLib.PDFJS.maxCanvasPixels) {
+                isScalingRestricted = true;
+              }
+            }
+            if (this.canvas) {
+              if (pdfjsLib.PDFJS.useOnlyCssZoom || this.hasRestrictedScaling && isScalingRestricted) {
+                this.cssTransform(this.canvas, true);
+                this.eventBus.dispatch('pagerendered', {
+                  source: this,
+                  pageNumber: this.id,
+                  cssTransform: true
+                });
+                return;
+              }
+              if (!this.zoomLayer) {
+                this.zoomLayer = this.canvas.parentNode;
+                this.zoomLayer.style.position = 'absolute';
+              }
+            }
+            if (this.zoomLayer) {
+              this.cssTransform(this.zoomLayer.firstChild);
+            }
+            this.reset(/* keepZoomLayer = */
+            true, /* keepAnnotations = */
+            true);
+          },
+          cancelRendering: function PDFPageView_cancelRendering() {
+            if (this.renderTask) {
+              this.renderTask.cancel();
+              this.renderTask = null;
+            }
+            this.renderingState = RenderingStates.INITIAL;
+            this.resume = null;
+            if (this.textLayer) {
+              this.textLayer.cancel();
+              this.textLayer = null;
+            }
+          },
+          /**
+           * Called when moved in the parent's container.
+           */
+          updatePosition: function PDFPageView_updatePosition() {
+            if (this.textLayer) {
+              this.textLayer.render(TEXT_LAYER_RENDER_DELAY);
+            }
+          },
+          cssTransform: function PDFPageView_transform(canvas, redrawAnnotations) {
+            var CustomStyle = pdfjsLib.CustomStyle;
+            // Scale canvas, canvas wrapper, and page container.
+            var width = this.viewport.width;
+            var height = this.viewport.height;
+            var div = this.div;
+            canvas.style.width = canvas.parentNode.style.width = div.style.width = Math.floor(width) + 'px';
+            canvas.style.height = canvas.parentNode.style.height = div.style.height = Math.floor(height) + 'px';
+            // The canvas may have been originally rotated, rotate relative to that.
+            var relativeRotation = this.viewport.rotation - canvas._viewport.rotation;
+            var absRotation = Math.abs(relativeRotation);
+            var scaleX = 1, scaleY = 1;
+            if (absRotation === 90 || absRotation === 270) {
+              // Scale x and y because of the rotation.
+              scaleX = height / width;
+              scaleY = width / height;
+            }
+            var cssTransform = 'rotate(' + relativeRotation + 'deg) ' + 'scale(' + scaleX + ',' + scaleY + ')';
+            CustomStyle.setProp('transform', canvas, cssTransform);
+            if (this.textLayer) {
+              // Rotating the text layer is more complicated since the divs inside the
+              // the text layer are rotated.
+              // TODO: This could probably be simplified by drawing the text layer in
+              // one orientation then rotating overall.
+              var textLayerViewport = this.textLayer.viewport;
+              var textRelativeRotation = this.viewport.rotation - textLayerViewport.rotation;
+              var textAbsRotation = Math.abs(textRelativeRotation);
+              var scale = width / textLayerViewport.width;
+              if (textAbsRotation === 90 || textAbsRotation === 270) {
+                scale = width / textLayerViewport.height;
+              }
+              var textLayerDiv = this.textLayer.textLayerDiv;
+              var transX, transY;
+              switch (textAbsRotation) {
+              case 0:
+                transX = transY = 0;
+                break;
+              case 90:
+                transX = 0;
+                transY = '-' + textLayerDiv.style.height;
+                break;
+              case 180:
+                transX = '-' + textLayerDiv.style.width;
+                transY = '-' + textLayerDiv.style.height;
+                break;
+              case 270:
+                transX = '-' + textLayerDiv.style.width;
+                transY = 0;
+                break;
+              default:
+                console.error('Bad rotation value.');
+                break;
+              }
+              CustomStyle.setProp('transform', textLayerDiv, 'rotate(' + textAbsRotation + 'deg) ' + 'scale(' + scale + ', ' + scale + ') ' + 'translate(' + transX + ', ' + transY + ')');
+              CustomStyle.setProp('transformOrigin', textLayerDiv, '0% 0%');
+            }
+            if (redrawAnnotations && this.annotationLayer) {
+              this.annotationLayer.render(this.viewport, 'display');
+            }
+          },
+          get width() {
+            return this.viewport.width;
+          },
+          get height() {
+            return this.viewport.height;
+          },
+          getPagePoint: function PDFPageView_getPagePoint(x, y) {
+            return this.viewport.convertToPdfPoint(x, y);
+          },
+          draw: function PDFPageView_draw() {
+            if (this.renderingState !== RenderingStates.INITIAL) {
+              console.error('Must be in new state before drawing');
+              this.reset();
+            }
+            // Ensure that we reset all state to prevent issues.
+            this.renderingState = RenderingStates.RUNNING;
+            var pdfPage = this.pdfPage;
+            var viewport = this.viewport;
+            var div = this.div;
+            // Wrap the canvas so if it has a css transform for highdpi the overflow
+            // will be hidden in FF.
+            var canvasWrapper = document.createElement('div');
+            canvasWrapper.style.width = div.style.width;
+            canvasWrapper.style.height = div.style.height;
+            canvasWrapper.classList.add('canvasWrapper');
+            var canvas = document.createElement('canvas');
+            canvas.id = 'page' + this.id;
+            // Keep the canvas hidden until the first draw callback, or until drawing
+            // is complete when `!this.renderingQueue`, to prevent black flickering.
+            canvas.setAttribute('hidden', 'hidden');
+            var isCanvasHidden = true;
+            canvasWrapper.appendChild(canvas);
+            if (this.annotationLayer && this.annotationLayer.div) {
+              // annotationLayer needs to stay on top
+              div.insertBefore(canvasWrapper, this.annotationLayer.div);
+            } else {
+              div.appendChild(canvasWrapper);
+            }
+            this.canvas = canvas;
+            canvas.mozOpaque = true;
+            var ctx = canvas.getContext('2d', { alpha: false });
+            var outputScale = getOutputScale(ctx);
+            this.outputScale = outputScale;
+            if (pdfjsLib.PDFJS.useOnlyCssZoom) {
+              var actualSizeViewport = viewport.clone({ scale: CSS_UNITS });
+              // Use a scale that will make the canvas be the original intended size
+              // of the page.
+              outputScale.sx *= actualSizeViewport.width / viewport.width;
+              outputScale.sy *= actualSizeViewport.height / viewport.height;
+              outputScale.scaled = true;
+            }
+            if (pdfjsLib.PDFJS.maxCanvasPixels > 0) {
+              var pixelsInViewport = viewport.width * viewport.height;
+              var maxScale = Math.sqrt(pdfjsLib.PDFJS.maxCanvasPixels / pixelsInViewport);
+              if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
+                outputScale.sx = maxScale;
+                outputScale.sy = maxScale;
+                outputScale.scaled = true;
+                this.hasRestrictedScaling = true;
+              } else {
+                this.hasRestrictedScaling = false;
+              }
+            }
+            var sfx = approximateFraction(outputScale.sx);
+            var sfy = approximateFraction(outputScale.sy);
+            canvas.width = roundToDivide(viewport.width * outputScale.sx, sfx[0]);
+            canvas.height = roundToDivide(viewport.height * outputScale.sy, sfy[0]);
+            canvas.style.width = roundToDivide(viewport.width, sfx[1]) + 'px';
+            canvas.style.height = roundToDivide(viewport.height, sfy[1]) + 'px';
+            // Add the viewport so it's known what it was originally drawn with.
+            canvas._viewport = viewport;
+            var textLayerDiv = null;
+            var textLayer = null;
+            if (this.textLayerFactory) {
+              textLayerDiv = document.createElement('div');
+              textLayerDiv.className = 'textLayer';
+              textLayerDiv.style.width = canvasWrapper.style.width;
+              textLayerDiv.style.height = canvasWrapper.style.height;
+              if (this.annotationLayer && this.annotationLayer.div) {
+                // annotationLayer needs to stay on top
+                div.insertBefore(textLayerDiv, this.annotationLayer.div);
+              } else {
+                div.appendChild(textLayerDiv);
+              }
+              textLayer = this.textLayerFactory.createTextLayerBuilder(textLayerDiv, this.id - 1, this.viewport, this.enhanceTextSelection);
+            }
+            this.textLayer = textLayer;
+            var resolveRenderPromise, rejectRenderPromise;
+            var promise = new Promise(function (resolve, reject) {
+              resolveRenderPromise = resolve;
+              rejectRenderPromise = reject;
+            });
+            // Rendering area
+            var self = this;
+            function pageViewDrawCallback(error) {
+              // The renderTask may have been replaced by a new one, so only remove
+              // the reference to the renderTask if it matches the one that is
+              // triggering this callback.
+              if (renderTask === self.renderTask) {
+                self.renderTask = null;
+              }
+              if (error === 'cancelled') {
+                rejectRenderPromise(error);
+                return;
+              }
+              self.renderingState = RenderingStates.FINISHED;
+              if (isCanvasHidden) {
+                self.canvas.removeAttribute('hidden');
+                isCanvasHidden = false;
+              }
+              if (self.loadingIconDiv) {
+                div.removeChild(self.loadingIconDiv);
+                delete self.loadingIconDiv;
+              }
+              if (self.zoomLayer) {
+                // Zeroing the width and height causes Firefox to release graphics
+                // resources immediately, which can greatly reduce memory consumption.
+                var zoomLayerCanvas = self.zoomLayer.firstChild;
+                zoomLayerCanvas.width = 0;
+                zoomLayerCanvas.height = 0;
+                if (div.contains(self.zoomLayer)) {
+                  // Prevent "Node was not found" errors if the `zoomLayer` was
+                  // already removed. This may occur intermittently if the scale
+                  // changes many times in very quick succession.
+                  div.removeChild(self.zoomLayer);
+                }
+                self.zoomLayer = null;
+              }
+              self.error = error;
+              self.stats = pdfPage.stats;
+              if (self.onAfterDraw) {
+                self.onAfterDraw();
+              }
+              self.eventBus.dispatch('pagerendered', {
+                source: self,
+                pageNumber: self.id,
+                cssTransform: false
+              });
+              if (!error) {
+                resolveRenderPromise(undefined);
+              } else {
+                rejectRenderPromise(error);
+              }
+            }
+            var renderContinueCallback = null;
+            if (this.renderingQueue) {
+              renderContinueCallback = function renderContinueCallback(cont) {
+                if (!self.renderingQueue.isHighestPriority(self)) {
+                  self.renderingState = RenderingStates.PAUSED;
+                  self.resume = function resumeCallback() {
+                    self.renderingState = RenderingStates.RUNNING;
+                    cont();
+                  };
+                  return;
+                }
+                if (isCanvasHidden) {
+                  self.canvas.removeAttribute('hidden');
+                  isCanvasHidden = false;
+                }
+                cont();
+              };
+            }
+            var transform = !outputScale.scaled ? null : [
+              outputScale.sx,
+              0,
+              0,
+              outputScale.sy,
+              0,
+              0
+            ];
+            var renderContext = {
+              canvasContext: ctx,
+              transform: transform,
+              viewport: this.viewport,
+              renderInteractiveForms: this.renderInteractiveForms
+            };
+            // intent: 'default', // === 'display'
+            var renderTask = this.renderTask = this.pdfPage.render(renderContext);
+            renderTask.onContinue = renderContinueCallback;
+            this.renderTask.promise.then(function pdfPageRenderCallback() {
+              pageViewDrawCallback(null);
+              if (textLayer) {
+                self.pdfPage.getTextContent({ normalizeWhitespace: true }).then(function textContentResolved(textContent) {
+                  textLayer.setTextContent(textContent);
+                  textLayer.render(TEXT_LAYER_RENDER_DELAY);
+                });
+              }
+            }, function pdfPageRenderError(error) {
+              pageViewDrawCallback(error);
+            });
+            if (this.annotationLayerFactory) {
+              if (!this.annotationLayer) {
+                this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(div, this.pdfPage, this.renderInteractiveForms);
+              }
+              this.annotationLayer.render(this.viewport, 'display');
+            }
+            div.setAttribute('data-loaded', true);
+            if (self.onBeforeDraw) {
+              self.onBeforeDraw();
+            }
+            return promise;
+          },
+          /**
+           * @param {string|null} label
+           */
+          setPageLabel: function PDFView_setPageLabel(label) {
+            this.pageLabel = typeof label === 'string' ? label : null;
+            if (this.pageLabel !== null) {
+              this.div.setAttribute('data-page-label', this.pageLabel);
+            } else {
+              this.div.removeAttribute('data-page-label');
+            }
+          }
+        };
+        return PDFPageView;
+      }();
+      exports.PDFPageView = PDFPageView;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFThumbnailViewer = {}, root.pdfjsWebUIUtils, root.pdfjsWebPDFThumbnailView);
+    }(this, function (exports, uiUtils, pdfThumbnailView) {
+      var watchScroll = uiUtils.watchScroll;
+      var getVisibleElements = uiUtils.getVisibleElements;
+      var scrollIntoView = uiUtils.scrollIntoView;
+      var PDFThumbnailView = pdfThumbnailView.PDFThumbnailView;
+      var THUMBNAIL_SCROLL_MARGIN = -19;
+      /**
+       * @typedef {Object} PDFThumbnailViewerOptions
+       * @property {HTMLDivElement} container - The container for the thumbnail
+       *   elements.
+       * @property {IPDFLinkService} linkService - The navigation/linking service.
+       * @property {PDFRenderingQueue} renderingQueue - The rendering queue object.
+       */
+      /**
+       * Simple viewer control to display thumbnails for pages.
+       * @class
+       * @implements {IRenderableView}
+       */
+      var PDFThumbnailViewer = function PDFThumbnailViewerClosure() {
+        /**
+         * @constructs PDFThumbnailViewer
+         * @param {PDFThumbnailViewerOptions} options
+         */
+        function PDFThumbnailViewer(options) {
+          this.container = options.container;
+          this.renderingQueue = options.renderingQueue;
+          this.linkService = options.linkService;
+          this.scroll = watchScroll(this.container, this._scrollUpdated.bind(this));
+          this._resetView();
+        }
+        PDFThumbnailViewer.prototype = {
+          /**
+           * @private
+           */
+          _scrollUpdated: function PDFThumbnailViewer_scrollUpdated() {
+            this.renderingQueue.renderHighestPriority();
+          },
+          getThumbnail: function PDFThumbnailViewer_getThumbnail(index) {
+            return this.thumbnails[index];
+          },
+          /**
+           * @private
+           */
+          _getVisibleThumbs: function PDFThumbnailViewer_getVisibleThumbs() {
+            return getVisibleElements(this.container, this.thumbnails);
+          },
+          scrollThumbnailIntoView: function PDFThumbnailViewer_scrollThumbnailIntoView(page) {
+            var selected = document.querySelector('.thumbnail.selected');
+            if (selected) {
+              selected.classList.remove('selected');
+            }
+            var thumbnail = document.getElementById('thumbnailContainer' + page);
+            if (thumbnail) {
+              thumbnail.classList.add('selected');
+            }
+            var visibleThumbs = this._getVisibleThumbs();
+            var numVisibleThumbs = visibleThumbs.views.length;
+            // If the thumbnail isn't currently visible, scroll it into view.
+            if (numVisibleThumbs > 0) {
+              var first = visibleThumbs.first.id;
+              // Account for only one thumbnail being visible.
+              var last = numVisibleThumbs > 1 ? visibleThumbs.last.id : first;
+              if (page <= first || page >= last) {
+                scrollIntoView(thumbnail, { top: THUMBNAIL_SCROLL_MARGIN });
+              }
+            }
+          },
+          get pagesRotation() {
+            return this._pagesRotation;
+          },
+          set pagesRotation(rotation) {
+            this._pagesRotation = rotation;
+            for (var i = 0, l = this.thumbnails.length; i < l; i++) {
+              var thumb = this.thumbnails[i];
+              thumb.update(rotation);
+            }
+          },
+          cleanup: function PDFThumbnailViewer_cleanup() {
+            var tempCanvas = PDFThumbnailView.tempImageCache;
+            if (tempCanvas) {
+              // Zeroing the width and height causes Firefox to release graphics
+              // resources immediately, which can greatly reduce memory consumption.
+              tempCanvas.width = 0;
+              tempCanvas.height = 0;
+            }
+            PDFThumbnailView.tempImageCache = null;
+          },
+          /**
+           * @private
+           */
+          _resetView: function PDFThumbnailViewer_resetView() {
+            this.thumbnails = [];
+            this._pageLabels = null;
+            this._pagesRotation = 0;
+            this._pagesRequests = [];
+            // Remove the thumbnails from the DOM.
+            this.container.textContent = '';
+          },
+          setDocument: function PDFThumbnailViewer_setDocument(pdfDocument) {
+            if (this.pdfDocument) {
+              this._cancelRendering();
+              this._resetView();
+            }
+            this.pdfDocument = pdfDocument;
+            if (!pdfDocument) {
+              return Promise.resolve();
+            }
+            return pdfDocument.getPage(1).then(function (firstPage) {
+              var pagesCount = pdfDocument.numPages;
+              var viewport = firstPage.getViewport(1.0);
+              for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+                var thumbnail = new PDFThumbnailView({
+                  container: this.container,
+                  id: pageNum,
+                  defaultViewport: viewport.clone(),
+                  linkService: this.linkService,
+                  renderingQueue: this.renderingQueue,
+                  disableCanvasToImageConversion: false
+                });
+                this.thumbnails.push(thumbnail);
+              }
+            }.bind(this));
+          },
+          /**
+           * @private
+           */
+          _cancelRendering: function PDFThumbnailViewer_cancelRendering() {
+            for (var i = 0, ii = this.thumbnails.length; i < ii; i++) {
+              if (this.thumbnails[i]) {
+                this.thumbnails[i].cancelRendering();
+              }
+            }
+          },
+          /**
+           * @param {Array|null} labels
+           */
+          setPageLabels: function PDFThumbnailViewer_setPageLabels(labels) {
+            if (!this.pdfDocument) {
+              return;
+            }
+            if (!labels) {
+              this._pageLabels = null;
+            } else if (!(labels instanceof Array && this.pdfDocument.numPages === labels.length)) {
+              this._pageLabels = null;
+              console.error('PDFThumbnailViewer_setPageLabels: Invalid page labels.');
+            } else {
+              this._pageLabels = labels;
+            }
+            // Update all the `PDFThumbnailView` instances.
+            for (var i = 0, ii = this.thumbnails.length; i < ii; i++) {
+              var thumbnailView = this.thumbnails[i];
+              var label = this._pageLabels && this._pageLabels[i];
+              thumbnailView.setPageLabel(label);
+            }
+          },
+          /**
+           * @param {PDFThumbnailView} thumbView
+           * @returns {PDFPage}
+           * @private
+           */
+          _ensurePdfPageLoaded: function PDFThumbnailViewer_ensurePdfPageLoaded(thumbView) {
+            if (thumbView.pdfPage) {
+              return Promise.resolve(thumbView.pdfPage);
+            }
+            var pageNumber = thumbView.id;
+            if (this._pagesRequests[pageNumber]) {
+              return this._pagesRequests[pageNumber];
+            }
+            var promise = this.pdfDocument.getPage(pageNumber).then(function (pdfPage) {
+              thumbView.setPdfPage(pdfPage);
+              this._pagesRequests[pageNumber] = null;
+              return pdfPage;
+            }.bind(this));
+            this._pagesRequests[pageNumber] = promise;
+            return promise;
+          },
+          forceRendering: function () {
+            var visibleThumbs = this._getVisibleThumbs();
+            var thumbView = this.renderingQueue.getHighestPriority(visibleThumbs, this.thumbnails, this.scroll.down);
+            if (thumbView) {
+              this._ensurePdfPageLoaded(thumbView).then(function () {
+                this.renderingQueue.renderView(thumbView);
+              }.bind(this));
+              return true;
+            }
+            return false;
+          }
+        };
+        return PDFThumbnailViewer;
+      }();
+      exports.PDFThumbnailViewer = PDFThumbnailViewer;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebTextLayerBuilder = {}, root.pdfjsWebDOMEvents, root.pdfjsWebPDFJS);
+    }(this, function (exports, domEvents, pdfjsLib) {
+      var EXPAND_DIVS_TIMEOUT = 300;
+      // ms
+      /**
+       * @typedef {Object} TextLayerBuilderOptions
+       * @property {HTMLDivElement} textLayerDiv - The text layer container.
+       * @property {EventBus} eventBus - The application event bus.
+       * @property {number} pageIndex - The page index.
+       * @property {PageViewport} viewport - The viewport of the text layer.
+       * @property {PDFFindController} findController
+       * @property {boolean} enhanceTextSelection - Option to turn on improved
+       *   text selection.
+       */
+      /**
+       * TextLayerBuilder provides text-selection functionality for the PDF.
+       * It does this by creating overlay divs over the PDF text. These divs
+       * contain text that matches the PDF text they are overlaying. This object
+       * also provides a way to highlight text that is being searched for.
+       * @class
+       */
+      var TextLayerBuilder = function TextLayerBuilderClosure() {
+        function TextLayerBuilder(options) {
+          this.textLayerDiv = options.textLayerDiv;
+          this.eventBus = options.eventBus || domEvents.getGlobalEventBus();
+          this.textContent = null;
+          this.renderingDone = false;
+          this.pageIdx = options.pageIndex;
+          this.pageNumber = this.pageIdx + 1;
+          this.matches = [];
+          this.viewport = options.viewport;
+          this.textDivs = [];
+          this.findController = options.findController || null;
+          this.textLayerRenderTask = null;
+          this.enhanceTextSelection = options.enhanceTextSelection;
+          this._bindMouse();
+        }
+        TextLayerBuilder.prototype = {
+          /**
+           * @private
+           */
+          _finishRendering: function TextLayerBuilder_finishRendering() {
+            this.renderingDone = true;
+            if (!this.enhanceTextSelection) {
+              var endOfContent = document.createElement('div');
+              endOfContent.className = 'endOfContent';
+              this.textLayerDiv.appendChild(endOfContent);
+            }
+            this.eventBus.dispatch('textlayerrendered', {
+              source: this,
+              pageNumber: this.pageNumber,
+              numTextDivs: this.textDivs.length
+            });
+          },
+          /**
+           * Renders the text layer.
+           * @param {number} timeout (optional) if specified, the rendering waits
+           *   for specified amount of ms.
+           */
+          render: function TextLayerBuilder_render(timeout) {
+            if (!this.textContent || this.renderingDone) {
+              return;
+            }
+            this.cancel();
+            this.textDivs = [];
+            var textLayerFrag = document.createDocumentFragment();
+            this.textLayerRenderTask = pdfjsLib.renderTextLayer({
+              textContent: this.textContent,
+              container: textLayerFrag,
+              viewport: this.viewport,
+              textDivs: this.textDivs,
+              timeout: timeout,
+              enhanceTextSelection: this.enhanceTextSelection
+            });
+            this.textLayerRenderTask.promise.then(function () {
+              this.textLayerDiv.appendChild(textLayerFrag);
+              this._finishRendering();
+              this.updateMatches();
+            }.bind(this), function (reason) {
+            });
+          },
+          /**
+           * Cancels rendering of the text layer.
+           */
+          cancel: function TextLayerBuilder_cancel() {
+            if (this.textLayerRenderTask) {
+              this.textLayerRenderTask.cancel();
+              this.textLayerRenderTask = null;
+            }
+          },
+          setTextContent: function TextLayerBuilder_setTextContent(textContent) {
+            this.cancel();
+            this.textContent = textContent;
+          },
+          convertMatches: function TextLayerBuilder_convertMatches(matches, matchesLength) {
+            var i = 0;
+            var iIndex = 0;
+            var bidiTexts = this.textContent.items;
+            var end = bidiTexts.length - 1;
+            var queryLen = this.findController === null ? 0 : this.findController.state.query.length;
+            var ret = [];
+            if (!matches) {
+              return ret;
+            }
+            for (var m = 0, len = matches.length; m < len; m++) {
+              // Calculate the start position.
+              var matchIdx = matches[m];
+              // Loop over the divIdxs.
+              while (i !== end && matchIdx >= iIndex + bidiTexts[i].str.length) {
+                iIndex += bidiTexts[i].str.length;
+                i++;
+              }
+              if (i === bidiTexts.length) {
+                console.error('Could not find a matching mapping');
+              }
+              var match = {
+                begin: {
+                  divIdx: i,
+                  offset: matchIdx - iIndex
+                }
+              };
+              // Calculate the end position.
+              if (matchesLength) {
+                // multiterm search
+                matchIdx += matchesLength[m];
+              } else {
+                // phrase search
+                matchIdx += queryLen;
+              }
+              // Somewhat the same array as above, but use > instead of >= to get
+              // the end position right.
+              while (i !== end && matchIdx > iIndex + bidiTexts[i].str.length) {
+                iIndex += bidiTexts[i].str.length;
+                i++;
+              }
+              match.end = {
+                divIdx: i,
+                offset: matchIdx - iIndex
+              };
+              ret.push(match);
+            }
+            return ret;
+          },
+          renderMatches: function TextLayerBuilder_renderMatches(matches) {
+            // Early exit if there is nothing to render.
+            if (matches.length === 0) {
+              return;
+            }
+            var bidiTexts = this.textContent.items;
+            var textDivs = this.textDivs;
+            var prevEnd = null;
+            var pageIdx = this.pageIdx;
+            var isSelectedPage = this.findController === null ? false : pageIdx === this.findController.selected.pageIdx;
+            var selectedMatchIdx = this.findController === null ? -1 : this.findController.selected.matchIdx;
+            var highlightAll = this.findController === null ? false : this.findController.state.highlightAll;
+            var infinity = {
+              divIdx: -1,
+              offset: undefined
+            };
+            function beginText(begin, className) {
+              var divIdx = begin.divIdx;
+              textDivs[divIdx].textContent = '';
+              appendTextToDiv(divIdx, 0, begin.offset, className);
+            }
+            function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
+              var div = textDivs[divIdx];
+              var content = bidiTexts[divIdx].str.substring(fromOffset, toOffset);
+              var node = document.createTextNode(content);
+              if (className) {
+                var span = document.createElement('span');
+                span.className = className;
+                span.appendChild(node);
+                div.appendChild(span);
+                return;
+              }
+              div.appendChild(node);
+            }
+            var i0 = selectedMatchIdx, i1 = i0 + 1;
+            if (highlightAll) {
+              i0 = 0;
+              i1 = matches.length;
+            } else if (!isSelectedPage) {
+              // Not highlighting all and this isn't the selected page, so do nothing.
+              return;
+            }
+            for (var i = i0; i < i1; i++) {
+              var match = matches[i];
+              var begin = match.begin;
+              var end = match.end;
+              var isSelected = isSelectedPage && i === selectedMatchIdx;
+              var highlightSuffix = isSelected ? ' selected' : '';
+              if (this.findController) {
+                this.findController.updateMatchPosition(pageIdx, i, textDivs, begin.divIdx);
+              }
+              // Match inside new div.
+              if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
+                // If there was a previous div, then add the text at the end.
+                if (prevEnd !== null) {
+                  appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+                }
+                // Clear the divs and set the content until the starting point.
+                beginText(begin);
+              } else {
+                appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
+              }
+              if (begin.divIdx === end.divIdx) {
+                appendTextToDiv(begin.divIdx, begin.offset, end.offset, 'highlight' + highlightSuffix);
+              } else {
+                appendTextToDiv(begin.divIdx, begin.offset, infinity.offset, 'highlight begin' + highlightSuffix);
+                for (var n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {
+                  textDivs[n0].className = 'highlight middle' + highlightSuffix;
+                }
+                beginText(end, 'highlight end' + highlightSuffix);
+              }
+              prevEnd = end;
+            }
+            if (prevEnd) {
+              appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
+            }
+          },
+          updateMatches: function TextLayerBuilder_updateMatches() {
+            // Only show matches when all rendering is done.
+            if (!this.renderingDone) {
+              return;
+            }
+            // Clear all matches.
+            var matches = this.matches;
+            var textDivs = this.textDivs;
+            var bidiTexts = this.textContent.items;
+            var clearedUntilDivIdx = -1;
+            // Clear all current matches.
+            for (var i = 0, len = matches.length; i < len; i++) {
+              var match = matches[i];
+              var begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
+              for (var n = begin, end = match.end.divIdx; n <= end; n++) {
+                var div = textDivs[n];
+                div.textContent = bidiTexts[n].str;
+                div.className = '';
+              }
+              clearedUntilDivIdx = match.end.divIdx + 1;
+            }
+            if (this.findController === null || !this.findController.active) {
+              return;
+            }
+            // Convert the matches on the page controller into the match format
+            // used for the textLayer.
+            var pageMatches, pageMatchesLength;
+            if (this.findController !== null) {
+              pageMatches = this.findController.pageMatches[this.pageIdx] || null;
+              pageMatchesLength = this.findController.pageMatchesLength ? this.findController.pageMatchesLength[this.pageIdx] || null : null;
+            }
+            this.matches = this.convertMatches(pageMatches, pageMatchesLength);
+            this.renderMatches(this.matches);
+          },
+          /**
+           * Fixes text selection: adds additional div where mouse was clicked.
+           * This reduces flickering of the content if mouse slowly dragged down/up.
+           * @private
+           */
+          _bindMouse: function TextLayerBuilder_bindMouse() {
+            var div = this.textLayerDiv;
+            var self = this;
+            var expandDivsTimer = null;
+            div.addEventListener('mousedown', function (e) {
+              if (self.enhanceTextSelection && self.textLayerRenderTask) {
+                self.textLayerRenderTask.expandTextDivs(true);
+                return;
+              }
+              var end = div.querySelector('.endOfContent');
+              if (!end) {
+                return;
+              }
+              end.classList.add('active');
+            });
+            div.addEventListener('mouseup', function (e) {
+              if (self.enhanceTextSelection && self.textLayerRenderTask) {
+                self.textLayerRenderTask.expandTextDivs(false);
+                return;
+              }
+              var end = div.querySelector('.endOfContent');
+              if (!end) {
+                return;
+              }
+              end.classList.remove('active');
+            });
+          }
+        };
+        return TextLayerBuilder;
+      }();
+      /**
+       * @constructor
+       * @implements IPDFTextLayerFactory
+       */
+      function DefaultTextLayerFactory() {
+      }
+      DefaultTextLayerFactory.prototype = {
+        /**
+         * @param {HTMLDivElement} textLayerDiv
+         * @param {number} pageIndex
+         * @param {PageViewport} viewport
+         * @param {boolean} enhanceTextSelection
+         * @returns {TextLayerBuilder}
+         */
+        createTextLayerBuilder: function (textLayerDiv, pageIndex, viewport, enhanceTextSelection) {
+          return new TextLayerBuilder({
+            textLayerDiv: textLayerDiv,
+            pageIndex: pageIndex,
+            viewport: viewport,
+            enhanceTextSelection: enhanceTextSelection
+          });
+        }
+      };
+      exports.TextLayerBuilder = TextLayerBuilder;
+      exports.DefaultTextLayerFactory = DefaultTextLayerFactory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebAnnotationLayerBuilder = {}, root.pdfjsWebUIUtils, root.pdfjsWebPDFLinkService, root.pdfjsWebPDFJS);
+    }(this, function (exports, uiUtils, pdfLinkService, pdfjsLib) {
+      var mozL10n = uiUtils.mozL10n;
+      var SimpleLinkService = pdfLinkService.SimpleLinkService;
+      /**
+       * @typedef {Object} AnnotationLayerBuilderOptions
+       * @property {HTMLDivElement} pageDiv
+       * @property {PDFPage} pdfPage
+       * @property {boolean} renderInteractiveForms
+       * @property {IPDFLinkService} linkService
+       * @property {DownloadManager} downloadManager
+       */
+      /**
+       * @class
+       */
+      var AnnotationLayerBuilder = function AnnotationLayerBuilderClosure() {
+        /**
+         * @param {AnnotationLayerBuilderOptions} options
+         * @constructs AnnotationLayerBuilder
+         */
+        function AnnotationLayerBuilder(options) {
+          this.pageDiv = options.pageDiv;
+          this.pdfPage = options.pdfPage;
+          this.renderInteractiveForms = options.renderInteractiveForms;
+          this.linkService = options.linkService;
+          this.downloadManager = options.downloadManager;
+          this.div = null;
+        }
+        AnnotationLayerBuilder.prototype = /** @lends AnnotationLayerBuilder.prototype */
+        {
+          /**
+           * @param {PageViewport} viewport
+           * @param {string} intent (default value is 'display')
+           */
+          render: function AnnotationLayerBuilder_render(viewport, intent) {
+            var self = this;
+            var parameters = { intent: intent === undefined ? 'display' : intent };
+            this.pdfPage.getAnnotations(parameters).then(function (annotations) {
+              viewport = viewport.clone({ dontFlip: true });
+              parameters = {
+                viewport: viewport,
+                div: self.div,
+                annotations: annotations,
+                page: self.pdfPage,
+                renderInteractiveForms: self.renderInteractiveForms,
+                linkService: self.linkService,
+                downloadManager: self.downloadManager
+              };
+              if (self.div) {
+                // If an annotationLayer already exists, refresh its children's
+                // transformation matrices.
+                pdfjsLib.AnnotationLayer.update(parameters);
+              } else {
+                // Create an annotation layer div and render the annotations
+                // if there is at least one annotation.
+                if (annotations.length === 0) {
+                  return;
+                }
+                self.div = document.createElement('div');
+                self.div.className = 'annotationLayer';
+                self.pageDiv.appendChild(self.div);
+                parameters.div = self.div;
+                pdfjsLib.AnnotationLayer.render(parameters);
+                if (typeof mozL10n !== 'undefined') {
+                  mozL10n.translate(self.div);
+                }
+              }
+            });
+          },
+          hide: function AnnotationLayerBuilder_hide() {
+            if (!this.div) {
+              return;
+            }
+            this.div.setAttribute('hidden', 'true');
+          }
+        };
+        return AnnotationLayerBuilder;
+      }();
+      /**
+       * @constructor
+       * @implements IPDFAnnotationLayerFactory
+       */
+      function DefaultAnnotationLayerFactory() {
+      }
+      DefaultAnnotationLayerFactory.prototype = {
+        /**
+         * @param {HTMLDivElement} pageDiv
+         * @param {PDFPage} pdfPage
+         * @param {boolean} renderInteractiveForms
+         * @returns {AnnotationLayerBuilder}
+         */
+        createAnnotationLayerBuilder: function (pageDiv, pdfPage, renderInteractiveForms) {
+          return new AnnotationLayerBuilder({
+            pageDiv: pageDiv,
+            pdfPage: pdfPage,
+            renderInteractiveForms: renderInteractiveForms,
+            linkService: new SimpleLinkService()
+          });
+        }
+      };
+      exports.AnnotationLayerBuilder = AnnotationLayerBuilder;
+      exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebPDFViewer = {}, root.pdfjsWebUIUtils, root.pdfjsWebPDFPageView, root.pdfjsWebPDFRenderingQueue, root.pdfjsWebTextLayerBuilder, root.pdfjsWebAnnotationLayerBuilder, root.pdfjsWebPDFLinkService, root.pdfjsWebDOMEvents, root.pdfjsWebPDFJS);
+    }(this, function (exports, uiUtils, pdfPageView, pdfRenderingQueue, textLayerBuilder, annotationLayerBuilder, pdfLinkService, domEvents, pdfjsLib) {
+      var UNKNOWN_SCALE = uiUtils.UNKNOWN_SCALE;
+      var SCROLLBAR_PADDING = uiUtils.SCROLLBAR_PADDING;
+      var VERTICAL_PADDING = uiUtils.VERTICAL_PADDING;
+      var MAX_AUTO_SCALE = uiUtils.MAX_AUTO_SCALE;
+      var CSS_UNITS = uiUtils.CSS_UNITS;
+      var DEFAULT_SCALE = uiUtils.DEFAULT_SCALE;
+      var DEFAULT_SCALE_VALUE = uiUtils.DEFAULT_SCALE_VALUE;
+      var scrollIntoView = uiUtils.scrollIntoView;
+      var watchScroll = uiUtils.watchScroll;
+      var getVisibleElements = uiUtils.getVisibleElements;
+      var PDFPageView = pdfPageView.PDFPageView;
+      var RenderingStates = pdfRenderingQueue.RenderingStates;
+      var PDFRenderingQueue = pdfRenderingQueue.PDFRenderingQueue;
+      var TextLayerBuilder = textLayerBuilder.TextLayerBuilder;
+      var AnnotationLayerBuilder = annotationLayerBuilder.AnnotationLayerBuilder;
+      var SimpleLinkService = pdfLinkService.SimpleLinkService;
+      var PresentationModeState = {
+        UNKNOWN: 0,
+        NORMAL: 1,
+        CHANGING: 2,
+        FULLSCREEN: 3
+      };
+      var DEFAULT_CACHE_SIZE = 10;
+      /**
+       * @typedef {Object} PDFViewerOptions
+       * @property {HTMLDivElement} container - The container for the viewer element.
+       * @property {HTMLDivElement} viewer - (optional) The viewer element.
+       * @property {EventBus} eventBus - The application event bus.
+       * @property {IPDFLinkService} linkService - The navigation/linking service.
+       * @property {DownloadManager} downloadManager - (optional) The download
+       *   manager component.
+       * @property {PDFRenderingQueue} renderingQueue - (optional) The rendering
+       *   queue object.
+       * @property {boolean} removePageBorders - (optional) Removes the border shadow
+       *   around the pages. The default is false.
+       * @property {boolean} enhanceTextSelection - (optional) Enables the improved
+       *   text selection behaviour. The default is `false`.
+       * @property {boolean} renderInteractiveForms - (optional) Enables rendering of
+       *   interactive form elements. The default is `false`.
+       */
+      /**
+       * Simple viewer control to display PDF content/pages.
+       * @class
+       * @implements {IRenderableView}
+       */
+      var PDFViewer = function pdfViewer() {
+        function PDFPageViewBuffer(size) {
+          var data = [];
+          this.push = function cachePush(view) {
+            var i = data.indexOf(view);
+            if (i >= 0) {
+              data.splice(i, 1);
+            }
+            data.push(view);
+            if (data.length > size) {
+              data.shift().destroy();
+            }
+          };
+          this.resize = function (newSize) {
+            size = newSize;
+            while (data.length > size) {
+              data.shift().destroy();
+            }
+          };
+        }
+        function isSameScale(oldScale, newScale) {
+          if (newScale === oldScale) {
+            return true;
+          }
+          if (Math.abs(newScale - oldScale) < 1e-15) {
+            // Prevent unnecessary re-rendering of all pages when the scale
+            // changes only because of limited numerical precision.
+            return true;
+          }
+          return false;
+        }
+        /**
+         * @constructs PDFViewer
+         * @param {PDFViewerOptions} options
+         */
+        function PDFViewer(options) {
+          this.container = options.container;
+          this.viewer = options.viewer || options.container.firstElementChild;
+          this.eventBus = options.eventBus || domEvents.getGlobalEventBus();
+          this.linkService = options.linkService || new SimpleLinkService();
+          this.downloadManager = options.downloadManager || null;
+          this.removePageBorders = options.removePageBorders || false;
+          this.enhanceTextSelection = options.enhanceTextSelection || false;
+          this.renderInteractiveForms = options.renderInteractiveForms || false;
+          this.defaultRenderingQueue = !options.renderingQueue;
+          if (this.defaultRenderingQueue) {
+            // Custom rendering queue is not specified, using default one
+            this.renderingQueue = new PDFRenderingQueue();
+            this.renderingQueue.setViewer(this);
+          } else {
+            this.renderingQueue = options.renderingQueue;
+          }
+          this.scroll = watchScroll(this.container, this._scrollUpdate.bind(this));
+          this.presentationModeState = PresentationModeState.UNKNOWN;
+          this._resetView();
+          if (this.removePageBorders) {
+            this.viewer.classList.add('removePageBorders');
+          }
+        }
+        PDFViewer.prototype = /** @lends PDFViewer.prototype */
+        {
+          get pagesCount() {
+            return this._pages.length;
+          },
+          getPageView: function (index) {
+            return this._pages[index];
+          },
+          /**
+           * @returns {boolean} true if all {PDFPageView} objects are initialized.
+           */
+          get pageViewsReady() {
+            return this._pageViewsReady;
+          },
+          /**
+           * @returns {number}
+           */
+          get currentPageNumber() {
+            return this._currentPageNumber;
+          },
+          /**
+           * @param {number} val - The page number.
+           */
+          set currentPageNumber(val) {
+            if ((val | 0) !== val) {
+              // Ensure that `val` is an integer.
+              throw new Error('Invalid page number.');
+            }
+            if (!this.pdfDocument) {
+              this._currentPageNumber = val;
+              return;
+            }
+            // The intent can be to just reset a scroll position and/or scale.
+            this._setCurrentPageNumber(val, /* resetCurrentPageView = */
+            true);
+          },
+          /**
+           * @private
+           */
+          _setCurrentPageNumber: function PDFViewer_setCurrentPageNumber(val, resetCurrentPageView) {
+            if (this._currentPageNumber === val) {
+              if (resetCurrentPageView) {
+                this._resetCurrentPageView();
+              }
+              return;
+            }
+            if (!(0 < val && val <= this.pagesCount)) {
+              console.error('PDFViewer_setCurrentPageNumber: "' + val + '" is out of bounds.');
+              return;
+            }
+            var arg = {
+              source: this,
+              pageNumber: val,
+              pageLabel: this._pageLabels && this._pageLabels[val - 1]
+            };
+            this._currentPageNumber = val;
+            this.eventBus.dispatch('pagechanging', arg);
+            this.eventBus.dispatch('pagechange', arg);
+            if (resetCurrentPageView) {
+              this._resetCurrentPageView();
+            }
+          },
+          /**
+           * @returns {string|null} Returns the current page label,
+           *                        or `null` if no page labels exist.
+           */
+          get currentPageLabel() {
+            return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];
+          },
+          /**
+           * @param {string} val - The page label.
+           */
+          set currentPageLabel(val) {
+            var pageNumber = val | 0;
+            // Fallback page number.
+            if (this._pageLabels) {
+              var i = this._pageLabels.indexOf(val);
+              if (i >= 0) {
+                pageNumber = i + 1;
+              }
+            }
+            this.currentPageNumber = pageNumber;
+          },
+          /**
+           * @returns {number}
+           */
+          get currentScale() {
+            return this._currentScale !== UNKNOWN_SCALE ? this._currentScale : DEFAULT_SCALE;
+          },
+          /**
+           * @param {number} val - Scale of the pages in percents.
+           */
+          set currentScale(val) {
+            if (isNaN(val)) {
+              throw new Error('Invalid numeric scale');
+            }
+            if (!this.pdfDocument) {
+              this._currentScale = val;
+              this._currentScaleValue = val !== UNKNOWN_SCALE ? val.toString() : null;
+              return;
+            }
+            this._setScale(val, false);
+          },
+          /**
+           * @returns {string}
+           */
+          get currentScaleValue() {
+            return this._currentScaleValue;
+          },
+          /**
+           * @param val - The scale of the pages (in percent or predefined value).
+           */
+          set currentScaleValue(val) {
+            if (!this.pdfDocument) {
+              this._currentScale = isNaN(val) ? UNKNOWN_SCALE : val;
+              this._currentScaleValue = val.toString();
+              return;
+            }
+            this._setScale(val, false);
+          },
+          /**
+           * @returns {number}
+           */
+          get pagesRotation() {
+            return this._pagesRotation;
+          },
+          /**
+           * @param {number} rotation - The rotation of the pages (0, 90, 180, 270).
+           */
+          set pagesRotation(rotation) {
+            if (!(typeof rotation === 'number' && rotation % 90 === 0)) {
+              throw new Error('Invalid pages rotation angle.');
+            }
+            this._pagesRotation = rotation;
+            if (!this.pdfDocument) {
+              return;
+            }
+            for (var i = 0, l = this._pages.length; i < l; i++) {
+              var pageView = this._pages[i];
+              pageView.update(pageView.scale, rotation);
+            }
+            this._setScale(this._currentScaleValue, true);
+            if (this.defaultRenderingQueue) {
+              this.update();
+            }
+          },
+          /**
+           * @param pdfDocument {PDFDocument}
+           */
+          setDocument: function (pdfDocument) {
+            if (this.pdfDocument) {
+              this._cancelRendering();
+              this._resetView();
+            }
+            this.pdfDocument = pdfDocument;
+            if (!pdfDocument) {
+              return;
+            }
+            var pagesCount = pdfDocument.numPages;
+            var self = this;
+            var resolvePagesPromise;
+            var pagesPromise = new Promise(function (resolve) {
+              resolvePagesPromise = resolve;
+            });
+            this.pagesPromise = pagesPromise;
+            pagesPromise.then(function () {
+              self._pageViewsReady = true;
+              self.eventBus.dispatch('pagesloaded', {
+                source: self,
+                pagesCount: pagesCount
+              });
+            });
+            var isOnePageRenderedResolved = false;
+            var resolveOnePageRendered = null;
+            var onePageRendered = new Promise(function (resolve) {
+              resolveOnePageRendered = resolve;
+            });
+            this.onePageRendered = onePageRendered;
+            var bindOnAfterAndBeforeDraw = function (pageView) {
+              pageView.onBeforeDraw = function pdfViewLoadOnBeforeDraw() {
+                // Add the page to the buffer at the start of drawing. That way it can
+                // be evicted from the buffer and destroyed even if we pause its
+                // rendering.
+                self._buffer.push(this);
+              };
+              pageView.onAfterDraw = function pdfViewLoadOnAfterDraw() {
+                if (!isOnePageRenderedResolved) {
+                  isOnePageRenderedResolved = true;
+                  resolveOnePageRendered();
+                }
+              };
+            };
+            var firstPagePromise = pdfDocument.getPage(1);
+            this.firstPagePromise = firstPagePromise;
+            // Fetch a single page so we can get a viewport that will be the default
+            // viewport for all pages
+            return firstPagePromise.then(function (pdfPage) {
+              var scale = this.currentScale;
+              var viewport = pdfPage.getViewport(scale * CSS_UNITS);
+              for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+                var textLayerFactory = null;
+                if (!pdfjsLib.PDFJS.disableTextLayer) {
+                  textLayerFactory = this;
+                }
+                var pageView = new PDFPageView({
+                  container: this.viewer,
+                  eventBus: this.eventBus,
+                  id: pageNum,
+                  scale: scale,
+                  defaultViewport: viewport.clone(),
+                  renderingQueue: this.renderingQueue,
+                  textLayerFactory: textLayerFactory,
+                  annotationLayerFactory: this,
+                  enhanceTextSelection: this.enhanceTextSelection,
+                  renderInteractiveForms: this.renderInteractiveForms
+                });
+                bindOnAfterAndBeforeDraw(pageView);
+                this._pages.push(pageView);
+              }
+              var linkService = this.linkService;
+              // Fetch all the pages since the viewport is needed before printing
+              // starts to create the correct size canvas. Wait until one page is
+              // rendered so we don't tie up too many resources early on.
+              onePageRendered.then(function () {
+                if (!pdfjsLib.PDFJS.disableAutoFetch) {
+                  var getPagesLeft = pagesCount;
+                  for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
+                    pdfDocument.getPage(pageNum).then(function (pageNum, pdfPage) {
+                      var pageView = self._pages[pageNum - 1];
+                      if (!pageView.pdfPage) {
+                        pageView.setPdfPage(pdfPage);
+                      }
+                      linkService.cachePageRef(pageNum, pdfPage.ref);
+                      getPagesLeft--;
+                      if (!getPagesLeft) {
+                        resolvePagesPromise();
+                      }
+                    }.bind(null, pageNum));
+                  }
+                } else {
+                  // XXX: Printing is semi-broken with auto fetch disabled.
+                  resolvePagesPromise();
+                }
+              });
+              self.eventBus.dispatch('pagesinit', { source: self });
+              if (this.defaultRenderingQueue) {
+                this.update();
+              }
+              if (this.findController) {
+                this.findController.resolveFirstPage();
+              }
+            }.bind(this));
+          },
+          /**
+           * @param {Array|null} labels
+           */
+          setPageLabels: function PDFViewer_setPageLabels(labels) {
+            if (!this.pdfDocument) {
+              return;
+            }
+            if (!labels) {
+              this._pageLabels = null;
+            } else if (!(labels instanceof Array && this.pdfDocument.numPages === labels.length)) {
+              this._pageLabels = null;
+              console.error('PDFViewer_setPageLabels: Invalid page labels.');
+            } else {
+              this._pageLabels = labels;
+            }
+            // Update all the `PDFPageView` instances.
+            for (var i = 0, ii = this._pages.length; i < ii; i++) {
+              var pageView = this._pages[i];
+              var label = this._pageLabels && this._pageLabels[i];
+              pageView.setPageLabel(label);
+            }
+          },
+          _resetView: function () {
+            this._pages = [];
+            this._currentPageNumber = 1;
+            this._currentScale = UNKNOWN_SCALE;
+            this._currentScaleValue = null;
+            this._pageLabels = null;
+            this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
+            this._location = null;
+            this._pagesRotation = 0;
+            this._pagesRequests = [];
+            this._pageViewsReady = false;
+            // Remove the pages from the DOM.
+            this.viewer.textContent = '';
+          },
+          _scrollUpdate: function PDFViewer_scrollUpdate() {
+            if (this.pagesCount === 0) {
+              return;
+            }
+            this.update();
+            for (var i = 0, ii = this._pages.length; i < ii; i++) {
+              this._pages[i].updatePosition();
+            }
+          },
+          _setScaleDispatchEvent: function pdfViewer_setScaleDispatchEvent(newScale, newValue, preset) {
+            var arg = {
+              source: this,
+              scale: newScale,
+              presetValue: preset ? newValue : undefined
+            };
+            this.eventBus.dispatch('scalechanging', arg);
+            this.eventBus.dispatch('scalechange', arg);
+          },
+          _setScaleUpdatePages: function pdfViewer_setScaleUpdatePages(newScale, newValue, noScroll, preset) {
+            this._currentScaleValue = newValue.toString();
+            if (isSameScale(this._currentScale, newScale)) {
+              if (preset) {
+                this._setScaleDispatchEvent(newScale, newValue, true);
+              }
+              return;
+            }
+            for (var i = 0, ii = this._pages.length; i < ii; i++) {
+              this._pages[i].update(newScale);
+            }
+            this._currentScale = newScale;
+            if (!noScroll) {
+              var page = this._currentPageNumber, dest;
+              if (this._location && !pdfjsLib.PDFJS.ignoreCurrentPositionOnZoom && !(this.isInPresentationMode || this.isChangingPresentationMode)) {
+                page = this._location.pageNumber;
+                dest = [
+                  null,
+                  { name: 'XYZ' },
+                  this._location.left,
+                  this._location.top,
+                  null
+                ];
+              }
+              this.scrollPageIntoView({
+                pageNumber: page,
+                destArray: dest,
+                allowNegativeOffset: true
+              });
+            }
+            this._setScaleDispatchEvent(newScale, newValue, preset);
+            if (this.defaultRenderingQueue) {
+              this.update();
+            }
+          },
+          _setScale: function PDFViewer_setScale(value, noScroll) {
+            var scale = parseFloat(value);
+            if (scale > 0) {
+              this._setScaleUpdatePages(scale, value, noScroll, false);
+            } else {
+              var currentPage = this._pages[this._currentPageNumber - 1];
+              if (!currentPage) {
+                return;
+              }
+              var hPadding = this.isInPresentationMode || this.removePageBorders ? 0 : SCROLLBAR_PADDING;
+              var vPadding = this.isInPresentationMode || this.removePageBorders ? 0 : VERTICAL_PADDING;
+              var pageWidthScale = (this.container.clientWidth - hPadding) / currentPage.width * currentPage.scale;
+              var pageHeightScale = (this.container.clientHeight - vPadding) / currentPage.height * currentPage.scale;
+              switch (value) {
+              case 'page-actual':
+                scale = 1;
+                break;
+              case 'page-width':
+                scale = pageWidthScale;
+                break;
+              case 'page-height':
+                scale = pageHeightScale;
+                break;
+              case 'page-fit':
+                scale = Math.min(pageWidthScale, pageHeightScale);
+                break;
+              case 'auto':
+                var isLandscape = currentPage.width > currentPage.height;
+                // For pages in landscape mode, fit the page height to the viewer
+                // *unless* the page would thus become too wide to fit horizontally.
+                var horizontalScale = isLandscape ? Math.min(pageHeightScale, pageWidthScale) : pageWidthScale;
+                scale = Math.min(MAX_AUTO_SCALE, horizontalScale);
+                break;
+              default:
+                console.error('PDFViewer_setScale: "' + value + '" is an unknown zoom value.');
+                return;
+              }
+              this._setScaleUpdatePages(scale, value, noScroll, true);
+            }
+          },
+          /**
+           * Refreshes page view: scrolls to the current page and updates the scale.
+           * @private
+           */
+          _resetCurrentPageView: function () {
+            if (this.isInPresentationMode) {
+              // Fixes the case when PDF has different page sizes.
+              this._setScale(this._currentScaleValue, true);
+            }
+            var pageView = this._pages[this._currentPageNumber - 1];
+            scrollIntoView(pageView.div);
+          },
+          /**
+           * @typedef ScrollPageIntoViewParameters
+           * @property {number} pageNumber - The page number.
+           * @property {Array} destArray - (optional) The original PDF destination
+           *   array, in the format: <page-ref> </XYZ|/FitXXX> <args..>
+           * @property {boolean} allowNegativeOffset - (optional) Allow negative page
+           *   offsets. The default value is `false`.
+           */
+          /**
+           * Scrolls page into view.
+           * @param {ScrollPageIntoViewParameters} params
+           */
+          scrollPageIntoView: function PDFViewer_scrollPageIntoView(params) {
+            if (!this.pdfDocument) {
+              return;
+            }
+            var pageNumber = params.pageNumber || 0;
+            var dest = params.destArray || null;
+            var allowNegativeOffset = params.allowNegativeOffset || false;
+            if (this.isInPresentationMode || !dest) {
+              this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView */
+              true);
+              return;
+            }
+            var pageView = this._pages[pageNumber - 1];
+            if (!pageView) {
+              console.error('PDFViewer_scrollPageIntoView: ' + 'Invalid "pageNumber" parameter.');
+              return;
+            }
+            var x = 0, y = 0;
+            var width = 0, height = 0, widthScale, heightScale;
+            var changeOrientation = pageView.rotation % 180 === 0 ? false : true;
+            var pageWidth = (changeOrientation ? pageView.height : pageView.width) / pageView.scale / CSS_UNITS;
+            var pageHeight = (changeOrientation ? pageView.width : pageView.height) / pageView.scale / CSS_UNITS;
+            var scale = 0;
+            switch (dest[1].name) {
+            case 'XYZ':
+              x = dest[2];
+              y = dest[3];
+              scale = dest[4];
+              // If x and/or y coordinates are not supplied, default to
+              // _top_ left of the page (not the obvious bottom left,
+              // since aligning the bottom of the intended page with the
+              // top of the window is rarely helpful).
+              x = x !== null ? x : 0;
+              y = y !== null ? y : pageHeight;
+              break;
+            case 'Fit':
+            case 'FitB':
+              scale = 'page-fit';
+              break;
+            case 'FitH':
+            case 'FitBH':
+              y = dest[2];
+              scale = 'page-width';
+              // According to the PDF spec, section 12.3.2.2, a `null` value in the
+              // parameter should maintain the position relative to the new page.
+              if (y === null && this._location) {
+                x = this._location.left;
+                y = this._location.top;
+              }
+              break;
+            case 'FitV':
+            case 'FitBV':
+              x = dest[2];
+              width = pageWidth;
+              height = pageHeight;
+              scale = 'page-height';
+              break;
+            case 'FitR':
+              x = dest[2];
+              y = dest[3];
+              width = dest[4] - x;
+              height = dest[5] - y;
+              var hPadding = this.removePageBorders ? 0 : SCROLLBAR_PADDING;
+              var vPadding = this.removePageBorders ? 0 : VERTICAL_PADDING;
+              widthScale = (this.container.clientWidth - hPadding) / width / CSS_UNITS;
+              heightScale = (this.container.clientHeight - vPadding) / height / CSS_UNITS;
+              scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
+              break;
+            default:
+              console.error('PDFViewer_scrollPageIntoView: \'' + dest[1].name + '\' is not a valid destination type.');
+              return;
+            }
+            if (scale && scale !== this._currentScale) {
+              this.currentScaleValue = scale;
+            } else if (this._currentScale === UNKNOWN_SCALE) {
+              this.currentScaleValue = DEFAULT_SCALE_VALUE;
+            }
+            if (scale === 'page-fit' && !dest[4]) {
+              scrollIntoView(pageView.div);
+              return;
+            }
+            var boundingRect = [
+              pageView.viewport.convertToViewportPoint(x, y),
+              pageView.viewport.convertToViewportPoint(x + width, y + height)
+            ];
+            var left = Math.min(boundingRect[0][0], boundingRect[1][0]);
+            var top = Math.min(boundingRect[0][1], boundingRect[1][1]);
+            if (!allowNegativeOffset) {
+              // Some bad PDF generators will create destinations with e.g. top values
+              // that exceeds the page height. Ensure that offsets are not negative,
+              // to prevent a previous page from becoming visible (fixes bug 874482).
+              left = Math.max(left, 0);
+              top = Math.max(top, 0);
+            }
+            scrollIntoView(pageView.div, {
+              left: left,
+              top: top
+            });
+          },
+          _updateLocation: function (firstPage) {
+            var currentScale = this._currentScale;
+            var currentScaleValue = this._currentScaleValue;
+            var normalizedScaleValue = parseFloat(currentScaleValue) === currentScale ? Math.round(currentScale * 10000) / 100 : currentScaleValue;
+            var pageNumber = firstPage.id;
+            var pdfOpenParams = '#page=' + pageNumber;
+            pdfOpenParams += '&zoom=' + normalizedScaleValue;
+            var currentPageView = this._pages[pageNumber - 1];
+            var container = this.container;
+            var topLeft = currentPageView.getPagePoint(container.scrollLeft - firstPage.x, container.scrollTop - firstPage.y);
+            var intLeft = Math.round(topLeft[0]);
+            var intTop = Math.round(topLeft[1]);
+            pdfOpenParams += ',' + intLeft + ',' + intTop;
+            this._location = {
+              pageNumber: pageNumber,
+              scale: normalizedScaleValue,
+              top: intTop,
+              left: intLeft,
+              pdfOpenParams: pdfOpenParams
+            };
+          },
+          update: function PDFViewer_update() {
+            var visible = this._getVisiblePages();
+            var visiblePages = visible.views;
+            if (visiblePages.length === 0) {
+              return;
+            }
+            var suggestedCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * visiblePages.length + 1);
+            this._buffer.resize(suggestedCacheSize);
+            this.renderingQueue.renderHighestPriority(visible);
+            var currentId = this._currentPageNumber;
+            var firstPage = visible.first;
+            for (var i = 0, ii = visiblePages.length, stillFullyVisible = false; i < ii; ++i) {
+              var page = visiblePages[i];
+              if (page.percent < 100) {
+                break;
+              }
+              if (page.id === currentId) {
+                stillFullyVisible = true;
+                break;
+              }
+            }
+            if (!stillFullyVisible) {
+              currentId = visiblePages[0].id;
+            }
+            if (!this.isInPresentationMode) {
+              this._setCurrentPageNumber(currentId);
+            }
+            this._updateLocation(firstPage);
+            this.eventBus.dispatch('updateviewarea', {
+              source: this,
+              location: this._location
+            });
+          },
+          containsElement: function (element) {
+            return this.container.contains(element);
+          },
+          focus: function () {
+            this.container.focus();
+          },
+          get isInPresentationMode() {
+            return this.presentationModeState === PresentationModeState.FULLSCREEN;
+          },
+          get isChangingPresentationMode() {
+            return this.presentationModeState === PresentationModeState.CHANGING;
+          },
+          get isHorizontalScrollbarEnabled() {
+            return this.isInPresentationMode ? false : this.container.scrollWidth > this.container.clientWidth;
+          },
+          _getVisiblePages: function () {
+            if (!this.isInPresentationMode) {
+              return getVisibleElements(this.container, this._pages, true);
+            } else {
+              // The algorithm in getVisibleElements doesn't work in all browsers and
+              // configurations when presentation mode is active.
+              var visible = [];
+              var currentPage = this._pages[this._currentPageNumber - 1];
+              visible.push({
+                id: currentPage.id,
+                view: currentPage
+              });
+              return {
+                first: currentPage,
+                last: currentPage,
+                views: visible
+              };
+            }
+          },
+          cleanup: function () {
+            for (var i = 0, ii = this._pages.length; i < ii; i++) {
+              if (this._pages[i] && this._pages[i].renderingState !== RenderingStates.FINISHED) {
+                this._pages[i].reset();
+              }
+            }
+          },
+          /**
+           * @private
+           */
+          _cancelRendering: function PDFViewer_cancelRendering() {
+            for (var i = 0, ii = this._pages.length; i < ii; i++) {
+              if (this._pages[i]) {
+                this._pages[i].cancelRendering();
+              }
+            }
+          },
+          /**
+           * @param {PDFPageView} pageView
+           * @returns {PDFPage}
+           * @private
+           */
+          _ensurePdfPageLoaded: function (pageView) {
+            if (pageView.pdfPage) {
+              return Promise.resolve(pageView.pdfPage);
+            }
+            var pageNumber = pageView.id;
+            if (this._pagesRequests[pageNumber]) {
+              return this._pagesRequests[pageNumber];
+            }
+            var promise = this.pdfDocument.getPage(pageNumber).then(function (pdfPage) {
+              pageView.setPdfPage(pdfPage);
+              this._pagesRequests[pageNumber] = null;
+              return pdfPage;
+            }.bind(this));
+            this._pagesRequests[pageNumber] = promise;
+            return promise;
+          },
+          forceRendering: function (currentlyVisiblePages) {
+            var visiblePages = currentlyVisiblePages || this._getVisiblePages();
+            var pageView = this.renderingQueue.getHighestPriority(visiblePages, this._pages, this.scroll.down);
+            if (pageView) {
+              this._ensurePdfPageLoaded(pageView).then(function () {
+                this.renderingQueue.renderView(pageView);
+              }.bind(this));
+              return true;
+            }
+            return false;
+          },
+          getPageTextContent: function (pageIndex) {
+            return this.pdfDocument.getPage(pageIndex + 1).then(function (page) {
+              return page.getTextContent({ normalizeWhitespace: true });
+            });
+          },
+          /**
+           * @param {HTMLDivElement} textLayerDiv
+           * @param {number} pageIndex
+           * @param {PageViewport} viewport
+           * @returns {TextLayerBuilder}
+           */
+          createTextLayerBuilder: function (textLayerDiv, pageIndex, viewport, enhanceTextSelection) {
+            return new TextLayerBuilder({
+              textLayerDiv: textLayerDiv,
+              eventBus: this.eventBus,
+              pageIndex: pageIndex,
+              viewport: viewport,
+              findController: this.isInPresentationMode ? null : this.findController,
+              enhanceTextSelection: this.isInPresentationMode ? false : enhanceTextSelection
+            });
+          },
+          /**
+           * @param {HTMLDivElement} pageDiv
+           * @param {PDFPage} pdfPage
+           * @param {boolean} renderInteractiveForms
+           * @returns {AnnotationLayerBuilder}
+           */
+          createAnnotationLayerBuilder: function (pageDiv, pdfPage, renderInteractiveForms) {
+            return new AnnotationLayerBuilder({
+              pageDiv: pageDiv,
+              pdfPage: pdfPage,
+              renderInteractiveForms: renderInteractiveForms,
+              linkService: this.linkService,
+              downloadManager: this.downloadManager
+            });
+          },
+          setFindController: function (findController) {
+            this.findController = findController;
+          },
+          /**
+           * Returns sizes of the pages.
+           * @returns {Array} Array of objects with width/height fields.
+           */
+          getPagesOverview: function () {
+            return this._pages.map(function (pageView) {
+              var viewport = pageView.pdfPage.getViewport(1);
+              return {
+                width: viewport.width,
+                height: viewport.height
+              };
+            });
+          }
+        };
+        return PDFViewer;
+      }();
+      exports.PresentationModeState = PresentationModeState;
+      exports.PDFViewer = PDFViewer;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebApp = {}, root.pdfjsWebUIUtils, root.pdfjsWebDownloadManager, root.pdfjsWebPDFHistory, root.pdfjsWebPreferences, root.pdfjsWebPDFSidebar, root.pdfjsWebViewHistory, root.pdfjsWebPDFThumbnailViewer, root.pdfjsWebSecondaryToolbar, root.pdfjsWebPasswordPrompt, root.pdfjsWebPDFPresentationMode, root.pdfjsWebPDFDocumentProperties, root.pdfjsWebHandTool, root.pdfjsWebPDFViewer, root.pdfjsWebPDFRenderingQueue, root.pdfjsWebPDFLinkService, root.pdfjsWebPDFOutlineViewer, root.pdfjsWebOverlayManager, root.pdfjsWebPDFAttachmentViewer, root.pdfjsWebPDFFindController, root.pdfjsWebPDFFindBar, root.pdfjsWebDOMEvents, root.pdfjsWebPDFJS);
+    }(this, function (exports, uiUtilsLib, downloadManagerLib, pdfHistoryLib, preferencesLib, pdfSidebarLib, viewHistoryLib, pdfThumbnailViewerLib, secondaryToolbarLib, passwordPromptLib, pdfPresentationModeLib, pdfDocumentPropertiesLib, handToolLib, pdfViewerLib, pdfRenderingQueueLib, pdfLinkServiceLib, pdfOutlineViewerLib, overlayManagerLib, pdfAttachmentViewerLib, pdfFindControllerLib, pdfFindBarLib, domEventsLib, pdfjsLib) {
+      var UNKNOWN_SCALE = uiUtilsLib.UNKNOWN_SCALE;
+      var DEFAULT_SCALE_VALUE = uiUtilsLib.DEFAULT_SCALE_VALUE;
+      var ProgressBar = uiUtilsLib.ProgressBar;
+      var getPDFFileNameFromURL = uiUtilsLib.getPDFFileNameFromURL;
+      var noContextMenuHandler = uiUtilsLib.noContextMenuHandler;
+      var mozL10n = uiUtilsLib.mozL10n;
+      var parseQueryString = uiUtilsLib.parseQueryString;
+      var PDFHistory = pdfHistoryLib.PDFHistory;
+      var Preferences = preferencesLib.Preferences;
+      var SidebarView = pdfSidebarLib.SidebarView;
+      var PDFSidebar = pdfSidebarLib.PDFSidebar;
+      var ViewHistory = viewHistoryLib.ViewHistory;
+      var PDFThumbnailViewer = pdfThumbnailViewerLib.PDFThumbnailViewer;
+      var SecondaryToolbar = secondaryToolbarLib.SecondaryToolbar;
+      var PasswordPrompt = passwordPromptLib.PasswordPrompt;
+      var PDFPresentationMode = pdfPresentationModeLib.PDFPresentationMode;
+      var PDFDocumentProperties = pdfDocumentPropertiesLib.PDFDocumentProperties;
+      var HandTool = handToolLib.HandTool;
+      var PresentationModeState = pdfViewerLib.PresentationModeState;
+      var PDFViewer = pdfViewerLib.PDFViewer;
+      var RenderingStates = pdfRenderingQueueLib.RenderingStates;
+      var PDFRenderingQueue = pdfRenderingQueueLib.PDFRenderingQueue;
+      var PDFLinkService = pdfLinkServiceLib.PDFLinkService;
+      var PDFOutlineViewer = pdfOutlineViewerLib.PDFOutlineViewer;
+      var OverlayManager = overlayManagerLib.OverlayManager;
+      var PDFAttachmentViewer = pdfAttachmentViewerLib.PDFAttachmentViewer;
+      var PDFFindController = pdfFindControllerLib.PDFFindController;
+      var PDFFindBar = pdfFindBarLib.PDFFindBar;
+      var getGlobalEventBus = domEventsLib.getGlobalEventBus;
+      var normalizeWheelEventDelta = uiUtilsLib.normalizeWheelEventDelta;
+      var DEFAULT_SCALE_DELTA = 1.1;
+      var MIN_SCALE = 0.25;
+      var MAX_SCALE = 10.0;
+      var SCALE_SELECT_CONTAINER_PADDING = 8;
+      var SCALE_SELECT_PADDING = 22;
+      var PAGE_NUMBER_LOADING_INDICATOR = 'visiblePageIsLoading';
+      var DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;
+      function configure(PDFJS) {
+        PDFJS.imageResourcesPath = './images/';
+        PDFJS.workerSrc = '../build/pdf.worker.js';
+        PDFJS.cMapUrl = '../web/cmaps/';
+        PDFJS.cMapPacked = true;
+      }
+      var DefaultExernalServices = {
+        updateFindControlState: function (data) {
+        },
+        initPassiveLoading: function (callbacks) {
+        },
+        fallback: function (data, callback) {
+        },
+        reportTelemetry: function (data) {
+        },
+        createDownloadManager: function () {
+          return new downloadManagerLib.DownloadManager();
+        },
+        supportsIntegratedFind: false,
+        supportsDocumentFonts: true,
+        supportsDocumentColors: true,
+        supportedMouseWheelZoomModifierKeys: {
+          ctrlKey: true,
+          metaKey: true
+        }
+      };
+      var PDFViewerApplication = {
+        initialBookmark: document.location.hash.substring(1),
+        initialDestination: null,
+        initialized: false,
+        fellback: false,
+        appConfig: null,
+        pdfDocument: null,
+        pdfLoadingTask: null,
+        printService: null,
+        /** @type {PDFViewer} */
+        pdfViewer: null,
+        /** @type {PDFThumbnailViewer} */
+        pdfThumbnailViewer: null,
+        /** @type {PDFRenderingQueue} */
+        pdfRenderingQueue: null,
+        /** @type {PDFPresentationMode} */
+        pdfPresentationMode: null,
+        /** @type {PDFDocumentProperties} */
+        pdfDocumentProperties: null,
+        /** @type {PDFLinkService} */
+        pdfLinkService: null,
+        /** @type {PDFHistory} */
+        pdfHistory: null,
+        /** @type {PDFSidebar} */
+        pdfSidebar: null,
+        /** @type {PDFOutlineViewer} */
+        pdfOutlineViewer: null,
+        /** @type {PDFAttachmentViewer} */
+        pdfAttachmentViewer: null,
+        /** @type {ViewHistory} */
+        store: null,
+        /** @type {DownloadManager} */
+        downloadManager: null,
+        /** @type {EventBus} */
+        eventBus: null,
+        pageRotation: 0,
+        isInitialViewSet: false,
+        animationStartedPromise: null,
+        preferenceSidebarViewOnLoad: SidebarView.NONE,
+        preferencePdfBugEnabled: false,
+        preferenceShowPreviousViewOnLoad: true,
+        preferenceDefaultZoomValue: '',
+        preferenceDisablePageLabels: false,
+        isViewerEmbedded: window.parent !== window,
+        url: '',
+        baseUrl: '',
+        externalServices: DefaultExernalServices,
+        hasPageLabels: false,
+        // called once when the document is loaded
+        initialize: function pdfViewInitialize(appConfig) {
+          configure(pdfjsLib.PDFJS);
+          this.appConfig = appConfig;
+          var eventBus = appConfig.eventBus || getGlobalEventBus();
+          this.eventBus = eventBus;
+          this.bindEvents();
+          var pdfRenderingQueue = new PDFRenderingQueue();
+          pdfRenderingQueue.onIdle = this.cleanup.bind(this);
+          this.pdfRenderingQueue = pdfRenderingQueue;
+          var pdfLinkService = new PDFLinkService({ eventBus: eventBus });
+          this.pdfLinkService = pdfLinkService;
+          var downloadManager = this.externalServices.createDownloadManager();
+          this.downloadManager = downloadManager;
+          var container = appConfig.mainContainer;
+          var viewer = appConfig.viewerContainer;
+          this.pdfViewer = new PDFViewer({
+            container: container,
+            viewer: viewer,
+            eventBus: eventBus,
+            renderingQueue: pdfRenderingQueue,
+            linkService: pdfLinkService,
+            downloadManager: downloadManager,
+            enhanceTextSelection: false,
+            renderInteractiveForms: false
+          });
+          pdfRenderingQueue.setViewer(this.pdfViewer);
+          pdfLinkService.setViewer(this.pdfViewer);
+          var thumbnailContainer = appConfig.sidebar.thumbnailView;
+          this.pdfThumbnailViewer = new PDFThumbnailViewer({
+            container: thumbnailContainer,
+            renderingQueue: pdfRenderingQueue,
+            linkService: pdfLinkService
+          });
+          pdfRenderingQueue.setThumbnailViewer(this.pdfThumbnailViewer);
+          Preferences.initialize();
+          this.preferences = Preferences;
+          this.pdfHistory = new PDFHistory({
+            linkService: pdfLinkService,
+            eventBus: this.eventBus
+          });
+          pdfLinkService.setHistory(this.pdfHistory);
+          this.findController = new PDFFindController({ pdfViewer: this.pdfViewer });
+          this.findController.onUpdateResultsCount = function (matchCount) {
+            if (this.supportsIntegratedFind) {
+              return;
+            }
+            this.findBar.updateResultsCount(matchCount);
+          }.bind(this);
+          this.findController.onUpdateState = function (state, previous, matchCount) {
+            if (this.supportsIntegratedFind) {
+              this.externalServices.updateFindControlState({
+                result: state,
+                findPrevious: previous
+              });
+            } else {
+              this.findBar.updateUIState(state, previous, matchCount);
+            }
+          }.bind(this);
+          this.pdfViewer.setFindController(this.findController);
+          // FIXME better PDFFindBar constructor parameters
+          var findBarConfig = Object.create(appConfig.findBar);
+          findBarConfig.findController = this.findController;
+          findBarConfig.eventBus = this.eventBus;
+          this.findBar = new PDFFindBar(findBarConfig);
+          this.overlayManager = OverlayManager;
+          this.handTool = new HandTool({
+            container: container,
+            eventBus: this.eventBus
+          });
+          this.pdfDocumentProperties = new PDFDocumentProperties(appConfig.documentProperties);
+          this.secondaryToolbar = new SecondaryToolbar(appConfig.secondaryToolbar, container, eventBus);
+          if (this.supportsFullscreen) {
+            this.pdfPresentationMode = new PDFPresentationMode({
+              container: container,
+              viewer: viewer,
+              pdfViewer: this.pdfViewer,
+              eventBus: this.eventBus,
+              contextMenuItems: appConfig.fullscreen
+            });
+          }
+          this.passwordPrompt = new PasswordPrompt(appConfig.passwordOverlay);
+          this.pdfOutlineViewer = new PDFOutlineViewer({
+            container: appConfig.sidebar.outlineView,
+            eventBus: this.eventBus,
+            linkService: pdfLinkService
+          });
+          this.pdfAttachmentViewer = new PDFAttachmentViewer({
+            container: appConfig.sidebar.attachmentsView,
+            eventBus: this.eventBus,
+            downloadManager: downloadManager
+          });
+          // FIXME better PDFSidebar constructor parameters
+          var sidebarConfig = Object.create(appConfig.sidebar);
+          sidebarConfig.pdfViewer = this.pdfViewer;
+          sidebarConfig.pdfThumbnailViewer = this.pdfThumbnailViewer;
+          sidebarConfig.pdfOutlineViewer = this.pdfOutlineViewer;
+          sidebarConfig.eventBus = this.eventBus;
+          this.pdfSidebar = new PDFSidebar(sidebarConfig);
+          this.pdfSidebar.onToggled = this.forceRendering.bind(this);
+          var self = this;
+          var PDFJS = pdfjsLib.PDFJS;
+          var initializedPromise = Promise.all([
+            Preferences.get('enableWebGL').then(function resolved(value) {
+              PDFJS.disableWebGL = !value;
+            }),
+            Preferences.get('sidebarViewOnLoad').then(function resolved(value) {
+              self.preferenceSidebarViewOnLoad = value;
+            }),
+            Preferences.get('pdfBugEnabled').then(function resolved(value) {
+              self.preferencePdfBugEnabled = value;
+            }),
+            Preferences.get('showPreviousViewOnLoad').then(function resolved(value) {
+              self.preferenceShowPreviousViewOnLoad = value;
+            }),
+            Preferences.get('defaultZoomValue').then(function resolved(value) {
+              self.preferenceDefaultZoomValue = value;
+            }),
+            Preferences.get('enhanceTextSelection').then(function resolved(value) {
+              // TODO: Move the initialization and fetching of `Preferences` to occur
+              //       before the various viewer components are initialized.
+              //
+              // This was attempted in: https://github.com/mozilla/pdf.js/pull/7586,
+              // but it had to be backed out since it violated implicit assumptions
+              // about some viewer components being synchronously available.
+              //
+              // NOTE: This hack works since the `enhanceTextSelection` option is not
+              //       needed until `PDFViewer.setDocument` has been called.
+              self.pdfViewer.enhanceTextSelection = value;
+            }),
+            Preferences.get('disableTextLayer').then(function resolved(value) {
+              if (PDFJS.disableTextLayer === true) {
+                return;
+              }
+              PDFJS.disableTextLayer = value;
+            }),
+            Preferences.get('disableRange').then(function resolved(value) {
+              if (PDFJS.disableRange === true) {
+                return;
+              }
+              PDFJS.disableRange = value;
+            }),
+            Preferences.get('disableStream').then(function resolved(value) {
+              if (PDFJS.disableStream === true) {
+                return;
+              }
+              PDFJS.disableStream = value;
+            }),
+            Preferences.get('disableAutoFetch').then(function resolved(value) {
+              PDFJS.disableAutoFetch = value;
+            }),
+            Preferences.get('disableFontFace').then(function resolved(value) {
+              if (PDFJS.disableFontFace === true) {
+                return;
+              }
+              PDFJS.disableFontFace = value;
+            }),
+            Preferences.get('useOnlyCssZoom').then(function resolved(value) {
+              PDFJS.useOnlyCssZoom = value;
+            }),
+            Preferences.get('externalLinkTarget').then(function resolved(value) {
+              if (PDFJS.isExternalLinkTargetSet()) {
+                return;
+              }
+              PDFJS.externalLinkTarget = value;
+            }),
+            Preferences.get('renderInteractiveForms').then(function resolved(value) {
+              // TODO: Like the `enhanceTextSelection` preference, move the
+              //       initialization and fetching of `Preferences` to occur
+              //       before the various viewer components are initialized.
+              self.pdfViewer.renderInteractiveForms = value;
+            }),
+            Preferences.get('disablePageLabels').then(function resolved(value) {
+              self.preferenceDisablePageLabels = value;
+            })
+          ]).catch(function (reason) {
+          });
+          return initializedPromise.then(function () {
+            if (self.isViewerEmbedded && !PDFJS.isExternalLinkTargetSet()) {
+              // Prevent external links from "replacing" the viewer,
+              // when it's embedded in e.g. an iframe or an object.
+              PDFJS.externalLinkTarget = PDFJS.LinkTarget.TOP;
+            }
+            self.initialized = true;
+          });
+        },
+        run: function pdfViewRun(config) {
+          this.initialize(config).then(webViewerInitialized);
+        },
+        zoomIn: function pdfViewZoomIn(ticks) {
+          var newScale = this.pdfViewer.currentScale;
+          do {
+            newScale = (newScale * DEFAULT_SCALE_DELTA).toFixed(2);
+            newScale = Math.ceil(newScale * 10) / 10;
+            newScale = Math.min(MAX_SCALE, newScale);
+          } while (--ticks > 0 && newScale < MAX_SCALE);
+          this.pdfViewer.currentScaleValue = newScale;
+        },
+        zoomOut: function pdfViewZoomOut(ticks) {
+          var newScale = this.pdfViewer.currentScale;
+          do {
+            newScale = (newScale / DEFAULT_SCALE_DELTA).toFixed(2);
+            newScale = Math.floor(newScale * 10) / 10;
+            newScale = Math.max(MIN_SCALE, newScale);
+          } while (--ticks > 0 && newScale > MIN_SCALE);
+          this.pdfViewer.currentScaleValue = newScale;
+        },
+        get pagesCount() {
+          return this.pdfDocument ? this.pdfDocument.numPages : 0;
+        },
+        set page(val) {
+          this.pdfViewer.currentPageNumber = val;
+        },
+        get page() {
+          return this.pdfViewer.currentPageNumber;
+        },
+        get printing() {
+          return !!this.printService;
+        },
+        get supportsPrinting() {
+          return PDFPrintServiceFactory.instance.supportsPrinting;
+        },
+        get supportsFullscreen() {
+          var support;
+          support = document.fullscreenEnabled === true || document.mozFullScreenEnabled === true;
+          if (support && pdfjsLib.PDFJS.disableFullscreen === true) {
+            support = false;
+          }
+          return pdfjsLib.shadow(this, 'supportsFullscreen', support);
+        },
+        get supportsIntegratedFind() {
+          return this.externalServices.supportsIntegratedFind;
+        },
+        get supportsDocumentFonts() {
+          return this.externalServices.supportsDocumentFonts;
+        },
+        get supportsDocumentColors() {
+          return this.externalServices.supportsDocumentColors;
+        },
+        get loadingBar() {
+          var bar = new ProgressBar('#loadingBar', {});
+          return pdfjsLib.shadow(this, 'loadingBar', bar);
+        },
+        get supportedMouseWheelZoomModifierKeys() {
+          return this.externalServices.supportedMouseWheelZoomModifierKeys;
+        },
+        initPassiveLoading: function pdfViewInitPassiveLoading() {
+          this.externalServices.initPassiveLoading({
+            onOpenWithTransport: function (url, length, transport) {
+              PDFViewerApplication.open(url, { range: transport });
+              if (length) {
+                PDFViewerApplication.pdfDocumentProperties.setFileSize(length);
+              }
+            },
+            onOpenWithData: function (data) {
+              PDFViewerApplication.open(data);
+            },
+            onOpenWithURL: function (url, length, originalURL) {
+              var file = url, args = null;
+              if (length !== undefined) {
+                args = { length: length };
+              }
+              if (originalURL !== undefined) {
+                file = {
+                  file: url,
+                  originalURL: originalURL
+                };
+              }
+              PDFViewerApplication.open(file, args);
+            },
+            onError: function (e) {
+              PDFViewerApplication.error(mozL10n.get('loading_error', null, 'An error occurred while loading the PDF.'), e);
+            },
+            onProgress: function (loaded, total) {
+              PDFViewerApplication.progress(loaded / total);
+            }
+          });
+        },
+        setTitleUsingUrl: function pdfViewSetTitleUsingUrl(url) {
+          this.url = url;
+          this.baseUrl = url.split('#')[0];
+          try {
+            this.setTitle(decodeURIComponent(pdfjsLib.getFilenameFromUrl(url)) || url);
+          } catch (e) {
+            // decodeURIComponent may throw URIError,
+            // fall back to using the unprocessed url in that case
+            this.setTitle(url);
+          }
+        },
+        setTitle: function pdfViewSetTitle(title) {
+          if (this.isViewerEmbedded) {
+            // Embedded PDF viewers should not be changing their parent page's title.
+            return;
+          }
+          document.title = title;
+        },
+        /**
+         * Closes opened PDF document.
+         * @returns {Promise} - Returns the promise, which is resolved when all
+         *                      destruction is completed.
+         */
+        close: function pdfViewClose() {
+          var errorWrapper = this.appConfig.errorWrapper.container;
+          errorWrapper.setAttribute('hidden', 'true');
+          if (!this.pdfLoadingTask) {
+            return Promise.resolve();
+          }
+          var promise = this.pdfLoadingTask.destroy();
+          this.pdfLoadingTask = null;
+          if (this.pdfDocument) {
+            this.pdfDocument = null;
+            this.pdfThumbnailViewer.setDocument(null);
+            this.pdfViewer.setDocument(null);
+            this.pdfLinkService.setDocument(null, null);
+          }
+          this.store = null;
+          this.isInitialViewSet = false;
+          this.hasPageLabels = false;
+          this.pdfSidebar.reset();
+          this.pdfOutlineViewer.reset();
+          this.pdfAttachmentViewer.reset();
+          this.findController.reset();
+          this.findBar.reset();
+          if (typeof PDFBug !== 'undefined') {
+            PDFBug.cleanup();
+          }
+          return promise;
+        },
+        /**
+         * Opens PDF document specified by URL or array with additional arguments.
+         * @param {string|TypedArray|ArrayBuffer} file - PDF location or binary data.
+         * @param {Object} args - (optional) Additional arguments for the getDocument
+         *                        call, e.g. HTTP headers ('httpHeaders') or
+         *                        alternative data transport ('range').
+         * @returns {Promise} - Returns the promise, which is resolved when document
+         *                      is opened.
+         */
+        open: function pdfViewOpen(file, args) {
+          if (this.pdfLoadingTask) {
+            // We need to destroy already opened document.
+            return this.close().then(function () {
+              // Reload the preferences if a document was previously opened.
+              Preferences.reload();
+              // ... and repeat the open() call.
+              return this.open(file, args);
+            }.bind(this));
+          }
+          var parameters = Object.create(null), scale;
+          if (typeof file === 'string') {
+            // URL
+            this.setTitleUsingUrl(file);
+            parameters.url = file;
+          } else if (file && 'byteLength' in file) {
+            // ArrayBuffer
+            parameters.data = file;
+          } else if (file.url && file.originalUrl) {
+            this.setTitleUsingUrl(file.originalUrl);
+            parameters.url = file.url;
+          }
+          parameters.docBaseUrl = this.baseUrl;
+          if (args) {
+            for (var prop in args) {
+              parameters[prop] = args[prop];
+            }
+            if (args.scale) {
+              scale = args.scale;
+            }
+            if (args.length) {
+              this.pdfDocumentProperties.setFileSize(args.length);
+            }
+          }
+          var self = this;
+          self.downloadComplete = false;
+          var loadingTask = pdfjsLib.getDocument(parameters);
+          this.pdfLoadingTask = loadingTask;
+          loadingTask.onPassword = function passwordNeeded(updateCallback, reason) {
+            self.passwordPrompt.setUpdateCallback(updateCallback, reason);
+            self.passwordPrompt.open();
+          };
+          loadingTask.onProgress = function getDocumentProgress(progressData) {
+            self.progress(progressData.loaded / progressData.total);
+          };
+          // Listen for unsupported features to trigger the fallback UI.
+          loadingTask.onUnsupportedFeature = this.fallback.bind(this);
+          return loadingTask.promise.then(function getDocumentCallback(pdfDocument) {
+            self.load(pdfDocument, scale);
+          }, function getDocumentError(exception) {
+            var message = exception && exception.message;
+            var loadingErrorMessage = mozL10n.get('loading_error', null, 'An error occurred while loading the PDF.');
+            if (exception instanceof pdfjsLib.InvalidPDFException) {
+              // change error message also for other builds
+              loadingErrorMessage = mozL10n.get('invalid_file_error', null, 'Invalid or corrupted PDF file.');
+            } else if (exception instanceof pdfjsLib.MissingPDFException) {
+              // special message for missing PDF's
+              loadingErrorMessage = mozL10n.get('missing_file_error', null, 'Missing PDF file.');
+            } else if (exception instanceof pdfjsLib.UnexpectedResponseException) {
+              loadingErrorMessage = mozL10n.get('unexpected_response_error', null, 'Unexpected server response.');
+            }
+            var moreInfo = { message: message };
+            self.error(loadingErrorMessage, moreInfo);
+            throw new Error(loadingErrorMessage);
+          });
+        },
+        download: function pdfViewDownload() {
+          function downloadByUrl() {
+            downloadManager.downloadUrl(url, filename);
+          }
+          var url = this.baseUrl;
+          var filename = getPDFFileNameFromURL(url);
+          var downloadManager = this.downloadManager;
+          downloadManager.onerror = function (err) {
+            // This error won't really be helpful because it's likely the
+            // fallback won't work either (or is already open).
+            PDFViewerApplication.error('PDF failed to download.');
+          };
+          if (!this.pdfDocument) {
+            // the PDF is not ready yet
+            downloadByUrl();
+            return;
+          }
+          if (!this.downloadComplete) {
+            // the PDF is still downloading
+            downloadByUrl();
+            return;
+          }
+          this.pdfDocument.getData().then(function getDataSuccess(data) {
+            var blob = pdfjsLib.createBlob(data, 'application/pdf');
+            downloadManager.download(blob, url, filename);
+          }, downloadByUrl).then(null, downloadByUrl);
+        },
+        fallback: function pdfViewFallback(featureId) {
+          // Only trigger the fallback once so we don't spam the user with messages
+          // for one PDF.
+          if (this.fellback) {
+            return;
+          }
+          this.fellback = true;
+          this.externalServices.fallback({
+            featureId: featureId,
+            url: this.baseUrl
+          }, function response(download) {
+            if (!download) {
+              return;
+            }
+            PDFViewerApplication.download();
+          });
+        },
+        /**
+         * Show the error box.
+         * @param {String} message A message that is human readable.
+         * @param {Object} moreInfo (optional) Further information about the error
+         *                            that is more technical.  Should have a 'message'
+         *                            and optionally a 'stack' property.
+         */
+        error: function pdfViewError(message, moreInfo) {
+          var moreInfoText = mozL10n.get('error_version_info', {
+            version: pdfjsLib.version || '?',
+            build: pdfjsLib.build || '?'
+          }, 'PDF.js v{{version}} (build: {{build}})') + '\n';
+          if (moreInfo) {
+            moreInfoText += mozL10n.get('error_message', { message: moreInfo.message }, 'Message: {{message}}');
+            if (moreInfo.stack) {
+              moreInfoText += '\n' + mozL10n.get('error_stack', { stack: moreInfo.stack }, 'Stack: {{stack}}');
+            } else {
+              if (moreInfo.filename) {
+                moreInfoText += '\n' + mozL10n.get('error_file', { file: moreInfo.filename }, 'File: {{file}}');
+              }
+              if (moreInfo.lineNumber) {
+                moreInfoText += '\n' + mozL10n.get('error_line', { line: moreInfo.lineNumber }, 'Line: {{line}}');
+              }
+            }
+          }
+          console.error(message + '\n' + moreInfoText);
+          this.fallback();
+        },
+        progress: function pdfViewProgress(level) {
+          var percent = Math.round(level * 100);
+          // When we transition from full request to range requests, it's possible
+          // that we discard some of the loaded data. This can cause the loading
+          // bar to move backwards. So prevent this by only updating the bar if it
+          // increases.
+          if (percent > this.loadingBar.percent || isNaN(percent)) {
+            this.loadingBar.percent = percent;
+            // When disableAutoFetch is enabled, it's not uncommon for the entire file
+            // to never be fetched (depends on e.g. the file structure). In this case
+            // the loading bar will not be completely filled, nor will it be hidden.
+            // To prevent displaying a partially filled loading bar permanently, we
+            // hide it when no data has been loaded during a certain amount of time.
+            if (pdfjsLib.PDFJS.disableAutoFetch && percent) {
+              if (this.disableAutoFetchLoadingBarTimeout) {
+                clearTimeout(this.disableAutoFetchLoadingBarTimeout);
+                this.disableAutoFetchLoadingBarTimeout = null;
+              }
+              this.loadingBar.show();
+              this.disableAutoFetchLoadingBarTimeout = setTimeout(function () {
+                this.loadingBar.hide();
+                this.disableAutoFetchLoadingBarTimeout = null;
+              }.bind(this), DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
+            }
+          }
+        },
+        load: function pdfViewLoad(pdfDocument, scale) {
+          var self = this;
+          scale = scale || UNKNOWN_SCALE;
+          this.pdfDocument = pdfDocument;
+          this.pdfDocumentProperties.setDocumentAndUrl(pdfDocument, this.url);
+          var downloadedPromise = pdfDocument.getDownloadInfo().then(function () {
+            self.downloadComplete = true;
+            self.loadingBar.hide();
+          });
+          this._updateUIToolbar({ resetNumPages: true });
+          var id = this.documentFingerprint = pdfDocument.fingerprint;
+          var store = this.store = new ViewHistory(id);
+          var baseDocumentUrl;
+          baseDocumentUrl = this.baseUrl;
+          this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
+          var pdfViewer = this.pdfViewer;
+          pdfViewer.currentScale = scale;
+          pdfViewer.setDocument(pdfDocument);
+          var firstPagePromise = pdfViewer.firstPagePromise;
+          var pagesPromise = pdfViewer.pagesPromise;
+          var onePageRendered = pdfViewer.onePageRendered;
+          this.pageRotation = 0;
+          var pdfThumbnailViewer = this.pdfThumbnailViewer;
+          pdfThumbnailViewer.setDocument(pdfDocument);
+          firstPagePromise.then(function (pdfPage) {
+            downloadedPromise.then(function () {
+              self.eventBus.dispatch('documentload', { source: self });
+            });
+            self.loadingBar.setWidth(self.appConfig.viewerContainer);
+            if (!pdfjsLib.PDFJS.disableHistory && !self.isViewerEmbedded) {
+              // The browsing history is only enabled when the viewer is standalone,
+              // i.e. not when it is embedded in a web page.
+              if (!self.preferenceShowPreviousViewOnLoad) {
+                self.pdfHistory.clearHistoryState();
+              }
+              self.pdfHistory.initialize(self.documentFingerprint);
+              if (self.pdfHistory.initialDestination) {
+                self.initialDestination = self.pdfHistory.initialDestination;
+              } else if (self.pdfHistory.initialBookmark) {
+                self.initialBookmark = self.pdfHistory.initialBookmark;
+              }
+            }
+            var initialParams = {
+              destination: self.initialDestination,
+              bookmark: self.initialBookmark,
+              hash: null
+            };
+            store.initializedPromise.then(function resolved() {
+              var storedHash = null, sidebarView = null;
+              if (self.preferenceShowPreviousViewOnLoad && store.get('exists', false)) {
+                var pageNum = store.get('page', '1');
+                var zoom = self.preferenceDefaultZoomValue || store.get('zoom', DEFAULT_SCALE_VALUE);
+                var left = store.get('scrollLeft', '0');
+                var top = store.get('scrollTop', '0');
+                storedHash = 'page=' + pageNum + '&zoom=' + zoom + ',' + left + ',' + top;
+                sidebarView = store.get('sidebarView', SidebarView.NONE);
+              } else if (self.preferenceDefaultZoomValue) {
+                storedHash = 'page=1&zoom=' + self.preferenceDefaultZoomValue;
+              }
+              self.setInitialView(storedHash, {
+                scale: scale,
+                sidebarView: sidebarView
+              });
+              initialParams.hash = storedHash;
+              // Make all navigation keys work on document load,
+              // unless the viewer is embedded in a web page.
+              if (!self.isViewerEmbedded) {
+                self.pdfViewer.focus();
+              }
+            }, function rejected(reason) {
+              console.error(reason);
+              self.setInitialView(null, { scale: scale });
+            });
+            // For documents with different page sizes,
+            // ensure that the correct location becomes visible on load.
+            pagesPromise.then(function resolved() {
+              if (!initialParams.destination && !initialParams.bookmark && !initialParams.hash) {
+                return;
+              }
+              if (self.hasEqualPageSizes) {
+                return;
+              }
+              self.initialDestination = initialParams.destination;
+              self.initialBookmark = initialParams.bookmark;
+              self.pdfViewer.currentScaleValue = self.pdfViewer.currentScaleValue;
+              self.setInitialView(initialParams.hash);
+            });
+          });
+          pdfDocument.getPageLabels().then(function (labels) {
+            if (!labels || self.preferenceDisablePageLabels) {
+              return;
+            }
+            var i = 0, numLabels = labels.length;
+            if (numLabels !== self.pagesCount) {
+              console.error('The number of Page Labels does not match ' + 'the number of pages in the document.');
+              return;
+            }
+            // Ignore page labels that correspond to standard page numbering.
+            while (i < numLabels && labels[i] === (i + 1).toString()) {
+              i++;
+            }
+            if (i === numLabels) {
+              return;
+            }
+            pdfViewer.setPageLabels(labels);
+            pdfThumbnailViewer.setPageLabels(labels);
+            self.hasPageLabels = true;
+            self._updateUIToolbar({ resetNumPages: true });
+          });
+          pagesPromise.then(function () {
+            if (self.supportsPrinting) {
+              pdfDocument.getJavaScript().then(function (javaScript) {
+                if (javaScript.length) {
+                  console.warn('Warning: JavaScript is not supported');
+                  self.fallback(pdfjsLib.UNSUPPORTED_FEATURES.javaScript);
+                }
+                // Hack to support auto printing.
+                var regex = /\bprint\s*\(/;
+                for (var i = 0, ii = javaScript.length; i < ii; i++) {
+                  var js = javaScript[i];
+                  if (js && regex.test(js)) {
+                    setTimeout(function () {
+                      window.print();
+                    });
+                    return;
+                  }
+                }
+              });
+            }
+          });
+          Promise.all([
+            onePageRendered,
+            this.animationStartedPromise
+          ]).then(function () {
+            pdfDocument.getOutline().then(function (outline) {
+              self.pdfOutlineViewer.render({ outline: outline });
+            });
+            pdfDocument.getAttachments().then(function (attachments) {
+              self.pdfAttachmentViewer.render({ attachments: attachments });
+            });
+          });
+          pdfDocument.getMetadata().then(function (data) {
+            var info = data.info, metadata = data.metadata;
+            self.documentInfo = info;
+            self.metadata = metadata;
+            // Provides some basic debug information
+            console.log('PDF ' + pdfDocument.fingerprint + ' [' + info.PDFFormatVersion + ' ' + (info.Producer || '-').trim() + ' / ' + (info.Creator || '-').trim() + ']' + ' (PDF.js: ' + (pdfjsLib.version || '-') + (!pdfjsLib.PDFJS.disableWebGL ? ' [WebGL]' : '') + ')');
+            var pdfTitle;
+            if (metadata && metadata.has('dc:title')) {
+              var title = metadata.get('dc:title');
+              // Ghostscript sometimes return 'Untitled', sets the title to 'Untitled'
+              if (title !== 'Untitled') {
+                pdfTitle = title;
+              }
+            }
+            if (!pdfTitle && info && info['Title']) {
+              pdfTitle = info['Title'];
+            }
+            if (pdfTitle) {
+              self.setTitle(pdfTitle + ' - ' + document.title);
+            }
+            if (info.IsAcroFormPresent) {
+              console.warn('Warning: AcroForm/XFA is not supported');
+              self.fallback(pdfjsLib.UNSUPPORTED_FEATURES.forms);
+            }
+            var versionId = String(info.PDFFormatVersion).slice(-1) | 0;
+            var generatorId = 0;
+            var KNOWN_GENERATORS = [
+              'acrobat distiller',
+              'acrobat pdfwriter',
+              'adobe livecycle',
+              'adobe pdf library',
+              'adobe photoshop',
+              'ghostscript',
+              'tcpdf',
+              'cairo',
+              'dvipdfm',
+              'dvips',
+              'pdftex',
+              'pdfkit',
+              'itext',
+              'prince',
+              'quarkxpress',
+              'mac os x',
+              'microsoft',
+              'openoffice',
+              'oracle',
+              'luradocument',
+              'pdf-xchange',
+              'antenna house',
+              'aspose.cells',
+              'fpdf'
+            ];
+            if (info.Producer) {
+              KNOWN_GENERATORS.some(function (generator, s, i) {
+                if (generator.indexOf(s) < 0) {
+                  return false;
+                }
+                generatorId = i + 1;
+                return true;
+              }.bind(null, info.Producer.toLowerCase()));
+            }
+            var formType = !info.IsAcroFormPresent ? null : info.IsXFAPresent ? 'xfa' : 'acroform';
+            self.externalServices.reportTelemetry({
+              type: 'documentInfo',
+              version: versionId,
+              generator: generatorId,
+              formType: formType
+            });
+          });
+        },
+        setInitialView: function pdfViewSetInitialView(storedHash, options) {
+          var scale = options && options.scale;
+          var sidebarView = options && options.sidebarView;
+          this.isInitialViewSet = true;
+          this.pdfSidebar.setInitialView(this.preferenceSidebarViewOnLoad || sidebarView | 0);
+          if (this.initialDestination) {
+            this.pdfLinkService.navigateTo(this.initialDestination);
+            this.initialDestination = null;
+          } else if (this.initialBookmark) {
+            this.pdfLinkService.setHash(this.initialBookmark);
+            this.pdfHistory.push({ hash: this.initialBookmark }, true);
+            this.initialBookmark = null;
+          } else if (storedHash) {
+            this.pdfLinkService.setHash(storedHash);
+          } else if (scale) {
+            this.pdfViewer.currentScaleValue = scale;
+            this.page = 1;
+          }
+          if (!this.pdfViewer.currentScaleValue) {
+            // Scale was not initialized: invalid bookmark or scale was not specified.
+            // Setting the default one.
+            this.pdfViewer.currentScaleValue = DEFAULT_SCALE_VALUE;
+          }
+        },
+        cleanup: function pdfViewCleanup() {
+          if (!this.pdfDocument) {
+            return;
+          }
+          // run cleanup when document is loaded
+          this.pdfViewer.cleanup();
+          this.pdfThumbnailViewer.cleanup();
+          this.pdfDocument.cleanup();
+        },
+        forceRendering: function pdfViewForceRendering() {
+          this.pdfRenderingQueue.printing = this.printing;
+          this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar.isThumbnailViewVisible;
+          this.pdfRenderingQueue.renderHighestPriority();
+        },
+        beforePrint: function pdfViewSetupBeforePrint() {
+          if (this.printService) {
+            // There is no way to suppress beforePrint/afterPrint events,
+            // but PDFPrintService may generate double events -- this will ignore
+            // the second event that will be coming from native window.print().
+            return;
+          }
+          if (!this.supportsPrinting) {
+            var printMessage = mozL10n.get('printing_not_supported', null, 'Warning: Printing is not fully supported by this browser.');
+            this.error(printMessage);
+            return;
+          }
+          // The beforePrint is a sync method and we need to know layout before
+          // returning from this method. Ensure that we can get sizes of the pages.
+          if (!this.pdfViewer.pageViewsReady) {
+            var notReadyMessage = mozL10n.get('printing_not_ready', null, 'Warning: The PDF is not fully loaded for printing.');
+            window.alert(notReadyMessage);
+            return;
+          }
+          var pagesOverview = this.pdfViewer.getPagesOverview();
+          var printContainer = this.appConfig.printContainer;
+          var printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument, pagesOverview, printContainer);
+          this.printService = printService;
+          this.forceRendering();
+          printService.layout();
+          this.externalServices.reportTelemetry({ type: 'print' });
+        },
+        // Whether all pages of the PDF have the same width and height.
+        get hasEqualPageSizes() {
+          var firstPage = this.pdfViewer.getPageView(0);
+          for (var i = 1, ii = this.pagesCount; i < ii; ++i) {
+            var pageView = this.pdfViewer.getPageView(i);
+            if (pageView.width !== firstPage.width || pageView.height !== firstPage.height) {
+              return false;
+            }
+          }
+          return true;
+        },
+        afterPrint: function pdfViewSetupAfterPrint() {
+          if (this.printService) {
+            this.printService.destroy();
+            this.printService = null;
+          }
+          this.forceRendering();
+        },
+        rotatePages: function pdfViewRotatePages(delta) {
+          var pageNumber = this.page;
+          this.pageRotation = (this.pageRotation + 360 + delta) % 360;
+          this.pdfViewer.pagesRotation = this.pageRotation;
+          this.pdfThumbnailViewer.pagesRotation = this.pageRotation;
+          this.forceRendering();
+          this.pdfViewer.currentPageNumber = pageNumber;
+        },
+        requestPresentationMode: function pdfViewRequestPresentationMode() {
+          if (!this.pdfPresentationMode) {
+            return;
+          }
+          this.pdfPresentationMode.request();
+        },
+        /**
+         * @typedef UpdateUIToolbarParameters
+         * @property {number} pageNumber
+         * @property {string} pageLabel
+         * @property {string} scaleValue
+         * @property {number} scale
+         * @property {boolean} resetNumPages
+         */
+        /**
+         * @param {Object} UpdateUIToolbarParameters
+         * @private
+         */
+        _updateUIToolbar: function (params) {
+          function selectScaleOption(value, scale) {
+            var options = toolbarConfig.scaleSelect.options;
+            var predefinedValueFound = false;
+            for (var i = 0, ii = options.length; i < ii; i++) {
+              var option = options[i];
+              if (option.value !== value) {
+                option.selected = false;
+                continue;
+              }
+              option.selected = true;
+              predefinedValueFound = true;
+            }
+            if (!predefinedValueFound) {
+              var customScale = Math.round(scale * 10000) / 100;
+              toolbarConfig.customScaleOption.textContent = mozL10n.get('page_scale_percent', { scale: customScale }, '{{scale}}%');
+              toolbarConfig.customScaleOption.selected = true;
+            }
+          }
+          var pageNumber = params.pageNumber || this.pdfViewer.currentPageNumber;
+          var scaleValue = (params.scaleValue || params.scale || this.pdfViewer.currentScaleValue || DEFAULT_SCALE_VALUE).toString();
+          var scale = params.scale || this.pdfViewer.currentScale;
+          var resetNumPages = params.resetNumPages || false;
+          var toolbarConfig = this.appConfig.toolbar;
+          var pagesCount = this.pagesCount;
+          if (resetNumPages) {
+            if (this.hasPageLabels) {
+              toolbarConfig.pageNumber.type = 'text';
+            } else {
+              toolbarConfig.pageNumber.type = 'number';
+              toolbarConfig.numPages.textContent = mozL10n.get('of_pages', { pagesCount: pagesCount }, 'of {{pagesCount}}');
+            }
+            toolbarConfig.pageNumber.max = pagesCount;
+          }
+          if (this.hasPageLabels) {
+            toolbarConfig.pageNumber.value = params.pageLabel || this.pdfViewer.currentPageLabel;
+            toolbarConfig.numPages.textContent = mozL10n.get('page_of_pages', {
+              pageNumber: pageNumber,
+              pagesCount: pagesCount
+            }, '({{pageNumber}} of {{pagesCount}})');
+          } else {
+            toolbarConfig.pageNumber.value = pageNumber;
+          }
+          toolbarConfig.previous.disabled = pageNumber <= 1;
+          toolbarConfig.next.disabled = pageNumber >= pagesCount;
+          toolbarConfig.firstPage.disabled = pageNumber <= 1;
+          toolbarConfig.lastPage.disabled = pageNumber >= pagesCount;
+          toolbarConfig.zoomOut.disabled = scale <= MIN_SCALE;
+          toolbarConfig.zoomIn.disabled = scale >= MAX_SCALE;
+          selectScaleOption(scaleValue, scale);
+        },
+        bindEvents: function pdfViewBindEvents() {
+          var eventBus = this.eventBus;
+          eventBus.on('resize', webViewerResize);
+          eventBus.on('localized', webViewerLocalized);
+          eventBus.on('hashchange', webViewerHashchange);
+          eventBus.on('beforeprint', this.beforePrint.bind(this));
+          eventBus.on('afterprint', this.afterPrint.bind(this));
+          eventBus.on('pagerendered', webViewerPageRendered);
+          eventBus.on('textlayerrendered', webViewerTextLayerRendered);
+          eventBus.on('updateviewarea', webViewerUpdateViewarea);
+          eventBus.on('pagechanging', webViewerPageChanging);
+          eventBus.on('scalechanging', webViewerScaleChanging);
+          eventBus.on('sidebarviewchanged', webViewerSidebarViewChanged);
+          eventBus.on('pagemode', webViewerPageMode);
+          eventBus.on('namedaction', webViewerNamedAction);
+          eventBus.on('presentationmodechanged', webViewerPresentationModeChanged);
+          eventBus.on('presentationmode', webViewerPresentationMode);
+          eventBus.on('openfile', webViewerOpenFile);
+          eventBus.on('print', webViewerPrint);
+          eventBus.on('download', webViewerDownload);
+          eventBus.on('firstpage', webViewerFirstPage);
+          eventBus.on('lastpage', webViewerLastPage);
+          eventBus.on('rotatecw', webViewerRotateCw);
+          eventBus.on('rotateccw', webViewerRotateCcw);
+          eventBus.on('documentproperties', webViewerDocumentProperties);
+          eventBus.on('find', webViewerFind);
+          eventBus.on('findfromurlhash', webViewerFindFromUrlHash);
+        }
+      };
+      var validateFileURL;
+      function loadAndEnablePDFBug(enabledTabs) {
+        return new Promise(function (resolve, reject) {
+          var appConfig = PDFViewerApplication.appConfig;
+          var script = document.createElement('script');
+          script.src = appConfig.debuggerScriptPath;
+          script.onload = function () {
+            PDFBug.enable(enabledTabs);
+            PDFBug.init(pdfjsLib, appConfig.mainContainer);
+            resolve();
+          };
+          script.onerror = function () {
+            reject(new Error('Cannot load debugger at ' + script.src));
+          };
+          (document.getElementsByTagName('head')[0] || document.body).appendChild(script);
+        });
+      }
+      function webViewerInitialized() {
+        var file;
+        file = window.location.href.split('#')[0];
+        var waitForBeforeOpening = [];
+        var appConfig = PDFViewerApplication.appConfig;
+        appConfig.toolbar.openFile.setAttribute('hidden', 'true');
+        appConfig.secondaryToolbar.openFileButton.setAttribute('hidden', 'true');
+        var PDFJS = pdfjsLib.PDFJS;
+        if (PDFViewerApplication.preferencePdfBugEnabled) {
+          // Special debugging flags in the hash section of the URL.
+          var hash = document.location.hash.substring(1);
+          var hashParams = parseQueryString(hash);
+          if ('disableworker' in hashParams) {
+            PDFJS.disableWorker = hashParams['disableworker'] === 'true';
+          }
+          if ('disablerange' in hashParams) {
+            PDFJS.disableRange = hashParams['disablerange'] === 'true';
+          }
+          if ('disablestream' in hashParams) {
+            PDFJS.disableStream = hashParams['disablestream'] === 'true';
+          }
+          if ('disableautofetch' in hashParams) {
+            PDFJS.disableAutoFetch = hashParams['disableautofetch'] === 'true';
+          }
+          if ('disablefontface' in hashParams) {
+            PDFJS.disableFontFace = hashParams['disablefontface'] === 'true';
+          }
+          if ('disablehistory' in hashParams) {
+            PDFJS.disableHistory = hashParams['disablehistory'] === 'true';
+          }
+          if ('webgl' in hashParams) {
+            PDFJS.disableWebGL = hashParams['webgl'] !== 'true';
+          }
+          if ('useonlycsszoom' in hashParams) {
+            PDFJS.useOnlyCssZoom = hashParams['useonlycsszoom'] === 'true';
+          }
+          if ('verbosity' in hashParams) {
+            PDFJS.verbosity = hashParams['verbosity'] | 0;
+          }
+          if ('ignorecurrentpositiononzoom' in hashParams) {
+            PDFJS.ignoreCurrentPositionOnZoom = hashParams['ignorecurrentpositiononzoom'] === 'true';
+          }
+          if ('textlayer' in hashParams) {
+            switch (hashParams['textlayer']) {
+            case 'off':
+              PDFJS.disableTextLayer = true;
+              break;
+            case 'visible':
+            case 'shadow':
+            case 'hover':
+              var viewer = appConfig.viewerContainer;
+              viewer.classList.add('textLayer-' + hashParams['textlayer']);
+              break;
+            }
+          }
+          if ('pdfbug' in hashParams) {
+            PDFJS.pdfBug = true;
+            var pdfBug = hashParams['pdfbug'];
+            var enabled = pdfBug.split(',');
+            waitForBeforeOpening.push(loadAndEnablePDFBug(enabled));
+          }
+        }
+        if (!PDFViewerApplication.supportsDocumentFonts) {
+          PDFJS.disableFontFace = true;
+          console.warn(mozL10n.get('web_fonts_disabled', null, 'Web fonts are disabled: unable to use embedded PDF fonts.'));
+        }
+        if (!PDFViewerApplication.supportsPrinting) {
+          appConfig.toolbar.print.classList.add('hidden');
+          appConfig.secondaryToolbar.printButton.classList.add('hidden');
+        }
+        if (!PDFViewerApplication.supportsFullscreen) {
+          appConfig.toolbar.presentationModeButton.classList.add('hidden');
+          appConfig.secondaryToolbar.presentationModeButton.classList.add('hidden');
+        }
+        if (PDFViewerApplication.supportsIntegratedFind) {
+          appConfig.toolbar.viewFind.classList.add('hidden');
+        }
+        // Suppress context menus for some controls
+        appConfig.toolbar.scaleSelect.oncontextmenu = noContextMenuHandler;
+        appConfig.sidebar.mainContainer.addEventListener('transitionend', function (e) {
+          if (e.target === /* mainContainer */
+            this) {
+            PDFViewerApplication.eventBus.dispatch('resize');
+          }
+        }, true);
+        appConfig.sidebar.toggleButton.addEventListener('click', function () {
+          PDFViewerApplication.pdfSidebar.toggle();
+        });
+        appConfig.toolbar.previous.addEventListener('click', function () {
+          PDFViewerApplication.page--;
+        });
+        appConfig.toolbar.next.addEventListener('click', function () {
+          PDFViewerApplication.page++;
+        });
+        appConfig.toolbar.zoomIn.addEventListener('click', function () {
+          PDFViewerApplication.zoomIn();
+        });
+        appConfig.toolbar.zoomOut.addEventListener('click', function () {
+          PDFViewerApplication.zoomOut();
+        });
+        appConfig.toolbar.pageNumber.addEventListener('click', function () {
+          this.select();
+        });
+        appConfig.toolbar.pageNumber.addEventListener('change', function () {
+          var pdfViewer = PDFViewerApplication.pdfViewer;
+          pdfViewer.currentPageLabel = this.value;
+          // Ensure that the page number input displays the correct value, even if the
+          // value entered by the user was invalid (e.g. a floating point number).
+          if (this.value !== pdfViewer.currentPageNumber.toString() && this.value !== pdfViewer.currentPageLabel) {
+            PDFViewerApplication._updateUIToolbar({});
+          }
+        });
+        appConfig.toolbar.scaleSelect.addEventListener('change', function () {
+          if (this.value === 'custom') {
+            return;
+          }
+          PDFViewerApplication.pdfViewer.currentScaleValue = this.value;
+        });
+        appConfig.toolbar.presentationModeButton.addEventListener('click', function (e) {
+          PDFViewerApplication.eventBus.dispatch('presentationmode');
+        });
+        appConfig.toolbar.openFile.addEventListener('click', function (e) {
+          PDFViewerApplication.eventBus.dispatch('openfile');
+        });
+        appConfig.toolbar.print.addEventListener('click', function (e) {
+          PDFViewerApplication.eventBus.dispatch('print');
+        });
+        appConfig.toolbar.download.addEventListener('click', function (e) {
+          PDFViewerApplication.eventBus.dispatch('download');
+        });
+        Promise.all(waitForBeforeOpening).then(function () {
+          webViewerOpenFileViaURL(file);
+        }).catch(function (reason) {
+          PDFViewerApplication.error(mozL10n.get('loading_error', null, 'An error occurred while opening.'), reason);
+        });
+      }
+      var webViewerOpenFileViaURL;
+      webViewerOpenFileViaURL = function webViewerOpenFileViaURL(file) {
+        PDFViewerApplication.setTitleUsingUrl(file);
+        PDFViewerApplication.initPassiveLoading();
+      };
+      function webViewerPageRendered(e) {
+        var pageNumber = e.pageNumber;
+        var pageIndex = pageNumber - 1;
+        var pageView = PDFViewerApplication.pdfViewer.getPageView(pageIndex);
+        // If the page is still visible when it has finished rendering,
+        // ensure that the page number input loading indicator is hidden.
+        if (pageNumber === PDFViewerApplication.page) {
+          var pageNumberInput = PDFViewerApplication.appConfig.toolbar.pageNumber;
+          pageNumberInput.classList.remove(PAGE_NUMBER_LOADING_INDICATOR);
+        }
+        // Prevent errors in the edge-case where the PDF document is removed *before*
+        // the 'pagerendered' event handler is invoked.
+        if (!pageView) {
+          return;
+        }
+        // Use the rendered page to set the corresponding thumbnail image.
+        if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
+          var thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageIndex);
+          thumbnailView.setImage(pageView);
+        }
+        if (pdfjsLib.PDFJS.pdfBug && Stats.enabled && pageView.stats) {
+          Stats.add(pageNumber, pageView.stats);
+        }
+        if (pageView.error) {
+          PDFViewerApplication.error(mozL10n.get('rendering_error', null, 'An error occurred while rendering the page.'), pageView.error);
+        }
+        PDFViewerApplication.externalServices.reportTelemetry({ type: 'pageInfo' });
+        // It is a good time to report stream and font types.
+        PDFViewerApplication.pdfDocument.getStats().then(function (stats) {
+          PDFViewerApplication.externalServices.reportTelemetry({
+            type: 'documentStats',
+            stats: stats
+          });
+        });
+      }
+      function webViewerTextLayerRendered(e) {
+        if (e.numTextDivs > 0 && !PDFViewerApplication.supportsDocumentColors) {
+          console.error(mozL10n.get('document_colors_not_allowed', null, 'PDF documents are not allowed to use their own colors: ' + '\'Allow pages to choose their own colors\' ' + 'is deactivated in the browser.'));
+          PDFViewerApplication.fallback();
+        }
+      }
+      function webViewerPageMode(e) {
+        if (!PDFViewerApplication.initialized) {
+          return;
+        }
+        // Handle the 'pagemode' hash parameter, see also `PDFLinkService_setHash`.
+        var mode = e.mode, view;
+        switch (mode) {
+        case 'thumbs':
+          view = SidebarView.THUMBS;
+          break;
+        case 'bookmarks':
+        case 'outline':
+          view = SidebarView.OUTLINE;
+          break;
+        case 'attachments':
+          view = SidebarView.ATTACHMENTS;
+          break;
+        case 'none':
+          view = SidebarView.NONE;
+          break;
+        default:
+          console.error('Invalid "pagemode" hash parameter: ' + mode);
+          return;
+        }
+        PDFViewerApplication.pdfSidebar.switchView(view, /* forceOpen = */
+        true);
+      }
+      function webViewerNamedAction(e) {
+        if (!PDFViewerApplication.initialized) {
+          return;
+        }
+        // Processing couple of named actions that might be useful.
+        // See also PDFLinkService.executeNamedAction
+        var action = e.action;
+        switch (action) {
+        case 'GoToPage':
+          PDFViewerApplication.appConfig.toolbar.pageNumber.select();
+          break;
+        case 'Find':
+          if (!PDFViewerApplication.supportsIntegratedFind) {
+            PDFViewerApplication.findBar.toggle();
+          }
+          break;
+        }
+      }
+      function webViewerPresentationModeChanged(e) {
+        var active = e.active;
+        var switchInProgress = e.switchInProgress;
+        PDFViewerApplication.pdfViewer.presentationModeState = switchInProgress ? PresentationModeState.CHANGING : active ? PresentationModeState.FULLSCREEN : PresentationModeState.NORMAL;
+      }
+      function webViewerSidebarViewChanged(e) {
+        if (!PDFViewerApplication.initialized) {
+          return;
+        }
+        PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication.pdfSidebar.isThumbnailViewVisible;
+        var store = PDFViewerApplication.store;
+        if (!store || !PDFViewerApplication.isInitialViewSet) {
+          // Only update the storage when the document has been loaded *and* rendered.
+          return;
+        }
+        store.initializedPromise.then(function () {
+          store.set('sidebarView', e.view).catch(function () {
+          });
+        });
+      }
+      function webViewerUpdateViewarea(e) {
+        if (!PDFViewerApplication.initialized) {
+          return;
+        }
+        var location = e.location, store = PDFViewerApplication.store;
+        if (store) {
+          store.initializedPromise.then(function () {
+            store.setMultiple({
+              'exists': true,
+              'page': location.pageNumber,
+              'zoom': location.scale,
+              'scrollLeft': location.left,
+              'scrollTop': location.top
+            }).catch(function () {
+            });
+          });
+        }
+        var href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
+        PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
+        PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
+        // Update the current bookmark in the browsing history.
+        PDFViewerApplication.pdfHistory.updateCurrentBookmark(location.pdfOpenParams, location.pageNumber);
+        // Show/hide the loading indicator in the page number input element.
+        var pageNumberInput = PDFViewerApplication.appConfig.toolbar.pageNumber;
+        var currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
+        if (currentPage.renderingState === RenderingStates.FINISHED) {
+          pageNumberInput.classList.remove(PAGE_NUMBER_LOADING_INDICATOR);
+        } else {
+          pageNumberInput.classList.add(PAGE_NUMBER_LOADING_INDICATOR);
+        }
+      }
+      window.addEventListener('resize', function webViewerResize(evt) {
+        if (!PDFViewerApplication.eventBus) {
+          return;
+        }
+        PDFViewerApplication.eventBus.dispatch('resize');
+      });
+      function webViewerResize() {
+        if (PDFViewerApplication.initialized) {
+          var currentScaleValue = PDFViewerApplication.pdfViewer.currentScaleValue;
+          if (currentScaleValue === 'auto' || currentScaleValue === 'page-fit' || currentScaleValue === 'page-width') {
+            // Note: the scale is constant for 'page-actual'.
+            PDFViewerApplication.pdfViewer.currentScaleValue = currentScaleValue;
+          } else if (!currentScaleValue) {
+            // Normally this shouldn't happen, but if the scale wasn't initialized
+            // we set it to the default value in order to prevent any issues.
+            // (E.g. the document being rendered with the wrong scale on load.)
+            PDFViewerApplication.pdfViewer.currentScaleValue = DEFAULT_SCALE_VALUE;
+          }
+          PDFViewerApplication.pdfViewer.update();
+        }
+      }
+      window.addEventListener('hashchange', function webViewerHashchange(evt) {
+        var hash = document.location.hash.substring(1);
+        PDFViewerApplication.eventBus.dispatch('hashchange', { hash: hash });
+      });
+      function webViewerHashchange(e) {
+        if (PDFViewerApplication.pdfHistory.isHashChangeUnlocked) {
+          var hash = e.hash;
+          if (!hash) {
+            return;
+          }
+          if (!PDFViewerApplication.isInitialViewSet) {
+            PDFViewerApplication.initialBookmark = hash;
+          } else {
+            PDFViewerApplication.pdfLinkService.setHash(hash);
+          }
+        }
+      }
+      var webViewerFileInputChange;
+      window.addEventListener('localized', function localized(evt) {
+        PDFViewerApplication.eventBus.dispatch('localized');
+      });
+      function webViewerLocalized() {
+        document.getElementsByTagName('html')[0].dir = mozL10n.getDirection();
+        PDFViewerApplication.animationStartedPromise.then(function () {
+          // Adjust the width of the zoom box to fit the content.
+          // Note: If the window is narrow enough that the zoom box is not visible,
+          //       we temporarily show it to be able to adjust its width.
+          var container = PDFViewerApplication.appConfig.toolbar.scaleSelectContainer;
+          if (container.clientWidth === 0) {
+            container.setAttribute('style', 'display: inherit;');
+          }
+          if (container.clientWidth > 0) {
+            var select = PDFViewerApplication.appConfig.toolbar.scaleSelect;
+            select.setAttribute('style', 'min-width: inherit;');
+            var width = select.clientWidth + SCALE_SELECT_CONTAINER_PADDING;
+            select.setAttribute('style', 'min-width: ' + (width + SCALE_SELECT_PADDING) + 'px;');
+            container.setAttribute('style', 'min-width: ' + width + 'px; ' + 'max-width: ' + width + 'px;');
+          }
+        });
+      }
+      function webViewerPresentationMode() {
+        PDFViewerApplication.requestPresentationMode();
+      }
+      function webViewerOpenFile() {
+        var openFileInputName = PDFViewerApplication.appConfig.openFileInputName;
+        document.getElementById(openFileInputName).click();
+      }
+      function webViewerPrint() {
+        window.print();
+      }
+      function webViewerDownload() {
+        PDFViewerApplication.download();
+      }
+      function webViewerFirstPage() {
+        if (PDFViewerApplication.pdfDocument) {
+          PDFViewerApplication.page = 1;
+        }
+      }
+      function webViewerLastPage() {
+        if (PDFViewerApplication.pdfDocument) {
+          PDFViewerApplication.page = PDFViewerApplication.pagesCount;
+        }
+      }
+      function webViewerRotateCw() {
+        PDFViewerApplication.rotatePages(90);
+      }
+      function webViewerRotateCcw() {
+        PDFViewerApplication.rotatePages(-90);
+      }
+      function webViewerDocumentProperties() {
+        PDFViewerApplication.pdfDocumentProperties.open();
+      }
+      function webViewerFind(e) {
+        PDFViewerApplication.findController.executeCommand('find' + e.type, {
+          query: e.query,
+          phraseSearch: e.phraseSearch,
+          caseSensitive: e.caseSensitive,
+          highlightAll: e.highlightAll,
+          findPrevious: e.findPrevious
+        });
+      }
+      function webViewerFindFromUrlHash(e) {
+        PDFViewerApplication.findController.executeCommand('find', {
+          query: e.query,
+          phraseSearch: e.phraseSearch,
+          caseSensitive: false,
+          highlightAll: true,
+          findPrevious: false
+        });
+      }
+      function webViewerScaleChanging(e) {
+        PDFViewerApplication._updateUIToolbar({
+          scaleValue: e.presetValue,
+          scale: e.scale
+        });
+        if (!PDFViewerApplication.initialized) {
+          return;
+        }
+        PDFViewerApplication.pdfViewer.update();
+      }
+      function webViewerPageChanging(e) {
+        var page = e.pageNumber;
+        PDFViewerApplication._updateUIToolbar({
+          pageNumber: page,
+          pageLabel: e.pageLabel
+        });
+        if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
+          PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(page);
+        }
+        // we need to update stats
+        if (pdfjsLib.PDFJS.pdfBug && Stats.enabled) {
+          var pageView = PDFViewerApplication.pdfViewer.getPageView(page - 1);
+          if (pageView.stats) {
+            Stats.add(page, pageView.stats);
+          }
+        }
+      }
+      var zoomDisabled = false, zoomDisabledTimeout;
+      function handleMouseWheel(evt) {
+        var pdfViewer = PDFViewerApplication.pdfViewer;
+        if (!pdfViewer || pdfViewer.isInPresentationMode) {
+          return;
+        }
+        if (evt.ctrlKey || evt.metaKey) {
+          var support = PDFViewerApplication.supportedMouseWheelZoomModifierKeys;
+          if (evt.ctrlKey && !support.ctrlKey || evt.metaKey && !support.metaKey) {
+            return;
+          }
+          // Only zoom the pages, not the entire viewer.
+          evt.preventDefault();
+          // NOTE: this check must be placed *after* preventDefault.
+          if (zoomDisabled) {
+            return;
+          }
+          var previousScale = pdfViewer.currentScale;
+          var delta = normalizeWheelEventDelta(evt);
+          var MOUSE_WHEEL_DELTA_PER_PAGE_SCALE = 3.0;
+          var ticks = delta * MOUSE_WHEEL_DELTA_PER_PAGE_SCALE;
+          if (ticks < 0) {
+            PDFViewerApplication.zoomOut(-ticks);
+          } else {
+            PDFViewerApplication.zoomIn(ticks);
+          }
+          var currentScale = pdfViewer.currentScale;
+          if (previousScale !== currentScale) {
+            // After scaling the page via zoomIn/zoomOut, the position of the upper-
+            // left corner is restored. When the mouse wheel is used, the position
+            // under the cursor should be restored instead.
+            var scaleCorrectionFactor = currentScale / previousScale - 1;
+            var rect = pdfViewer.container.getBoundingClientRect();
+            var dx = evt.clientX - rect.left;
+            var dy = evt.clientY - rect.top;
+            pdfViewer.container.scrollLeft += dx * scaleCorrectionFactor;
+            pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
+          }
+        } else {
+          zoomDisabled = true;
+          clearTimeout(zoomDisabledTimeout);
+          zoomDisabledTimeout = setTimeout(function () {
+            zoomDisabled = false;
+          }, 1000);
+        }
+      }
+      window.addEventListener('wheel', handleMouseWheel);
+      window.addEventListener('click', function click(evt) {
+        if (!PDFViewerApplication.secondaryToolbar.isOpen) {
+          return;
+        }
+        var appConfig = PDFViewerApplication.appConfig;
+        if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
+          PDFViewerApplication.secondaryToolbar.close();
+        }
+      }, true);
+      window.addEventListener('keydown', function keydown(evt) {
+        if (OverlayManager.active) {
+          return;
+        }
+        var handled = false;
+        var cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 : 0);
+        var pdfViewer = PDFViewerApplication.pdfViewer;
+        var isViewerInPresentationMode = pdfViewer && pdfViewer.isInPresentationMode;
+        // First, handle the key bindings that are independent whether an input
+        // control is selected or not.
+        if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
+          // either CTRL or META key with optional SHIFT.
+          switch (evt.keyCode) {
+          case 70:
+            // f
+            if (!PDFViewerApplication.supportsIntegratedFind) {
+              PDFViewerApplication.findBar.open();
+              handled = true;
+            }
+            break;
+          case 71:
+            // g
+            if (!PDFViewerApplication.supportsIntegratedFind) {
+              var findState = PDFViewerApplication.findController.state;
+              if (findState) {
+                PDFViewerApplication.findController.executeCommand('findagain', {
+                  query: findState.query,
+                  phraseSearch: findState.phraseSearch,
+                  caseSensitive: findState.caseSensitive,
+                  highlightAll: findState.highlightAll,
+                  findPrevious: cmd === 5 || cmd === 12
+                });
+              }
+              handled = true;
+            }
+            break;
+          case 61:
+          // FF/Mac '='
+          case 107:
+          // FF '+' and '='
+          case 187:
+          // Chrome '+'
+          case 171:
+            // FF with German keyboard
+            if (!isViewerInPresentationMode) {
+              PDFViewerApplication.zoomIn();
+            }
+            handled = true;
+            break;
+          case 173:
+          // FF/Mac '-'
+          case 109:
+          // FF '-'
+          case 189:
+            // Chrome '-'
+            if (!isViewerInPresentationMode) {
+              PDFViewerApplication.zoomOut();
+            }
+            handled = true;
+            break;
+          case 48:
+          // '0'
+          case 96:
+            // '0' on Numpad of Swedish keyboard
+            if (!isViewerInPresentationMode) {
+              // keeping it unhandled (to restore page zoom to 100%)
+              setTimeout(function () {
+                // ... and resetting the scale after browser adjusts its scale
+                pdfViewer.currentScaleValue = DEFAULT_SCALE_VALUE;
+              });
+              handled = false;
+            }
+            break;
+          }
+        }
+        // CTRL+ALT or Option+Command
+        if (cmd === 3 || cmd === 10) {
+          switch (evt.keyCode) {
+          case 80:
+            // p
+            PDFViewerApplication.requestPresentationMode();
+            handled = true;
+            break;
+          case 71:
+            // g
+            // focuses input#pageNumber field
+            PDFViewerApplication.appConfig.toolbar.pageNumber.select();
+            handled = true;
+            break;
+          }
+        }
+        if (handled) {
+          evt.preventDefault();
+          return;
+        }
+        // Some shortcuts should not get handled if a control/input element
+        // is selected.
+        var curElement = document.activeElement || document.querySelector(':focus');
+        var curElementTagName = curElement && curElement.tagName.toUpperCase();
+        if (curElementTagName === 'INPUT' || curElementTagName === 'TEXTAREA' || curElementTagName === 'SELECT') {
+          // Make sure that the secondary toolbar is closed when Escape is pressed.
+          if (evt.keyCode !== 27) {
+            // 'Esc'
+            return;
+          }
+        }
+        var ensureViewerFocused = false;
+        if (cmd === 0) {
+          // no control key pressed at all.
+          switch (evt.keyCode) {
+          case 38:
+          // up arrow
+          case 33:
+          // pg up
+          case 8:
+            // backspace
+            if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
+              break;
+            }
+          /* in presentation mode */
+          case 37:
+            // left arrow
+            // horizontal scrolling using arrow keys
+            if (pdfViewer.isHorizontalScrollbarEnabled) {
+              break;
+            }
+          case 75:
+          // 'k'
+          case 80:
+            // 'p'
+            if (PDFViewerApplication.page > 1) {
+              PDFViewerApplication.page--;
+            }
+            handled = true;
+            break;
+          case 27:
+            // esc key
+            if (PDFViewerApplication.secondaryToolbar.isOpen) {
+              PDFViewerApplication.secondaryToolbar.close();
+              handled = true;
+            }
+            if (!PDFViewerApplication.supportsIntegratedFind && PDFViewerApplication.findBar.opened) {
+              PDFViewerApplication.findBar.close();
+              handled = true;
+            }
+            break;
+          case 40:
+          // down arrow
+          case 34:
+          // pg down
+          case 32:
+            // spacebar
+            if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
+              break;
+            }
+          case 39:
+            // right arrow
+            // horizontal scrolling using arrow keys
+            if (pdfViewer.isHorizontalScrollbarEnabled) {
+              break;
+            }
+          case 74:
+          // 'j'
+          case 78:
+            // 'n'
+            if (PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
+              PDFViewerApplication.page++;
+            }
+            handled = true;
+            break;
+          case 36:
+            // home
+            if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
+              PDFViewerApplication.page = 1;
+              handled = true;
+              ensureViewerFocused = true;
+            }
+            break;
+          case 35:
+            // end
+            if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
+              PDFViewerApplication.page = PDFViewerApplication.pagesCount;
+              handled = true;
+              ensureViewerFocused = true;
+            }
+            break;
+          case 72:
+            // 'h'
+            if (!isViewerInPresentationMode) {
+              PDFViewerApplication.handTool.toggle();
+            }
+            break;
+          case 82:
+            // 'r'
+            PDFViewerApplication.rotatePages(90);
+            break;
+          }
+        }
+        if (cmd === 4) {
+          // shift-key
+          switch (evt.keyCode) {
+          case 32:
+            // spacebar
+            if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
+              break;
+            }
+            if (PDFViewerApplication.page > 1) {
+              PDFViewerApplication.page--;
+            }
+            handled = true;
+            break;
+          case 82:
+            // 'r'
+            PDFViewerApplication.rotatePages(-90);
+            break;
+          }
+        }
+        if (!handled && !isViewerInPresentationMode) {
+          // 33=Page Up  34=Page Down  35=End    36=Home
+          // 37=Left     38=Up         39=Right  40=Down
+          // 32=Spacebar
+          if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 && curElementTagName !== 'BUTTON') {
+            ensureViewerFocused = true;
+          }
+        }
+        if (cmd === 2) {
+          // alt-key
+          switch (evt.keyCode) {
+          case 37:
+            // left arrow
+            if (isViewerInPresentationMode) {
+              PDFViewerApplication.pdfHistory.back();
+              handled = true;
+            }
+            break;
+          case 39:
+            // right arrow
+            if (isViewerInPresentationMode) {
+              PDFViewerApplication.pdfHistory.forward();
+              handled = true;
+            }
+            break;
+          }
+        }
+        if (ensureViewerFocused && !pdfViewer.containsElement(curElement)) {
+          // The page container is not focused, but a page navigation key has been
+          // pressed. Change the focus to the viewer container to make sure that
+          // navigation by keyboard works as expected.
+          pdfViewer.focus();
+        }
+        if (handled) {
+          evt.preventDefault();
+        }
+      });
+      window.addEventListener('beforeprint', function beforePrint(evt) {
+        PDFViewerApplication.eventBus.dispatch('beforeprint');
+      });
+      window.addEventListener('afterprint', function afterPrint(evt) {
+        PDFViewerApplication.eventBus.dispatch('afterprint');
+      });
+      (function animationStartedClosure() {
+        // The offsetParent is not set until the pdf.js iframe or object is visible.
+        // Waiting for first animation.
+        PDFViewerApplication.animationStartedPromise = new Promise(function (resolve) {
+          window.requestAnimationFrame(resolve);
+        });
+      }());
+      /* Abstract factory for the print service. */
+      var PDFPrintServiceFactory = {
+        instance: {
+          supportsPrinting: false,
+          createPrintService: function () {
+            throw new Error('Not implemented: createPrintService');
+          }
+        }
+      };
+      exports.PDFViewerApplication = PDFViewerApplication;
+      exports.DefaultExernalServices = DefaultExernalServices;
+      exports.PDFPrintServiceFactory = PDFPrintServiceFactory;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebFirefoxPrintService = {}, root.pdfjsWebUIUtils, root.pdfjsWebApp, root.pdfjsWebPDFJS);
+    }(this, function (exports, uiUtils, app, pdfjsLib) {
+      var CSS_UNITS = uiUtils.CSS_UNITS;
+      var PDFPrintServiceFactory = app.PDFPrintServiceFactory;
+      // Creates a placeholder with div and canvas with right size for the page.
+      function composePage(pdfDocument, pageNumber, size, printContainer) {
+        var canvas = document.createElement('canvas');
+        // The size of the canvas in pixels for printing.
+        var PRINT_RESOLUTION = 150;
+        var PRINT_UNITS = PRINT_RESOLUTION / 72.0;
+        canvas.width = Math.floor(size.width * PRINT_UNITS);
+        canvas.height = Math.floor(size.height * PRINT_UNITS);
+        // The physical size of the canvas as specified by the PDF document.
+        canvas.style.width = Math.floor(size.width * CSS_UNITS) + 'px';
+        canvas.style.height = Math.floor(size.height * CSS_UNITS) + 'px';
+        var canvasWrapper = document.createElement('div');
+        canvasWrapper.appendChild(canvas);
+        printContainer.appendChild(canvasWrapper);
+        canvas.mozPrintCallback = function (obj) {
+          // Printing/rendering the page.
+          var ctx = obj.context;
+          ctx.save();
+          ctx.fillStyle = 'rgb(255, 255, 255)';
+          ctx.fillRect(0, 0, canvas.width, canvas.height);
+          ctx.restore();
+          pdfDocument.getPage(pageNumber).then(function (pdfPage) {
+            var renderContext = {
+              canvasContext: ctx,
+              transform: [
+                PRINT_UNITS,
+                0,
+                0,
+                PRINT_UNITS,
+                0,
+                0
+              ],
+              viewport: pdfPage.getViewport(1),
+              intent: 'print'
+            };
+            return pdfPage.render(renderContext).promise;
+          }).then(function () {
+            // Tell the printEngine that rendering this canvas/page has finished.
+            obj.done();
+          }, function (error) {
+            console.error(error);
+            // Tell the printEngine that rendering this canvas/page has failed.
+            // This will make the print process stop.
+            if ('abort' in obj) {
+              obj.abort();
+            } else {
+              obj.done();
+            }
+          });
+        };
+      }
+      function FirefoxPrintService(pdfDocument, pagesOverview, printContainer) {
+        this.pdfDocument = pdfDocument;
+        this.pagesOverview = pagesOverview;
+        this.printContainer = printContainer;
+      }
+      FirefoxPrintService.prototype = {
+        layout: function () {
+          var pdfDocument = this.pdfDocument;
+          var printContainer = this.printContainer;
+          var body = document.querySelector('body');
+          body.setAttribute('data-pdfjsprinting', true);
+          for (var i = 0, ii = this.pagesOverview.length; i < ii; ++i) {
+            composePage(pdfDocument, i + 1, this.pagesOverview[i], printContainer);
+          }
+        },
+        destroy: function () {
+          this.printContainer.textContent = '';
+        }
+      };
+      PDFPrintServiceFactory.instance = {
+        get supportsPrinting() {
+          var canvas = document.createElement('canvas');
+          var value = 'mozPrintCallback' in canvas;
+          return pdfjsLib.shadow(this, 'supportsPrinting', value);
+        },
+        createPrintService: function (pdfDocument, pagesOverview, printContainer) {
+          return new FirefoxPrintService(pdfDocument, pagesOverview, printContainer);
+        }
+      };
+      exports.FirefoxPrintService = FirefoxPrintService;
+    }));
+    (function (root, factory) {
+      factory(root.pdfjsWebFirefoxCom = {}, root.pdfjsWebPreferences, root.pdfjsWebApp, root.pdfjsWebPDFJS);
+    }(this, function (exports, preferences, app, pdfjsLib) {
+      var Preferences = preferences.Preferences;
+      var PDFViewerApplication = app.PDFViewerApplication;
+      var FirefoxCom = function FirefoxComClosure() {
+        return {
+          /**
+           * Creates an event that the extension is listening for and will
+           * synchronously respond to.
+           * NOTE: It is reccomended to use request() instead since one day we may not
+           * be able to synchronously reply.
+           * @param {String} action The action to trigger.
+           * @param {String} data Optional data to send.
+           * @return {*} The response.
+           */
+          requestSync: function (action, data) {
+            var request = document.createTextNode('');
+            document.documentElement.appendChild(request);
+            var sender = document.createEvent('CustomEvent');
+            sender.initCustomEvent('pdf.js.message', true, false, {
+              action: action,
+              data: data,
+              sync: true
+            });
+            request.dispatchEvent(sender);
+            var response = sender.detail.response;
+            document.documentElement.removeChild(request);
+            return response;
+          },
+          /**
+           * Creates an event that the extension is listening for and will
+           * asynchronously respond by calling the callback.
+           * @param {String} action The action to trigger.
+           * @param {String} data Optional data to send.
+           * @param {Function} callback Optional response callback that will be called
+           * with one data argument.
+           */
+          request: function (action, data, callback) {
+            var request = document.createTextNode('');
+            if (callback) {
+              document.addEventListener('pdf.js.response', function listener(event) {
+                var node = event.target;
+                var response = event.detail.response;
+                document.documentElement.removeChild(node);
+                document.removeEventListener('pdf.js.response', listener, false);
+                return callback(response);
+              }, false);
+            }
+            document.documentElement.appendChild(request);
+            var sender = document.createEvent('CustomEvent');
+            sender.initCustomEvent('pdf.js.message', true, false, {
+              action: action,
+              data: data,
+              sync: false,
+              responseExpected: !!callback
+            });
+            return request.dispatchEvent(sender);
+          }
+        };
+      }();
+      var DownloadManager = function DownloadManagerClosure() {
+        function DownloadManager() {
+        }
+        DownloadManager.prototype = {
+          downloadUrl: function DownloadManager_downloadUrl(url, filename) {
+            FirefoxCom.request('download', {
+              originalUrl: url,
+              filename: filename
+            });
+          },
+          downloadData: function DownloadManager_downloadData(data, filename, contentType) {
+            var blobUrl = pdfjsLib.createObjectURL(data, contentType, false);
+            FirefoxCom.request('download', {
+              blobUrl: blobUrl,
+              originalUrl: blobUrl,
+              filename: filename,
+              isAttachment: true
+            });
+          },
+          download: function DownloadManager_download(blob, url, filename) {
+            var blobUrl = window.URL.createObjectURL(blob);
+            FirefoxCom.request('download', {
+              blobUrl: blobUrl,
+              originalUrl: url,
+              filename: filename
+            }, function response(err) {
+              if (err && this.onerror) {
+                this.onerror(err);
+              }
+              window.URL.revokeObjectURL(blobUrl);
+            }.bind(this));
+          }
+        };
+        return DownloadManager;
+      }();
+      Preferences._writeToStorage = function (prefObj) {
+        return new Promise(function (resolve) {
+          FirefoxCom.request('setPreferences', prefObj, resolve);
+        });
+      };
+      Preferences._readFromStorage = function (prefObj) {
+        return new Promise(function (resolve) {
+          FirefoxCom.request('getPreferences', prefObj, function (prefStr) {
+            var readPrefs = JSON.parse(prefStr);
+            resolve(readPrefs);
+          });
+        });
+      };
+      (function listenFindEvents() {
+        var events = [
+          'find',
+          'findagain',
+          'findhighlightallchange',
+          'findcasesensitivitychange'
+        ];
+        var handleEvent = function (evt) {
+          if (!PDFViewerApplication.initialized) {
+            return;
+          }
+          PDFViewerApplication.eventBus.dispatch('find', {
+            source: window,
+            type: evt.type.substring('find'.length),
+            query: evt.detail.query,
+            phraseSearch: true,
+            caseSensitive: !!evt.detail.caseSensitive,
+            highlightAll: !!evt.detail.highlightAll,
+            findPrevious: !!evt.detail.findPrevious
+          });
+        }.bind(this);
+        for (var i = 0, len = events.length; i < len; i++) {
+          window.addEventListener(events[i], handleEvent);
+        }
+      }());
+      function FirefoxComDataRangeTransport(length, initialData) {
+        pdfjsLib.PDFDataRangeTransport.call(this, length, initialData);
+      }
+      FirefoxComDataRangeTransport.prototype = Object.create(pdfjsLib.PDFDataRangeTransport.prototype);
+      FirefoxComDataRangeTransport.prototype.requestDataRange = function FirefoxComDataRangeTransport_requestDataRange(begin, end) {
+        FirefoxCom.request('requestDataRange', {
+          begin: begin,
+          end: end
+        });
+      };
+      FirefoxComDataRangeTransport.prototype.abort = function FirefoxComDataRangeTransport_abort() {
+        // Sync call to ensure abort is really started.
+        FirefoxCom.requestSync('abortLoading', null);
+      };
+      PDFViewerApplication.externalServices = {
+        updateFindControlState: function (data) {
+          FirefoxCom.request('updateFindControlState', data);
+        },
+        initPassiveLoading: function (callbacks) {
+          var pdfDataRangeTransport;
+          window.addEventListener('message', function windowMessage(e) {
+            if (e.source !== null) {
+              // The message MUST originate from Chrome code.
+              console.warn('Rejected untrusted message from ' + e.origin);
+              return;
+            }
+            var args = e.data;
+            if (typeof args !== 'object' || !('pdfjsLoadAction' in args)) {
+              return;
+            }
+            switch (args.pdfjsLoadAction) {
+            case 'supportsRangedLoading':
+              pdfDataRangeTransport = new FirefoxComDataRangeTransport(args.length, args.data);
+              callbacks.onOpenWithTransport(args.pdfUrl, args.length, pdfDataRangeTransport);
+              break;
+            case 'range':
+              pdfDataRangeTransport.onDataRange(args.begin, args.chunk);
+              break;
+            case 'rangeProgress':
+              pdfDataRangeTransport.onDataProgress(args.loaded);
+              break;
+            case 'progressiveRead':
+              pdfDataRangeTransport.onDataProgressiveRead(args.chunk);
+              break;
+            case 'progress':
+              callbacks.onProgress(args.loaded, args.total);
+              break;
+            case 'complete':
+              if (!args.data) {
+                callbacks.onError(args.errorCode);
+                break;
+              }
+              callbacks.onOpenWithData(args.data);
+              break;
+            }
+          });
+          FirefoxCom.requestSync('initPassiveLoading', null);
+        },
+        fallback: function (data, callback) {
+          FirefoxCom.request('fallback', data, callback);
+        },
+        reportTelemetry: function (data) {
+          FirefoxCom.request('reportTelemetry', JSON.stringify(data));
+        },
+        createDownloadManager: function () {
+          return new DownloadManager();
+        },
+        get supportsIntegratedFind() {
+          var support = FirefoxCom.requestSync('supportsIntegratedFind');
+          return pdfjsLib.shadow(this, 'supportsIntegratedFind', support);
+        },
+        get supportsDocumentFonts() {
+          var support = FirefoxCom.requestSync('supportsDocumentFonts');
+          return pdfjsLib.shadow(this, 'supportsDocumentFonts', support);
+        },
+        get supportsDocumentColors() {
+          var support = FirefoxCom.requestSync('supportsDocumentColors');
+          return pdfjsLib.shadow(this, 'supportsDocumentColors', support);
+        },
+        get supportedMouseWheelZoomModifierKeys() {
+          var support = FirefoxCom.requestSync('supportedMouseWheelZoomModifierKeys');
+          return pdfjsLib.shadow(this, 'supportedMouseWheelZoomModifierKeys', support);
+        }
+      };
+      //// l10n.js for Firefox extension expects services to be set.
+      document.mozL10n.setExternalLocalizerServices({
+        getLocale: function () {
+          return FirefoxCom.requestSync('getLocale', null);
+        },
+        getStrings: function (key) {
+          return FirefoxCom.requestSync('getStrings', key);
+        }
+      });
+      exports.DownloadManager = DownloadManager;
+      exports.FirefoxCom = FirefoxCom;
+    }));
+  }.call(pdfjsWebLibs));
+}
+{
+  // FIXME the l10n.js file in the Firefox extension needs global FirefoxCom.
+  window.FirefoxCom = pdfjsWebLibs.pdfjsWebFirefoxCom.FirefoxCom;
+}
+function getViewerConfiguration() {
+  return {
+    appContainer: document.body,
+    mainContainer: document.getElementById('viewerContainer'),
+    viewerContainer: document.getElementById('viewer'),
+    eventBus: null,
+    // using global event bus with DOM events
+    toolbar: {
+      container: document.getElementById('toolbarViewer'),
+      numPages: document.getElementById('numPages'),
+      pageNumber: document.getElementById('pageNumber'),
+      scaleSelectContainer: document.getElementById('scaleSelectContainer'),
+      scaleSelect: document.getElementById('scaleSelect'),
+      customScaleOption: document.getElementById('customScaleOption'),
+      previous: document.getElementById('previous'),
+      next: document.getElementById('next'),
+      firstPage: document.getElementById('firstPage'),
+      lastPage: document.getElementById('lastPage'),
+      zoomIn: document.getElementById('zoomIn'),
+      zoomOut: document.getElementById('zoomOut'),
+      viewFind: document.getElementById('viewFind'),
+      openFile: document.getElementById('openFile'),
+      print: document.getElementById('print'),
+      presentationModeButton: document.getElementById('presentationMode'),
+      download: document.getElementById('download'),
+      viewBookmark: document.getElementById('viewBookmark')
+    },
+    secondaryToolbar: {
+      toolbar: document.getElementById('secondaryToolbar'),
+      toggleButton: document.getElementById('secondaryToolbarToggle'),
+      toolbarButtonContainer: document.getElementById('secondaryToolbarButtonContainer'),
+      presentationModeButton: document.getElementById('secondaryPresentationMode'),
+      openFileButton: document.getElementById('secondaryOpenFile'),
+      printButton: document.getElementById('secondaryPrint'),
+      downloadButton: document.getElementById('secondaryDownload'),
+      viewBookmarkButton: document.getElementById('secondaryViewBookmark'),
+      firstPageButton: document.getElementById('firstPage'),
+      lastPageButton: document.getElementById('lastPage'),
+      pageRotateCwButton: document.getElementById('pageRotateCw'),
+      pageRotateCcwButton: document.getElementById('pageRotateCcw'),
+      toggleHandToolButton: document.getElementById('toggleHandTool'),
+      documentPropertiesButton: document.getElementById('documentProperties')
+    },
+    fullscreen: {
+      contextFirstPage: document.getElementById('contextFirstPage'),
+      contextLastPage: document.getElementById('contextLastPage'),
+      contextPageRotateCw: document.getElementById('contextPageRotateCw'),
+      contextPageRotateCcw: document.getElementById('contextPageRotateCcw')
+    },
+    sidebar: {
+      // Divs (and sidebar button)
+      mainContainer: document.getElementById('mainContainer'),
+      outerContainer: document.getElementById('outerContainer'),
+      toggleButton: document.getElementById('sidebarToggle'),
+      // Buttons
+      thumbnailButton: document.getElementById('viewThumbnail'),
+      outlineButton: document.getElementById('viewOutline'),
+      attachmentsButton: document.getElementById('viewAttachments'),
+      // Views
+      thumbnailView: document.getElementById('thumbnailView'),
+      outlineView: document.getElementById('outlineView'),
+      attachmentsView: document.getElementById('attachmentsView')
+    },
+    findBar: {
+      bar: document.getElementById('findbar'),
+      toggleButton: document.getElementById('viewFind'),
+      findField: document.getElementById('findInput'),
+      highlightAllCheckbox: document.getElementById('findHighlightAll'),
+      caseSensitiveCheckbox: document.getElementById('findMatchCase'),
+      findMsg: document.getElementById('findMsg'),
+      findResultsCount: document.getElementById('findResultsCount'),
+      findStatusIcon: document.getElementById('findStatusIcon'),
+      findPreviousButton: document.getElementById('findPrevious'),
+      findNextButton: document.getElementById('findNext')
+    },
+    passwordOverlay: {
+      overlayName: 'passwordOverlay',
+      container: document.getElementById('passwordOverlay'),
+      label: document.getElementById('passwordText'),
+      input: document.getElementById('password'),
+      submitButton: document.getElementById('passwordSubmit'),
+      cancelButton: document.getElementById('passwordCancel')
+    },
+    documentProperties: {
+      overlayName: 'documentPropertiesOverlay',
+      container: document.getElementById('documentPropertiesOverlay'),
+      closeButton: document.getElementById('documentPropertiesClose'),
+      fields: {
+        'fileName': document.getElementById('fileNameField'),
+        'fileSize': document.getElementById('fileSizeField'),
+        'title': document.getElementById('titleField'),
+        'author': document.getElementById('authorField'),
+        'subject': document.getElementById('subjectField'),
+        'keywords': document.getElementById('keywordsField'),
+        'creationDate': document.getElementById('creationDateField'),
+        'modificationDate': document.getElementById('modificationDateField'),
+        'creator': document.getElementById('creatorField'),
+        'producer': document.getElementById('producerField'),
+        'version': document.getElementById('versionField'),
+        'pageCount': document.getElementById('pageCountField')
+      }
+    },
+    errorWrapper: {
+      container: document.getElementById('errorWrapper'),
+      errorMessage: document.getElementById('errorMessage'),
+      closeButton: document.getElementById('errorClose'),
+      errorMoreInfo: document.getElementById('errorMoreInfo'),
+      moreInfoButton: document.getElementById('errorShowMore'),
+      lessInfoButton: document.getElementById('errorShowLess')
+    },
+    printContainer: document.getElementById('printContainer'),
+    openFileInputName: 'fileInput',
+    debuggerScriptPath: './debugger.js'
+  };
+}
+function webViewerLoad() {
+  var config = getViewerConfiguration();
+  window.PDFViewerApplication = pdfjsWebLibs.pdfjsWebApp.PDFViewerApplication;
+  pdfjsWebLibs.pdfjsWebApp.PDFViewerApplication.run(config);
+}
+document.addEventListener('DOMContentLoaded', webViewerLoad, true);
\ No newline at end of file
diff --git a/application/basilisk/extensions/pdfjs/jar.mn b/application/basilisk/extensions/pdfjs/jar.mn
new file mode 100644
index 000000000..ca1148155
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/jar.mn
@@ -0,0 +1,3 @@
+pdfjs.jar:
+% resource pdf.js %content/
+ content/	(content/*)
diff --git a/application/basilisk/extensions/pdfjs/moz.build b/application/basilisk/extensions/pdfjs/moz.build
new file mode 100644
index 000000000..aac3a838c
--- /dev/null
+++ b/application/basilisk/extensions/pdfjs/moz.build
@@ -0,0 +1,7 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+JAR_MANIFESTS += ['jar.mn']