pdfjs-dist 2.2.228 → 2.6.347

package/lib/display/font_loader.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,418 +26,292 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.FontLoader = exports.FontFaceObject = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../shared/util.js");
 
-var _util = require("../shared/util");
+class BaseFontLoader {
+  constructor({
+    docId,
+    onUnsupportedFeature,
+    ownerDocument = globalThis.document
+  }) {
+    if (this.constructor === BaseFontLoader) {
+      (0, _util.unreachable)("Cannot initialize BaseFontLoader.");
+    }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+    this.docId = docId;
+    this._onUnsupportedFeature = onUnsupportedFeature;
+    this._document = ownerDocument;
+    this.nativeFontFaces = [];
+    this.styleElement = null;
+  }
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+  addNativeFontFace(nativeFontFace) {
+    this.nativeFontFaces.push(nativeFontFace);
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+    this._document.fonts.add(nativeFontFace);
+  }
 
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+  insertRule(rule) {
+    let styleElement = this.styleElement;
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+    if (!styleElement) {
+      styleElement = this.styleElement = this._document.createElement("style");
+      styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+      this._document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement);
+    }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+    const styleSheet = styleElement.sheet;
+    styleSheet.insertRule(rule, styleSheet.cssRules.length);
+  }
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+  clear() {
+    this.nativeFontFaces.forEach(nativeFontFace => {
+      this._document.fonts.delete(nativeFontFace);
+    });
+    this.nativeFontFaces.length = 0;
 
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+    if (this.styleElement) {
+      this.styleElement.remove();
+      this.styleElement = null;
+    }
+  }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+  async bind(font) {
+    if (font.attached || font.missingFile) {
+      return;
+    }
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+    font.attached = true;
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+    if (this.isFontLoadingAPISupported) {
+      const nativeFontFace = font.createNativeFontFace();
 
-var BaseFontLoader =
-/*#__PURE__*/
-function () {
-  function BaseFontLoader(_ref) {
-    var docId = _ref.docId,
-        onUnsupportedFeature = _ref.onUnsupportedFeature;
+      if (nativeFontFace) {
+        this.addNativeFontFace(nativeFontFace);
 
-    _classCallCheck(this, BaseFontLoader);
+        try {
+          await nativeFontFace.loaded;
+        } catch (ex) {
+          this._onUnsupportedFeature({
+            featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative
+          });
 
-    if (this.constructor === BaseFontLoader) {
-      (0, _util.unreachable)('Cannot initialize BaseFontLoader.');
+          (0, _util.warn)(`Failed to load font '${nativeFontFace.family}': '${ex}'.`);
+          font.disableFontFace = true;
+          throw ex;
+        }
+      }
+
+      return;
     }
 
-    this.docId = docId;
-    this._onUnsupportedFeature = onUnsupportedFeature;
-    this.nativeFontFaces = [];
-    this.styleElement = null;
-  }
+    const rule = font.createFontFaceRule();
 
-  _createClass(BaseFontLoader, [{
-    key: "addNativeFontFace",
-    value: function addNativeFontFace(nativeFontFace) {
-      this.nativeFontFaces.push(nativeFontFace);
-      document.fonts.add(nativeFontFace);
-    }
-  }, {
-    key: "insertRule",
-    value: function insertRule(rule) {
-      var styleElement = this.styleElement;
-
-      if (!styleElement) {
-        styleElement = this.styleElement = document.createElement('style');
-        styleElement.id = "PDFJS_FONT_STYLE_TAG_".concat(this.docId);
-        document.documentElement.getElementsByTagName('head')[0].appendChild(styleElement);
+    if (rule) {
+      this.insertRule(rule);
+
+      if (this.isSyncFontLoadingSupported) {
+        return;
       }
 
-      var styleSheet = styleElement.sheet;
-      styleSheet.insertRule(rule, styleSheet.cssRules.length);
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.nativeFontFaces.forEach(function (nativeFontFace) {
-        document.fonts["delete"](nativeFontFace);
-      });
-      this.nativeFontFaces.length = 0;
+      await new Promise(resolve => {
+        const request = this._queueLoadingCallback(resolve);
 
-      if (this.styleElement) {
-        this.styleElement.remove();
-        this.styleElement = null;
-      }
+        this._prepareFontLoadEvent([rule], [font], request);
+      });
     }
-  }, {
-    key: "bind",
-    value: function () {
-      var _bind = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee(font) {
-        var _this = this;
-
-        var nativeFontFace, rule;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!(font.attached || font.missingFile)) {
-                  _context.next = 2;
-                  break;
-                }
-
-                return _context.abrupt("return", undefined);
-
-              case 2:
-                font.attached = true;
-
-                if (!this.isFontLoadingAPISupported) {
-                  _context.next = 19;
-                  break;
-                }
-
-                nativeFontFace = font.createNativeFontFace();
-
-                if (!nativeFontFace) {
-                  _context.next = 18;
-                  break;
-                }
-
-                this.addNativeFontFace(nativeFontFace);
-                _context.prev = 7;
-                _context.next = 10;
-                return nativeFontFace.loaded;
-
-              case 10:
-                _context.next = 18;
-                break;
-
-              case 12:
-                _context.prev = 12;
-                _context.t0 = _context["catch"](7);
-
-                this._onUnsupportedFeature({
-                  featureId: _util.UNSUPPORTED_FEATURES.font
-                });
-
-                (0, _util.warn)("Failed to load font '".concat(nativeFontFace.family, "': '").concat(_context.t0, "'."));
-                font.disableFontFace = true;
-                throw _context.t0;
-
-              case 18:
-                return _context.abrupt("return", undefined);
-
-              case 19:
-                rule = font.createFontFaceRule();
-
-                if (!rule) {
-                  _context.next = 25;
-                  break;
-                }
-
-                this.insertRule(rule);
-
-                if (!this.isSyncFontLoadingSupported) {
-                  _context.next = 24;
-                  break;
-                }
-
-                return _context.abrupt("return", undefined);
-
-              case 24:
-                return _context.abrupt("return", new Promise(function (resolve) {
-                  var request = _this._queueLoadingCallback(resolve);
-
-                  _this._prepareFontLoadEvent([rule], [font], request);
-                }));
-
-              case 25:
-                return _context.abrupt("return", undefined);
-
-              case 26:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[7, 12]]);
-      }));
-
-      function bind(_x) {
-        return _bind.apply(this, arguments);
-      }
+  }
 
-      return bind;
-    }()
-  }, {
-    key: "_queueLoadingCallback",
-    value: function _queueLoadingCallback(callback) {
-      (0, _util.unreachable)('Abstract method `_queueLoadingCallback`.');
-    }
-  }, {
-    key: "_prepareFontLoadEvent",
-    value: function _prepareFontLoadEvent(rules, fontsToLoad, request) {
-      (0, _util.unreachable)('Abstract method `_prepareFontLoadEvent`.');
-    }
-  }, {
-    key: "isFontLoadingAPISupported",
-    get: function get() {
-      (0, _util.unreachable)('Abstract method `isFontLoadingAPISupported`.');
-    }
-  }, {
-    key: "isSyncFontLoadingSupported",
-    get: function get() {
-      (0, _util.unreachable)('Abstract method `isSyncFontLoadingSupported`.');
-    }
-  }, {
-    key: "_loadTestFont",
-    get: function get() {
-      (0, _util.unreachable)('Abstract method `_loadTestFont`.');
-    }
-  }]);
+  _queueLoadingCallback(callback) {
+    (0, _util.unreachable)("Abstract method `_queueLoadingCallback`.");
+  }
 
-  return BaseFontLoader;
-}();
+  get isFontLoadingAPISupported() {
+    const supported = typeof this._document !== "undefined" && !!this._document.fonts;
+    return (0, _util.shadow)(this, "isFontLoadingAPISupported", supported);
+  }
 
-var FontLoader;
-exports.FontLoader = FontLoader;
-{
-  exports.FontLoader = FontLoader =
-  /*#__PURE__*/
-  function (_BaseFontLoader) {
-    _inherits(GenericFontLoader, _BaseFontLoader);
+  get isSyncFontLoadingSupported() {
+    (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`.");
+  }
 
-    function GenericFontLoader(docId) {
-      var _this2;
+  get _loadTestFont() {
+    (0, _util.unreachable)("Abstract method `_loadTestFont`.");
+  }
+
+  _prepareFontLoadEvent(rules, fontsToLoad, request) {
+    (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`.");
+  }
 
-      _classCallCheck(this, GenericFontLoader);
+}
 
-      _this2 = _possibleConstructorReturn(this, _getPrototypeOf(GenericFontLoader).call(this, docId));
-      _this2.loadingContext = {
+let FontLoader;
+exports.FontLoader = FontLoader;
+{
+  exports.FontLoader = FontLoader = class GenericFontLoader extends BaseFontLoader {
+    constructor(params) {
+      super(params);
+      this.loadingContext = {
         requests: [],
         nextRequestId: 0
       };
-      _this2.loadTestFontId = 0;
-      return _this2;
+      this.loadTestFontId = 0;
     }
 
-    _createClass(GenericFontLoader, [{
-      key: "_queueLoadingCallback",
-      value: function _queueLoadingCallback(callback) {
-        function completeRequest() {
-          (0, _util.assert)(!request.done, 'completeRequest() cannot be called twice.');
-          request.done = true;
-
-          while (context.requests.length > 0 && context.requests[0].done) {
-            var otherRequest = context.requests.shift();
-            setTimeout(otherRequest.callback, 0);
-          }
-        }
+    get isSyncFontLoadingSupported() {
+      let supported = false;
 
-        var context = this.loadingContext;
-        var request = {
-          id: "pdfjs-font-loading-".concat(context.nextRequestId++),
-          done: false,
-          complete: completeRequest,
-          callback: callback
-        };
-        context.requests.push(request);
-        return request;
-      }
-    }, {
-      key: "_prepareFontLoadEvent",
-      value: function _prepareFontLoadEvent(rules, fonts, request) {
-        function int32(data, offset) {
-          return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
+      if (typeof navigator === "undefined") {
+        supported = true;
+      } else {
+        const m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
+
+        if (m && m[1] >= 14) {
+          supported = true;
         }
+      }
+
+      return (0, _util.shadow)(this, "isSyncFontLoadingSupported", supported);
+    }
+
+    _queueLoadingCallback(callback) {
+      function completeRequest() {
+        (0, _util.assert)(!request.done, "completeRequest() cannot be called twice.");
+        request.done = true;
 
-        function spliceString(s, offset, remove, insert) {
-          var chunk1 = s.substring(0, offset);
-          var chunk2 = s.substring(offset + remove);
-          return chunk1 + insert + chunk2;
+        while (context.requests.length > 0 && context.requests[0].done) {
+          const otherRequest = context.requests.shift();
+          setTimeout(otherRequest.callback, 0);
         }
+      }
 
-        var i, ii;
-        var canvas = document.createElement('canvas');
-        canvas.width = 1;
-        canvas.height = 1;
-        var ctx = canvas.getContext('2d');
-        var called = 0;
+      const context = this.loadingContext;
+      const request = {
+        id: `pdfjs-font-loading-${context.nextRequestId++}`,
+        done: false,
+        complete: completeRequest,
+        callback
+      };
+      context.requests.push(request);
+      return request;
+    }
 
-        function isFontReady(name, callback) {
-          called++;
+    get _loadTestFont() {
+      const getLoadTestFont = function () {
+        return atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA" + "FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA" + "ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA" + "AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1" + "AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD" + "6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM" + "AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D" + "IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA" + "AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA" + "AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB" + "AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY" + "AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA" + "AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA" + "AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC" + "AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3" + "Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj" + "FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==");
+      };
 
-          if (called > 30) {
-            (0, _util.warn)('Load test font never loaded.');
-            callback();
-            return;
-          }
+      return (0, _util.shadow)(this, "_loadTestFont", getLoadTestFont());
+    }
 
-          ctx.font = '30px ' + name;
-          ctx.fillText('.', 0, 20);
-          var imageData = ctx.getImageData(0, 0, 1, 1);
+    _prepareFontLoadEvent(rules, fonts, request) {
+      function int32(data, offset) {
+        return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
+      }
 
-          if (imageData.data[3] > 0) {
-            callback();
-            return;
-          }
+      function spliceString(s, offset, remove, insert) {
+        const chunk1 = s.substring(0, offset);
+        const chunk2 = s.substring(offset + remove);
+        return chunk1 + insert + chunk2;
+      }
 
-          setTimeout(isFontReady.bind(null, name, callback));
-        }
+      let i, ii;
 
-        var loadTestFontId = "lt".concat(Date.now()).concat(this.loadTestFontId++);
-        var data = this._loadTestFont;
-        var COMMENT_OFFSET = 976;
-        data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId);
-        var CFF_CHECKSUM_OFFSET = 16;
-        var XXXX_VALUE = 0x58585858;
-        var checksum = int32(data, CFF_CHECKSUM_OFFSET);
+      const canvas = this._document.createElement("canvas");
 
-        for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
-          checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
-        }
+      canvas.width = 1;
+      canvas.height = 1;
+      const ctx = canvas.getContext("2d");
+      let called = 0;
+
+      function isFontReady(name, callback) {
+        called++;
 
-        if (i < loadTestFontId.length) {
-          checksum = checksum - XXXX_VALUE + int32(loadTestFontId + 'XXX', i) | 0;
+        if (called > 30) {
+          (0, _util.warn)("Load test font never loaded.");
+          callback();
+          return;
         }
 
-        data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum));
-        var url = "url(data:font/opentype;base64,".concat(btoa(data), ");");
-        var rule = "@font-face {font-family:\"".concat(loadTestFontId, "\";src:").concat(url, "}");
-        this.insertRule(rule);
-        var names = [];
+        ctx.font = "30px " + name;
+        ctx.fillText(".", 0, 20);
+        const imageData = ctx.getImageData(0, 0, 1, 1);
 
-        for (i = 0, ii = fonts.length; i < ii; i++) {
-          names.push(fonts[i].loadedName);
+        if (imageData.data[3] > 0) {
+          callback();
+          return;
         }
 
-        names.push(loadTestFontId);
-        var div = document.createElement('div');
-        div.setAttribute('style', 'visibility: hidden;' + 'width: 10px; height: 10px;' + 'position: absolute; top: 0px; left: 0px;');
+        setTimeout(isFontReady.bind(null, name, callback));
+      }
 
-        for (i = 0, ii = names.length; i < ii; ++i) {
-          var span = document.createElement('span');
-          span.textContent = 'Hi';
-          span.style.fontFamily = names[i];
-          div.appendChild(span);
-        }
+      const loadTestFontId = `lt${Date.now()}${this.loadTestFontId++}`;
+      let data = this._loadTestFont;
+      const COMMENT_OFFSET = 976;
+      data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId);
+      const CFF_CHECKSUM_OFFSET = 16;
+      const XXXX_VALUE = 0x58585858;
+      let checksum = int32(data, CFF_CHECKSUM_OFFSET);
 
-        document.body.appendChild(div);
-        isFontReady(loadTestFontId, function () {
-          document.body.removeChild(div);
-          request.complete();
-        });
+      for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
+        checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
       }
-    }, {
-      key: "isFontLoadingAPISupported",
-      get: function get() {
-        var supported = typeof document !== 'undefined' && !!document.fonts;
 
-        if (supported && typeof navigator !== 'undefined') {
-          var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
+      if (i < loadTestFontId.length) {
+        checksum = checksum - XXXX_VALUE + int32(loadTestFontId + "XXX", i) | 0;
+      }
 
-          if (m && m[1] < 63) {
-            supported = false;
-          }
-        }
+      data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum));
+      const url = `url(data:font/opentype;base64,${btoa(data)});`;
+      const rule = `@font-face {font-family:"${loadTestFontId}";src:${url}}`;
+      this.insertRule(rule);
+      const names = [];
 
-        return (0, _util.shadow)(this, 'isFontLoadingAPISupported', supported);
+      for (i = 0, ii = fonts.length; i < ii; i++) {
+        names.push(fonts[i].loadedName);
       }
-    }, {
-      key: "isSyncFontLoadingSupported",
-      get: function get() {
-        var supported = false;
 
-        if (typeof navigator === 'undefined') {
-          supported = true;
-        } else {
-          var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
+      names.push(loadTestFontId);
 
-          if (m && m[1] >= 14) {
-            supported = true;
-          }
-        }
+      const div = this._document.createElement("div");
 
-        return (0, _util.shadow)(this, 'isSyncFontLoadingSupported', supported);
-      }
-    }, {
-      key: "_loadTestFont",
-      get: function get() {
-        var getLoadTestFont = function getLoadTestFont() {
-          return atob('T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA' + 'FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA' + 'ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA' + 'AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1' + 'AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD' + '6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM' + 'AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D' + 'IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA' + 'AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA' + 'AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB' + 'AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY' + 'AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA' + 'AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA' + 'AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC' + 'AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3' + 'Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj' + 'FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==');
-        };
-
-        return (0, _util.shadow)(this, '_loadTestFont', getLoadTestFont());
+      div.style.visibility = "hidden";
+      div.style.width = div.style.height = "10px";
+      div.style.position = "absolute";
+      div.style.top = div.style.left = "0px";
+
+      for (i = 0, ii = names.length; i < ii; ++i) {
+        const span = this._document.createElement("span");
+
+        span.textContent = "Hi";
+        span.style.fontFamily = names[i];
+        div.appendChild(span);
       }
-    }]);
 
-    return GenericFontLoader;
-  }(BaseFontLoader);
-}
-var IsEvalSupportedCached = {
-  get value() {
-    return (0, _util.shadow)(this, 'value', (0, _util.isEvalSupported)());
-  }
+      this._document.body.appendChild(div);
+
+      isFontReady(loadTestFontId, () => {
+        this._document.body.removeChild(div);
 
-};
-
-var FontFaceObject =
-/*#__PURE__*/
-function () {
-  function FontFaceObject(translatedData, _ref2) {
-    var _ref2$isEvalSupported = _ref2.isEvalSupported,
-        isEvalSupported = _ref2$isEvalSupported === void 0 ? true : _ref2$isEvalSupported,
-        _ref2$disableFontFace = _ref2.disableFontFace,
-        disableFontFace = _ref2$disableFontFace === void 0 ? false : _ref2$disableFontFace,
-        _ref2$ignoreErrors = _ref2.ignoreErrors,
-        ignoreErrors = _ref2$ignoreErrors === void 0 ? false : _ref2$ignoreErrors,
-        _ref2$onUnsupportedFe = _ref2.onUnsupportedFeature,
-        onUnsupportedFeature = _ref2$onUnsupportedFe === void 0 ? null : _ref2$onUnsupportedFe,
-        _ref2$fontRegistry = _ref2.fontRegistry,
-        fontRegistry = _ref2$fontRegistry === void 0 ? null : _ref2$fontRegistry;
-
-    _classCallCheck(this, FontFaceObject);
+        request.complete();
+      });
+    }
 
+  };
+}
+
+class FontFaceObject {
+  constructor(translatedData, {
+    isEvalSupported = true,
+    disableFontFace = false,
+    ignoreErrors = false,
+    onUnsupportedFeature = null,
+    fontRegistry = null
+  }) {
     this.compiledGlyphs = Object.create(null);
 
-    for (var i in translatedData) {
+    for (const i in translatedData) {
       this[i] = translatedData[i];
     }
 
@@ -448,98 +322,92 @@ function () {
     this.fontRegistry = fontRegistry;
   }
 
-  _createClass(FontFaceObject, [{
-    key: "createNativeFontFace",
-    value: function createNativeFontFace() {
-      if (!this.data || this.disableFontFace) {
-        return null;
-      }
-
-      var nativeFontFace = new FontFace(this.loadedName, this.data, {});
+  createNativeFontFace() {
+    if (!this.data || this.disableFontFace) {
+      return null;
+    }
 
-      if (this.fontRegistry) {
-        this.fontRegistry.registerFont(this);
-      }
+    const nativeFontFace = new FontFace(this.loadedName, this.data, {});
 
-      return nativeFontFace;
+    if (this.fontRegistry) {
+      this.fontRegistry.registerFont(this);
     }
-  }, {
-    key: "createFontFaceRule",
-    value: function createFontFaceRule() {
-      if (!this.data || this.disableFontFace) {
-        return null;
-      }
 
-      var data = (0, _util.bytesToString)(new Uint8Array(this.data));
-      var url = "url(data:".concat(this.mimetype, ";base64,").concat(btoa(data), ");");
-      var rule = "@font-face {font-family:\"".concat(this.loadedName, "\";src:").concat(url, "}");
+    return nativeFontFace;
+  }
 
-      if (this.fontRegistry) {
-        this.fontRegistry.registerFont(this, url);
-      }
+  createFontFaceRule() {
+    if (!this.data || this.disableFontFace) {
+      return null;
+    }
 
-      return rule;
+    const data = (0, _util.bytesToString)(new Uint8Array(this.data));
+    const url = `url(data:${this.mimetype};base64,${btoa(data)});`;
+    const rule = `@font-face {font-family:"${this.loadedName}";src:${url}}`;
+
+    if (this.fontRegistry) {
+      this.fontRegistry.registerFont(this, url);
     }
-  }, {
-    key: "getPathGenerator",
-    value: function getPathGenerator(objs, character) {
-      if (this.compiledGlyphs[character] !== undefined) {
-        return this.compiledGlyphs[character];
-      }
 
-      var cmds, current;
+    return rule;
+  }
 
-      try {
-        cmds = objs.get(this.loadedName + '_path_' + character);
-      } catch (ex) {
-        if (!this.ignoreErrors) {
-          throw ex;
-        }
+  getPathGenerator(objs, character) {
+    if (this.compiledGlyphs[character] !== undefined) {
+      return this.compiledGlyphs[character];
+    }
 
-        if (this._onUnsupportedFeature) {
-          this._onUnsupportedFeature({
-            featureId: _util.UNSUPPORTED_FEATURES.font
-          });
-        }
+    let cmds, current;
 
-        (0, _util.warn)("getPathGenerator - ignoring character: \"".concat(ex, "\"."));
-        return this.compiledGlyphs[character] = function (c, size) {};
+    try {
+      cmds = objs.get(this.loadedName + "_path_" + character);
+    } catch (ex) {
+      if (!this.ignoreErrors) {
+        throw ex;
       }
 
-      if (this.isEvalSupported && IsEvalSupportedCached.value) {
-        var args,
-            js = '';
+      if (this._onUnsupportedFeature) {
+        this._onUnsupportedFeature({
+          featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath
+        });
+      }
 
-        for (var i = 0, ii = cmds.length; i < ii; i++) {
-          current = cmds[i];
+      (0, _util.warn)(`getPathGenerator - ignoring character: "${ex}".`);
+      return this.compiledGlyphs[character] = function (c, size) {};
+    }
+
+    if (this.isEvalSupported && _util.IsEvalSupportedCached.value) {
+      let args,
+          js = "";
 
-          if (current.args !== undefined) {
-            args = current.args.join(',');
-          } else {
-            args = '';
-          }
+      for (let i = 0, ii = cmds.length; i < ii; i++) {
+        current = cmds[i];
 
-          js += 'c.' + current.cmd + '(' + args + ');\n';
+        if (current.args !== undefined) {
+          args = current.args.join(",");
+        } else {
+          args = "";
         }
 
-        return this.compiledGlyphs[character] = new Function('c', 'size', js);
+        js += "c." + current.cmd + "(" + args + ");\n";
       }
 
-      return this.compiledGlyphs[character] = function (c, size) {
-        for (var _i = 0, _ii = cmds.length; _i < _ii; _i++) {
-          current = cmds[_i];
+      return this.compiledGlyphs[character] = new Function("c", "size", js);
+    }
 
-          if (current.cmd === 'scale') {
-            current.args = [size, -size];
-          }
+    return this.compiledGlyphs[character] = function (c, size) {
+      for (let i = 0, ii = cmds.length; i < ii; i++) {
+        current = cmds[i];
 
-          c[current.cmd].apply(c, current.args);
+        if (current.cmd === "scale") {
+          current.args = [size, -size];
         }
-      };
-    }
-  }]);
 
-  return FontFaceObject;
-}();
+        c[current.cmd].apply(c, current.args);
+      }
+    };
+  }
+
+}
 
 exports.FontFaceObject = FontFaceObject;