pdfjs-dist 2.0.943 → 2.4.456

package/lib/core/fonts.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 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.
@@ -19,38 +19,40 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getFontType = exports.IdentityToUnicodeMap = exports.ToUnicodeMap = exports.FontFlags = exports.Font = exports.ErrorFont = exports.SEAC_ANALYSIS_ENABLED = undefined;
+exports.getFontType = getFontType;
+exports.IdentityToUnicodeMap = exports.ToUnicodeMap = exports.FontFlags = exports.Font = exports.ErrorFont = exports.SEAC_ANALYSIS_ENABLED = void 0;
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+var _util = require("../shared/util.js");
 
-var _util = require('../shared/util');
+var _cff_parser = require("./cff_parser.js");
 
-var _cff_parser = require('./cff_parser');
+var _glyphlist = require("./glyphlist.js");
 
-var _glyphlist = require('./glyphlist');
+var _encodings = require("./encodings.js");
 
-var _encodings = require('./encodings');
+var _standard_fonts = require("./standard_fonts.js");
 
-var _standard_fonts = require('./standard_fonts');
+var _unicode = require("./unicode.js");
 
-var _unicode = require('./unicode');
+var _core_utils = require("./core_utils.js");
 
-var _font_renderer = require('./font_renderer');
+var _font_renderer = require("./font_renderer.js");
 
-var _cmap = require('./cmap');
+var _cmap = require("./cmap.js");
 
-var _stream = require('./stream');
+var _stream = require("./stream.js");
 
-var _type1_parser = require('./type1_parser');
+var _type1_parser = require("./type1_parser.js");
 
-var PRIVATE_USE_AREAS = [[0xE000, 0xF8FF], [0x100000, 0x10FFFD]];
+const PRIVATE_USE_AREAS = [[0xe000, 0xf8ff], [0x100000, 0x10fffd]];
 var PDF_GLYPH_SPACE_UNITS = 1000;
 var SEAC_ANALYSIS_ENABLED = true;
+exports.SEAC_ANALYSIS_ENABLED = SEAC_ANALYSIS_ENABLED;
 var FontFlags = {
   FixedPitch: 1,
   Serif: 2,
@@ -62,70 +64,95 @@ var FontFlags = {
   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'];
+exports.FontFlags = FontFlags;
+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] === _util.FONT_IDENTITY_MATRIX[0]) {
     return;
   }
+
   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;
   }
+
   if (properties.hasEncoding) {
     return;
   }
+
   if (builtInEncoding === properties.defaultEncoding) {
     return;
   }
+
   if (properties.toUnicode instanceof IdentityToUnicodeMap) {
     return;
   }
+
   var toUnicode = [],
       glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+
   for (var charCode in builtInEncoding) {
     var glyphName = builtInEncoding[charCode];
     var unicode = (0, _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' ? _util.FontType.TYPE1C : _util.FontType.TYPE1;
-    case 'CIDFontType0':
-      return subtype === 'CIDFontType0C' ? _util.FontType.CIDFONTTYPE0C : _util.FontType.CIDFONTTYPE0;
-    case 'OpenType':
+    case "Type1":
+      return subtype === "Type1C" ? _util.FontType.TYPE1C : _util.FontType.TYPE1;
+
+    case "CIDFontType0":
+      return subtype === "CIDFontType0C" ? _util.FontType.CIDFONTTYPE0C : _util.FontType.CIDFONTTYPE0;
+
+    case "OpenType":
       return _util.FontType.OPENTYPE;
-    case 'TrueType':
+
+    case "TrueType":
       return _util.FontType.TRUETYPE;
-    case 'CIDFontType2':
+
+    case "CIDFontType2":
       return _util.FontType.CIDFONTTYPE2;
-    case 'MMType1':
+
+    case "MMType1":
       return _util.FontType.MMTYPE1;
-    case 'Type0':
+
+    case "Type0":
       return _util.FontType.TYPE0;
+
     default:
       return _util.FontType.UNKNOWN;
   }
 }
+
 function recoverGlyphName(name, glyphsUnicodeMap) {
   if (glyphsUnicodeMap[name] !== undefined) {
     return name;
   }
+
   var unicode = (0, _unicode.getUnicodeForGlyph)(name, glyphsUnicodeMap);
+
   if (unicode !== -1) {
     for (var key in glyphsUnicodeMap) {
       if (glyphsUnicodeMap[key] === unicode) {
@@ -133,9 +160,11 @@ function recoverGlyphName(name, glyphsUnicodeMap) {
       }
     }
   }
-  (0, _util.info)('Unable to recover a standard glyph name for: ' + name);
+
+  (0, _util.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;
@@ -147,120 +176,152 @@ var Glyph = function GlyphClosure() {
     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() {
-    var cmap = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
 
+var ToUnicodeMap = function ToUnicodeMapClosure() {
+  function ToUnicodeMap(cmap = []) {
     this._map = cmap;
   }
+
   ToUnicodeMap.prototype = {
     get length() {
       return this._map.length;
     },
-    forEach: function forEach(callback) {
+
+    forEach(callback) {
       for (var charCode in this._map) {
         callback(charCode, this._map[charCode].charCodeAt(0));
       }
     },
-    has: function has(i) {
+
+    has(i) {
       return this._map[i] !== undefined;
     },
-    get: function get(i) {
+
+    get(i) {
       return this._map[i];
     },
-    charCodeOf: function charCodeOf(value) {
-      var map = this._map;
+
+    charCodeOf(value) {
+      const map = this._map;
+
       if (map.length <= 0x10000) {
         return map.indexOf(value);
       }
-      for (var charCode in map) {
+
+      for (const charCode in map) {
         if (map[charCode] === value) {
           return charCode | 0;
         }
       }
+
       return -1;
     },
-    amend: function amend(map) {
+
+    amend(map) {
       for (var charCode in map) {
         this._map[charCode] = map[charCode];
       }
     }
+
   };
   return ToUnicodeMap;
 }();
+
+exports.ToUnicodeMap = 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 forEach(callback) {
+
+    forEach(callback) {
       for (var i = this.firstChar, ii = this.lastChar; i <= ii; i++) {
         callback(i, i);
       }
     },
-    has: function has(i) {
+
+    has(i) {
       return this.firstChar <= i && i <= this.lastChar;
     },
-    get: function get(i) {
+
+    get(i) {
       if (this.firstChar <= i && i <= this.lastChar) {
         return String.fromCharCode(i);
       }
+
       return undefined;
     },
-    charCodeOf: function charCodeOf(v) {
+
+    charCodeOf(v) {
       return Number.isInteger(v) && v >= this.firstChar && v <= this.lastChar ? v : -1;
     },
-    amend: function amend(map) {
-      (0, _util.unreachable)('Should not call amend()');
+
+    amend(map) {
+      (0, _util.unreachable)("Should not call amend()");
     }
+
   };
   return IdentityToUnicodeMap;
 }();
+
+exports.IdentityToUnicodeMap = IdentityToUnicodeMap;
+
 var OpenTypeFileBuilder = function OpenTypeFileBuilderClosure() {
   function writeInt16(dest, offset, num) {
-    dest[offset] = num >> 8 & 0xFF;
-    dest[offset + 1] = num & 0xFF;
+    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;
+    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') {
+    } else if (typeof data === "string") {
       for (i = 0, ii = data.length; i < ii; i++) {
-        dest[offset++] = data.charCodeAt(i) & 0xFF;
+        dest[offset++] = data.charCodeAt(i) & 0xff;
       }
     } else {
       for (i = 0, ii = data.length; i < ii; i++) {
-        dest[offset++] = data[i] & 0xFF;
+        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,
@@ -268,6 +329,7 @@ var OpenTypeFileBuilder = function OpenTypeFileBuilderClosure() {
       rangeShift: entrySize * entriesCount - searchRange
     };
   };
+
   var OTF_HEADER_SIZE = 12;
   var OTF_TABLE_ENTRY_SIZE = 16;
   OpenTypeFileBuilder.prototype = {
@@ -280,57 +342,68 @@ var OpenTypeFileBuilder = function OpenTypeFileBuilderClosure() {
       var i, j, jj, table, tableName;
       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);
+
       for (i = 0; i < numTables; i++) {
         table = tables[tablesNames[i]];
         writeData(file, tableOffsets[i], table);
       }
-      if (sfnt === 'true') {
+
+      if (sfnt === "true") {
         sfnt = (0, _util.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;
+
+      file[0] = sfnt.charCodeAt(0) & 0xff;
+      file[1] = sfnt.charCodeAt(1) & 0xff;
+      file[2] = sfnt.charCodeAt(2) & 0xff;
+      file[3] = sfnt.charCodeAt(3) & 0xff;
       writeInt16(file, 4, numTables);
       var searchParams = OpenTypeFileBuilder.getSearchParams(numTables, 16);
       writeInt16(file, 6, searchParams.range);
       writeInt16(file, 8, searchParams.entry);
       writeInt16(file, 10, searchParams.rangeShift);
       offset = OTF_HEADER_SIZE;
+
       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;
+        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;
         var checksum = 0;
+
         for (j = tableOffsets[i], jj = tableOffsets[i + 1]; j < jj; j += 4) {
-          var quad = (0, _util.readUint32)(file, j);
+          var quad = (0, _core_utils.readUint32)(file, j);
           checksum = checksum + quad >>> 0;
         }
+
         writeInt32(file, offset + 4, checksum);
         writeInt32(file, offset + 8, tableOffsets[i]);
         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');
+        throw new Error("Table " + tag + " already exists");
       }
+
       this.tables[tag] = data;
     }
   };
   return OpenTypeFileBuilder;
 }();
+
 var Font = function FontClosure() {
   function Font(name, file, properties) {
     var charCode;
@@ -347,7 +420,15 @@ var Font = function FontClosure() {
     var subtype = properties.subtype;
     this.type = type;
     this.subtype = subtype;
-    this.fallbackName = this.isMonospace ? 'monospace' : this.isSerifFont ? 'serif' : 'sans-serif';
+    let fallbackName = "sans-serif";
+
+    if (this.isMonospace) {
+      fallbackName = "monospace";
+    } else if (this.isSerifFont) {
+      fallbackName = "serif";
+    }
+
+    this.fallbackName = fallbackName;
     this.differences = properties.differences;
     this.widths = properties.widths;
     this.defaultWidth = properties.defaultWidth;
@@ -362,67 +443,76 @@ var Font = function FontClosure() {
     this.toUnicode = properties.toUnicode;
     this.fallbackToUnicode = properties.fallbackToUnicode || new ToUnicodeMap();
     this.toFontChar = [];
-    if (properties.type === 'Type3') {
+
+    if (properties.type === "Type3") {
       for (charCode = 0; charCode < 256; charCode++) {
         this.toFontChar[charCode] = this.differences[charCode] || properties.defaultEncoding[charCode];
       }
+
       this.fontType = _util.FontType.TYPE3;
       return;
     }
+
     this.cidEncoding = properties.cidEncoding;
     this.vertical = properties.vertical;
+
     if (this.vertical) {
       this.vmetrics = properties.vmetrics;
       this.defaultVMetrics = properties.defaultVMetrics;
     }
+
     if (!file || file.isEmpty) {
       if (file) {
-        (0, _util.warn)('Font file is empty in "' + name + '" (' + this.loadedName + ')');
+        (0, _util.warn)('Font file is empty in "' + name + '" (' + this.loadedName + ")");
       }
+
       this.fallbackToSystemFont();
       return;
     }
 
-    var _getFontFileType = getFontFileType(file, properties);
-
-    var _getFontFileType2 = _slicedToArray(_getFontFileType, 2);
-
-    type = _getFontFileType2[0];
-    subtype = _getFontFileType2[1];
+    [type, subtype] = getFontFileType(file, properties);
 
     if (type !== this.type || subtype !== this.subtype) {
-      (0, _util.info)('Inconsistent font file Type/SubType, expected: ' + (this.type + '/' + this.subtype + ' but found: ' + type + '/' + subtype + '.'));
+      (0, _util.info)("Inconsistent font file Type/SubType, expected: " + `${this.type}/${this.subtype} but found: ${type}/${subtype}.`);
     }
+
     try {
       var data;
+
       switch (type) {
-        case 'MMType1':
-          (0, _util.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);
+        case "MMType1":
+          (0, _util.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);
           data = this.convert(name, cff, properties);
           break;
-        case 'OpenType':
-        case 'TrueType':
-        case 'CIDFontType2':
-          this.mimetype = 'font/opentype';
+
+        case "OpenType":
+        case "TrueType":
+        case "CIDFontType2":
+          this.mimetype = "font/opentype";
           data = this.checkAndRepair(name, file, properties);
+
           if (this.isOpenType) {
             adjustWidths(properties);
-            type = 'OpenType';
+            type = "OpenType";
           }
+
           break;
+
         default:
-          throw new _util.FormatError('Font ' + type + ' is not supported');
+          throw new _util.FormatError(`Font ${type} is not supported`);
       }
     } catch (e) {
       (0, _util.warn)(e);
       this.fallbackToSystemFont();
       return;
     }
+
     this.data = data;
     this.fontType = getFontType(type, subtype);
     this.fontMatrix = properties.fontMatrix;
@@ -432,216 +522,272 @@ var Font = function FontClosure() {
     this.encoding = properties.baseEncoding;
     this.seacMap = properties.seacMap;
   }
+
   Font.getFontID = function () {
     var ID = 1;
     return function Font_getFontID() {
       return String(ID++);
     };
   }();
+
   function int16(b0, b1) {
     return (b0 << 8) + b1;
   }
+
   function writeSignedInt16(bytes, index, value) {
     bytes[index + 1] = value;
     bytes[index] = value >>> 8;
   }
+
   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) {
-    value = value > 0x7FFF ? 0x7FFF : value < -0x8000 ? -0x8000 : value;
+    if (value > 0x7fff) {
+      value = 0x7fff;
+    } else if (value < -0x8000) {
+      value = -0x8000;
+    }
+
     return String.fromCharCode(value >> 8 & 0xff, value & 0xff);
   }
+
   function isTrueTypeFile(file) {
     var header = file.peekBytes(4);
-    return (0, _util.readUint32)(header, 0) === 0x00010000 || (0, _util.bytesToString)(header) === 'true';
+    return (0, _core_utils.readUint32)(header, 0) === 0x00010000 || (0, _util.bytesToString)(header) === "true";
   }
+
   function isTrueTypeCollectionFile(file) {
-    var header = file.peekBytes(4);
-    return (0, _util.bytesToString)(header) === 'ttcf';
+    const header = file.peekBytes(4);
+    return (0, _util.bytesToString)(header) === "ttcf";
   }
+
   function isOpenTypeFile(file) {
     var header = file.peekBytes(4);
-    return (0, _util.bytesToString)(header) === 'OTTO';
+    return (0, _util.bytesToString)(header) === "OTTO";
   }
+
   function isType1File(file) {
     var header = file.peekBytes(2);
+
     if (header[0] === 0x25 && header[1] === 0x21) {
       return true;
     }
+
     if (header[0] === 0x80 && header[1] === 0x01) {
       return true;
     }
+
     return false;
   }
+
   function isCFFFile(file) {
-    var header = file.peekBytes(4);
+    const header = file.peekBytes(4);
+
     if (header[0] >= 1 && header[3] >= 1 && header[3] <= 4) {
       return true;
     }
+
     return false;
   }
-  function getFontFileType(file, _ref) {
-    var type = _ref.type,
-        subtype = _ref.subtype,
-        composite = _ref.composite;
 
-    var fileType = void 0,
-        fileSubtype = void 0;
+  function getFontFileType(file, {
+    type,
+    subtype,
+    composite
+  }) {
+    let fileType, fileSubtype;
+
     if (isTrueTypeFile(file) || isTrueTypeCollectionFile(file)) {
       if (composite) {
-        fileType = 'CIDFontType2';
+        fileType = "CIDFontType2";
       } else {
-        fileType = 'TrueType';
+        fileType = "TrueType";
       }
     } else if (isOpenTypeFile(file)) {
       if (composite) {
-        fileType = 'CIDFontType2';
+        fileType = "CIDFontType2";
       } else {
-        fileType = 'OpenType';
+        fileType = "OpenType";
       }
     } else if (isType1File(file)) {
       if (composite) {
-        fileType = 'CIDFontType0';
+        fileType = "CIDFontType0";
       } else {
-        fileType = type === 'MMType1' ? 'MMType1' : 'Type1';
+        fileType = type === "MMType1" ? "MMType1" : "Type1";
       }
     } else if (isCFFFile(file)) {
       if (composite) {
-        fileType = 'CIDFontType0';
-        fileSubtype = 'CIDFontType0C';
+        fileType = "CIDFontType0";
+        fileSubtype = "CIDFontType0C";
       } else {
-        fileType = type === 'MMType1' ? 'MMType1' : 'Type1';
-        fileSubtype = 'Type1C';
+        fileType = type === "MMType1" ? "MMType1" : "Type1";
+        fileSubtype = "Type1C";
       }
     } else {
-      (0, _util.warn)('getFontFileType: Unable to detect correct font file Type/Subtype.');
+      (0, _util.warn)("getFontFileType: Unable to detect correct font file Type/Subtype.");
       fileType = type;
       fileSubtype = subtype;
     }
+
     return [fileType, fileSubtype];
   }
+
   function buildToFontChar(encoding, glyphsUnicodeMap, differences) {
     var toFontChar = [],
         unicode;
+
     for (var i = 0, ii = encoding.length; i < ii; i++) {
       unicode = (0, _unicode.getUnicodeForGlyph)(encoding[i], glyphsUnicodeMap);
+
       if (unicode !== -1) {
         toFontChar[i] = unicode;
       }
     }
+
     for (var charCode in differences) {
       unicode = (0, _unicode.getUnicodeForGlyph)(differences[charCode], glyphsUnicodeMap);
+
       if (unicode !== -1) {
         toFontChar[+charCode] = unicode;
       }
     }
+
     return toFontChar;
   }
+
   function adjustMapping(charCodeToGlyphId, hasGlyph, newGlyphZeroId) {
     var newMap = Object.create(null);
     var toFontChar = [];
     var privateUseAreaIndex = 0;
     var nextAvailableFontCharCode = PRIVATE_USE_AREAS[privateUseAreaIndex][0];
     var privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
+
     for (var originalCharCode in charCodeToGlyphId) {
       originalCharCode |= 0;
       var glyphId = charCodeToGlyphId[originalCharCode];
+
       if (!hasGlyph(glyphId)) {
         continue;
       }
+
       if (nextAvailableFontCharCode > privateUseOffetEnd) {
         privateUseAreaIndex++;
+
         if (privateUseAreaIndex >= PRIVATE_USE_AREAS.length) {
-          (0, _util.warn)('Ran out of space in font private use area.');
+          (0, _util.warn)("Ran out of space in font private use area.");
           break;
         }
+
         nextAvailableFontCharCode = PRIVATE_USE_AREAS[privateUseAreaIndex][0];
         privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
       }
+
       var fontCharCode = nextAvailableFontCharCode++;
+
       if (glyphId === 0) {
         glyphId = newGlyphZeroId;
       }
+
       newMap[fontCharCode] = glyphId;
       toFontChar[originalCharCode] = fontCharCode;
     }
+
     return {
-      toFontChar: toFontChar,
+      toFontChar,
       charCodeToGlyphId: newMap,
-      nextAvailableFontCharCode: nextAvailableFontCharCode
+      nextAvailableFontCharCode
     };
   }
+
   function getRanges(glyphs, numGlyphs) {
     var codes = [];
+
     for (var charCode in glyphs) {
       if (glyphs[charCode] >= numGlyphs) {
         continue;
       }
+
       codes.push({
         fontCharCode: charCode | 0,
         glyphId: glyphs[charCode]
       });
     }
+
     if (codes.length === 0) {
       codes.push({
         fontCharCode: 0,
         glyphId: 0
       });
     }
+
     codes.sort(function fontGetRangesSort(a, b) {
       return a.fontCharCode - b.fontCharCode;
     });
     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) {
+
+        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' + string16(numTables) + '\x00\x03' + '\x00\x01' + (0, _util.string32)(4 + numTables * 8);
+    var numTables = ranges[ranges.length - 1][1] > 0xffff ? 2 : 1;
+    var cmap = "\x00\x00" + string16(numTables) + "\x00\x03" + "\x00\x01" + (0, _util.string32)(4 + numTables * 8);
     var i, ii, j, jj;
+
     for (i = ranges.length - 1; i >= 0; --i) {
-      if (ranges[i][0] <= 0xFFFF) {
+      if (ranges[i][0] <= 0xffff) {
         break;
       }
     }
+
     var bmpLength = i + 1;
-    if (ranges[i][0] < 0xFFFF && ranges[i][1] === 0xFFFF) {
-      ranges[i][1] = 0xFFFE;
+
+    if (ranges[i][0] < 0xffff && ranges[i][1] === 0xffff) {
+      ranges[i][1] = 0xfffe;
     }
-    var trailingRangesCount = ranges[i][1] < 0xFFFF ? 1 : 0;
+
+    var trailingRangesCount = ranges[i][1] < 0xffff ? 1 : 0;
     var segCount = bmpLength + trailingRangesCount;
     var searchParams = OpenTypeFileBuilder.getSearchParams(segCount, 2);
-    var startCount = '';
-    var endCount = '';
-    var idDeltas = '';
-    var idRangeOffsets = '';
-    var glyphsIds = '';
+    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];
@@ -650,43 +796,51 @@ var Font = function FontClosure() {
       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);
+        idDeltas += string16(startCode - start & 0xffff);
         idRangeOffsets += string16(0);
       }
     }
+
     if (trailingRangesCount > 0) {
-      endCount += '\xFF\xFF';
-      startCount += '\xFF\xFF';
-      idDeltas += '\x00\x01';
-      idRangeOffsets += '\x00\x00';
+      endCount += "\xFF\xFF";
+      startCount += "\xFF\xFF";
+      idDeltas += "\x00\x01";
+      idRangeOffsets += "\x00\x00";
     }
-    var format314 = '\x00\x00' + string16(2 * segCount) + string16(searchParams.range) + string16(searchParams.entry) + string16(searchParams.rangeShift) + endCount + '\x00\x00' + startCount + idDeltas + idRangeOffsets + glyphsIds;
-    var format31012 = '';
-    var header31012 = '';
+
+    var format314 = "\x00\x00" + 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' + '\x00\x0A' + (0, _util.string32)(4 + numTables * 8 + 4 + format314.length);
-      format31012 = '';
+      cmap += "\x00\x03" + "\x00\x0A" + (0, _util.string32)(4 + numTables * 8 + 4 + format314.length);
+      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;
@@ -695,33 +849,44 @@ var Font = function FontClosure() {
             code = codes[j];
           }
         }
+
         format31012 += (0, _util.string32)(start) + (0, _util.string32)(range[1]) + (0, _util.string32)(code);
       }
-      header31012 = '\x00\x0C' + '\x00\x00' + (0, _util.string32)(format31012.length + 16) + '\x00\x00\x00\x00' + (0, _util.string32)(format31012.length / 12);
+
+      header31012 = "\x00\x0C" + "\x00\x00" + (0, _util.string32)(format31012.length + 16) + "\x00\x00\x00\x00" + (0, _util.string32)(format31012.length / 12);
     }
-    return cmap + '\x00\x04' + string16(format314.length + 4) + format314 + header31012 + format31012;
+
+    return cmap + "\x00\x04" + string16(format314.length + 4) + format314 + header31012 + format31012;
   }
+
   function validateOS2Table(os2) {
     var stream = new _stream.Stream(os2.data);
     var version = stream.getUint16();
     stream.getBytes(60);
     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);
     var usWinAscent = stream.getUint16();
+
     if (usWinAscent === 0) {
       return false;
     }
+
     os2.data[8] = os2.data[9] = 0;
     return true;
   }
+
   function createOS2Table(properties, charstrings, override) {
     override = override || {
       unitsPerEm: 0,
@@ -736,16 +901,21 @@ var Font = function FontClosure() {
     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 = (0, _unicode.getUnicodeRangeFor)(code);
+
         if (position < 32) {
           ulUnicodeRange1 |= 1 << position;
         } else if (position < 64) {
@@ -755,56 +925,69 @@ var Font = function FontClosure() {
         } else if (position < 123) {
           ulUnicodeRange4 |= 1 << position - 96;
         } else {
-          throw new _util.FormatError('Unicode ranges Bits > 123 are reserved for internal usage');
+          throw new _util.FormatError("Unicode ranges Bits > 123 are reserved for internal usage");
         }
       }
-      if (lastCharIndex > 0xFFFF) {
-        lastCharIndex = 0xFFFF;
+
+      if (lastCharIndex > 0xffff) {
+        lastCharIndex = 0xffff;
       }
     } else {
       firstCharIndex = 0;
       lastCharIndex = 255;
     }
+
     var bbox = properties.bbox || [0, 0, 0, 0];
     var unitsPerEm = override.unitsPerEm || 1 / (properties.fontMatrix || _util.FONT_IDENTITY_MATRIX)[0];
     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;
     }
+
     var winAscent = override.yMax || typoAscent;
     var winDescent = -override.yMin || -typoDescent;
-    return '\x00\x03' + '\x02\x24' + '\x01\xF4' + '\x00\x05' + '\x00\x00' + '\x02\x8A' + '\x02\xBB' + '\x00\x00' + '\x00\x8C' + '\x02\x8A' + '\x02\xBB' + '\x00\x00' + '\x01\xDF' + '\x00\x31' + '\x01\x02' + '\x00\x00' + '\x00\x00\x06' + String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) + '\x00\x00\x00\x00\x00\x00' + (0, _util.string32)(ulUnicodeRange1) + (0, _util.string32)(ulUnicodeRange2) + (0, _util.string32)(ulUnicodeRange3) + (0, _util.string32)(ulUnicodeRange4) + '\x2A\x32\x31\x2A' + string16(properties.italicAngle ? 1 : 0) + string16(firstCharIndex || properties.firstChar) + string16(lastCharIndex || properties.lastChar) + string16(typoAscent) + string16(typoDescent) + '\x00\x64' + string16(winAscent) + string16(winDescent) + '\x00\x00\x00\x00' + '\x00\x00\x00\x00' + string16(properties.xHeight) + string16(properties.capHeight) + string16(0) + string16(firstCharIndex || properties.firstChar) + '\x00\x03';
+    return "\x00\x03" + "\x02\x24" + "\x01\xF4" + "\x00\x05" + "\x00\x00" + "\x02\x8A" + "\x02\xBB" + "\x00\x00" + "\x00\x8C" + "\x02\x8A" + "\x02\xBB" + "\x00\x00" + "\x01\xDF" + "\x00\x31" + "\x01\x02" + "\x00\x00" + "\x00\x00\x06" + String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) + "\x00\x00\x00\x00\x00\x00" + (0, _util.string32)(ulUnicodeRange1) + (0, _util.string32)(ulUnicodeRange2) + (0, _util.string32)(ulUnicodeRange3) + (0, _util.string32)(ulUnicodeRange4) + "\x2A\x32\x31\x2A" + string16(properties.italicAngle ? 1 : 0) + string16(firstCharIndex || properties.firstChar) + string16(lastCharIndex || properties.lastChar) + string16(typoAscent) + string16(typoDescent) + "\x00\x64" + string16(winAscent) + string16(winDescent) + "\x00\x00\x00\x00" + "\x00\x00\x00\x00" + string16(properties.xHeight) + string16(properties.capHeight) + string16(0) + string16(firstCharIndex || properties.firstChar) + "\x00\x03";
   }
+
   function createPostTable(properties) {
-    var angle = Math.floor(properties.italicAngle * Math.pow(2, 16));
-    return '\x00\x03\x00\x00' + (0, _util.string32)(angle) + '\x00\x00' + '\x00\x00' + (0, _util.string32)(properties.fixedPitch) + '\x00\x00\x00\x00' + '\x00\x00\x00\x00' + '\x00\x00\x00\x00' + '\x00\x00\x00\x00';
+    var angle = Math.floor(properties.italicAngle * 2 ** 16);
+    return "\x00\x03\x00\x00" + (0, _util.string32)(angle) + "\x00\x00" + "\x00\x00" + (0, _util.string32)(properties.fixedPitch) + "\x00\x00\x00\x00" + "\x00\x00\x00\x00" + "\x00\x00\x00\x00" + "\x00\x00\x00\x00";
   }
+
   function createNameTable(name, proto) {
     if (!proto) {
       proto = [[], []];
     }
-    var strings = [proto[0][0] || 'Original licence', proto[0][1] || name, proto[0][2] || 'Unknown', proto[0][3] || 'uniqueID', proto[0][4] || name, proto[0][5] || 'Version 0.11', proto[0][6] || '', proto[0][7] || 'Unknown', proto[0][8] || 'Unknown', proto[0][9] || 'Unknown'];
+
+    var strings = [proto[0][0] || "Original licence", proto[0][1] || name, proto[0][2] || "Unknown", proto[0][3] || "uniqueID", proto[0][4] || name, proto[0][5] || "Version 0.11", proto[0][6] || "", proto[0][7] || "Unknown", proto[0][8] || "Unknown", proto[0][9] || "Unknown"];
     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(''));
+
+      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 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' + string16(namesRecordCount) + string16(namesRecordCount * 12 + 6);
+    var nameTable = "\x00\x00" + string16(namesRecordCount) + string16(namesRecordCount * 12 + 6);
     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] + encodings[i] + languages[i] + string16(j) + string16(str.length) + string16(strOffset);
@@ -812,36 +995,42 @@ var Font = function FontClosure() {
         strOffset += str.length;
       }
     }
-    nameTable += strings.join('') + stringsUnicode.join('');
+
+    nameTable += strings.join("") + stringsUnicode.join("");
     return nameTable;
   }
+
   Font.prototype = {
     name: null,
     font: null,
     mimetype: null,
     encoding: null,
+    disableFontFace: false,
+
     get renderer() {
       var renderer = _font_renderer.FontRendererFactory.create(this, SEAC_ANALYSIS_ENABLED);
-      return (0, _util.shadow)(this, 'renderer', renderer);
+
+      return (0, _util.shadow)(this, "renderer", renderer);
     },
+
     exportData: function Font_exportData() {
       var data = {};
+
       for (var i in this) {
         if (this.hasOwnProperty(i)) {
           data[i] = this[i];
         }
       }
+
       return data;
     },
     fallbackToSystemFont: function Font_fallbackToSystemFont() {
-      var _this = this;
-
       this.missingFile = true;
       var charCode, unicode;
       var name = this.name;
       var type = this.type;
       var subtype = this.subtype;
-      var fontName = name.replace(/[,_]/g, '-');
+      let fontName = name.replace(/[,_]/g, "-").replace(/\s/g, "");
       var stdFontMap = (0, _standard_fonts.getStdFontMap)(),
           nonStdFontMap = (0, _standard_fonts.getNonStdFontMap)();
       var isStandardFont = !!stdFontMap[fontName] || !!(nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]);
@@ -850,80 +1039,112 @@ var Font = function FontClosure() {
       this.italic = fontName.search(/oblique/gi) !== -1 || fontName.search(/italic/gi) !== -1;
       this.black = name.search(/Black/g) !== -1;
       this.remeasure = Object.keys(this.widths).length > 0;
-      if (isStandardFont && type === 'CIDFontType2' && this.cidEncoding.indexOf('Identity-') === 0) {
-        var GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)();
-        var map = [];
+
+      if (isStandardFont && type === "CIDFontType2" && this.cidEncoding.startsWith("Identity-")) {
+        const GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)();
+        const map = [];
+
         for (charCode in GlyphMapForStandardFonts) {
           map[+charCode] = GlyphMapForStandardFonts[charCode];
         }
+
         if (/Arial-?Black/i.test(name)) {
           var SupplementalGlyphMapForArialBlack = (0, _standard_fonts.getSupplementalGlyphMapForArialBlack)();
+
           for (charCode in SupplementalGlyphMapForArialBlack) {
             map[+charCode] = SupplementalGlyphMapForArialBlack[charCode];
           }
         } else if (/Calibri/i.test(name)) {
-          var SupplementalGlyphMapForCalibri = (0, _standard_fonts.getSupplementalGlyphMapForCalibri)();
+          const SupplementalGlyphMapForCalibri = (0, _standard_fonts.getSupplementalGlyphMapForCalibri)();
+
           for (charCode in SupplementalGlyphMapForCalibri) {
             map[+charCode] = SupplementalGlyphMapForCalibri[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(_encodings.SymbolSetEncoding, (0, _glyphlist.getGlyphsUnicode)(), this.differences);
       } else if (/Dingbats/i.test(fontName)) {
         if (/Wingdings/i.test(name)) {
-          (0, _util.warn)('Non-embedded Wingdings font, falling back to ZapfDingbats.');
+          (0, _util.warn)("Non-embedded Wingdings font, falling back to ZapfDingbats.");
         }
+
         this.toFontChar = buildToFontChar(_encodings.ZapfDingbatsEncoding, (0, _glyphlist.getDingbatsGlyphsUnicode)(), this.differences);
       } else if (isStandardFont) {
         this.toFontChar = buildToFontChar(this.defaultEncoding, (0, _glyphlist.getGlyphsUnicode)(), this.differences);
       } else {
-        var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
-        this.toUnicode.forEach(function (charCode, unicodeCharCode) {
-          if (!_this.composite) {
-            var glyphName = _this.differences[charCode] || _this.defaultEncoding[charCode];
+        const glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+        const map = [];
+        this.toUnicode.forEach((charCode, unicodeCharCode) => {
+          if (!this.composite) {
+            var glyphName = this.differences[charCode] || this.defaultEncoding[charCode];
             unicode = (0, _unicode.getUnicodeForGlyph)(glyphName, glyphsUnicodeMap);
+
             if (unicode !== -1) {
               unicodeCharCode = unicode;
             }
           }
-          _this.toFontChar[charCode] = unicodeCharCode;
+
+          map[+charCode] = unicodeCharCode;
         });
+
+        if (this.composite && this.toUnicode instanceof IdentityToUnicodeMap) {
+          if (/Verdana/i.test(name)) {
+            const GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)();
+
+            for (charCode in GlyphMapForStandardFonts) {
+              map[+charCode] = GlyphMapForStandardFonts[charCode];
+            }
+          }
+        }
+
+        this.toFontChar = map;
       }
-      this.loadedName = fontName.split('-')[0];
+
+      this.loadedName = fontName.split("-")[0];
       this.fontType = getFontType(type, subtype);
     },
     checkAndRepair: function Font_checkAndRepair(name, font, properties) {
-      var VALID_TABLES = ['OS/2', 'cmap', 'head', 'hhea', 'hmtx', 'maxp', 'name', 'post', 'loca', 'glyf', 'fpgm', 'prep', 'cvt ', 'CFF '];
+      const VALID_TABLES = ["OS/2", "cmap", "head", "hhea", "hmtx", "maxp", "name", "post", "loca", "glyf", "fpgm", "prep", "cvt ", "CFF "];
+
       function readTables(file, numTables) {
-        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;
-        for (var i = 0; i < numTables; i++) {
-          var table = readTableEntry(font);
+        const 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;
+
+        for (let i = 0; i < numTables; i++) {
+          const table = readTableEntry(font);
+
           if (!VALID_TABLES.includes(table.tag)) {
             continue;
           }
+
           if (table.length === 0) {
             continue;
           }
+
           tables[table.tag] = table;
         }
+
         return tables;
       }
+
       function readTableEntry(file) {
         var tag = (0, _util.bytesToString)(file.getBytes(4));
         var checksum = file.getInt32() >>> 0;
@@ -934,18 +1155,21 @@ var Font = function FontClosure() {
         file.skip(offset);
         var data = file.getBytes(length);
         file.pos = previousPosition;
-        if (tag === 'head') {
+
+        if (tag === "head") {
           data[8] = data[9] = data[10] = data[11] = 0;
           data[17] |= 0x20;
         }
+
         return {
-          tag: tag,
-          checksum: checksum,
-          length: length,
-          offset: offset,
-          data: data
+          tag,
+          checksum,
+          length,
+          offset,
+          data
         };
       }
+
       function readOpenTypeHeader(ttf) {
         return {
           version: (0, _util.bytesToString)(ttf.getBytes(4)),
@@ -955,51 +1179,63 @@ var Font = function FontClosure() {
           rangeShift: ttf.getUint16()
         };
       }
+
       function readTrueTypeCollectionHeader(ttc) {
-        var ttcTag = (0, _util.bytesToString)(ttc.getBytes(4));
-        (0, _util.assert)(ttcTag === 'ttcf', 'Must be a TrueType Collection font.');
-        var majorVersion = ttc.getUint16();
-        var minorVersion = ttc.getUint16();
-        var numFonts = ttc.getInt32() >>> 0;
-        var offsetTable = [];
-        for (var i = 0; i < numFonts; i++) {
+        const ttcTag = (0, _util.bytesToString)(ttc.getBytes(4));
+        (0, _util.assert)(ttcTag === "ttcf", "Must be a TrueType Collection font.");
+        const majorVersion = ttc.getUint16();
+        const minorVersion = ttc.getUint16();
+        const numFonts = ttc.getInt32() >>> 0;
+        const offsetTable = [];
+
+        for (let i = 0; i < numFonts; i++) {
           offsetTable.push(ttc.getInt32() >>> 0);
         }
-        var header = {
-          ttcTag: ttcTag,
-          majorVersion: majorVersion,
-          minorVersion: minorVersion,
-          numFonts: numFonts,
-          offsetTable: offsetTable
+
+        const header = {
+          ttcTag,
+          majorVersion,
+          minorVersion,
+          numFonts,
+          offsetTable
         };
+
         switch (majorVersion) {
           case 1:
             return header;
+
           case 2:
             header.dsigTag = ttc.getInt32() >>> 0;
             header.dsigLength = ttc.getInt32() >>> 0;
             header.dsigOffset = ttc.getInt32() >>> 0;
             return header;
         }
-        throw new _util.FormatError('Invalid TrueType Collection majorVersion: ' + majorVersion + '.');
+
+        throw new _util.FormatError(`Invalid TrueType Collection majorVersion: ${majorVersion}.`);
       }
+
       function readTrueTypeCollectionData(ttc, fontName) {
-        var _readTrueTypeCollecti = readTrueTypeCollectionHeader(ttc),
-            numFonts = _readTrueTypeCollecti.numFonts,
-            offsetTable = _readTrueTypeCollecti.offsetTable;
+        const {
+          numFonts,
+          offsetTable
+        } = readTrueTypeCollectionHeader(ttc);
 
-        for (var i = 0; i < numFonts; i++) {
+        for (let i = 0; i < numFonts; i++) {
           ttc.pos = (ttc.start || 0) + offsetTable[i];
-          var potentialHeader = readOpenTypeHeader(ttc);
-          var potentialTables = readTables(ttc, potentialHeader.numTables);
-          if (!potentialTables['name']) {
+          const potentialHeader = readOpenTypeHeader(ttc);
+          const potentialTables = readTables(ttc, potentialHeader.numTables);
+
+          if (!potentialTables["name"]) {
             throw new _util.FormatError('TrueType Collection font must contain a "name" table.');
           }
-          var nameTable = readNameTable(potentialTables['name']);
-          for (var j = 0, jj = nameTable.length; j < jj; j++) {
-            for (var k = 0, kk = nameTable[j].length; k < kk; k++) {
-              var nameEntry = nameTable[j][k];
-              if (nameEntry && nameEntry.replace(/\s/g, '') === fontName) {
+
+          const nameTable = readNameTable(potentialTables["name"]);
+
+          for (let j = 0, jj = nameTable.length; j < jj; j++) {
+            for (let k = 0, kk = nameTable[j].length; k < kk; k++) {
+              const nameEntry = nameTable[j][k];
+
+              if (nameEntry && nameEntry.replace(/\s/g, "") === fontName) {
                 return {
                   header: potentialHeader,
                   tables: potentialTables
@@ -1008,11 +1244,13 @@ var Font = function FontClosure() {
             }
           }
         }
-        throw new _util.FormatError('TrueType Collection does not contain "' + fontName + '" font.');
+
+        throw new _util.FormatError(`TrueType Collection does not contain "${fontName}" font.`);
       }
+
       function readCmapTable(cmap, font, isSymbolicFont, hasEncoding) {
         if (!cmap) {
-          (0, _util.warn)('No cmap table available.');
+          (0, _util.warn)("No cmap table available.");
           return {
             platformId: -1,
             encodingId: -1,
@@ -1020,6 +1258,7 @@ var Font = function FontClosure() {
             hasShortCmap: false
           };
         }
+
         var segment;
         var start = (font.start ? font.start : 0) + cmap.offset;
         font.pos = start;
@@ -1027,20 +1266,24 @@ var Font = function FontClosure() {
         var numTables = font.getUint16();
         var potentialTable;
         var canBreak = false;
+
         for (var i = 0; i < numTables; i++) {
           var platformId = font.getUint16();
           var encodingId = font.getUint16();
           var offset = font.getInt32() >>> 0;
           var useTable = false;
+
           if (potentialTable && potentialTable.platformId === platformId && potentialTable.encodingId === encodingId) {
             continue;
           }
+
           if (platformId === 0 && encodingId === 0) {
             useTable = true;
           } else if (platformId === 1 && encodingId === 0) {
             useTable = true;
           } else if (platformId === 3 && encodingId === 1 && (hasEncoding || !potentialTable)) {
             useTable = true;
+
             if (!isSymbolicFont) {
               canBreak = true;
             }
@@ -1048,22 +1291,26 @@ var Font = function FontClosure() {
             useTable = true;
             canBreak = true;
           }
+
           if (useTable) {
             potentialTable = {
-              platformId: platformId,
-              encodingId: encodingId,
-              offset: offset
+              platformId,
+              encodingId,
+              offset
             };
           }
+
           if (canBreak) {
             break;
           }
         }
+
         if (potentialTable) {
           font.pos = start + potentialTable.offset;
         }
+
         if (!potentialTable || font.peekByte() === -1) {
-          (0, _util.warn)('Could not find a preferred cmap table.');
+          (0, _util.warn)("Could not find a preferred cmap table.");
           return {
             platformId: -1,
             encodingId: -1,
@@ -1071,86 +1318,107 @@ var Font = function FontClosure() {
             hasShortCmap: false
           };
         }
+
         var format = font.getUint16();
         font.getUint16();
         font.getUint16();
         var hasShortCmap = false;
         var mappings = [];
         var j, glyphId;
+
         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) {
           var segCount = font.getUint16() >> 1;
           font.getBytes(6);
           var segIndex,
               segments = [];
+
           for (segIndex = 0; segIndex < segCount; segIndex++) {
-            segments.push({ end: font.getUint16() });
+            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) {
+              if (j === 0xffff) {
                 continue;
               }
+
               glyphId = offsetIndex < 0 ? j : offsets[offsetIndex + j - start];
-              glyphId = glyphId + delta & 0xFFFF;
+              glyphId = glyphId + delta & 0xffff;
               mappings.push({
                 charCode: j,
-                glyphId: glyphId
+                glyphId
               });
             }
           }
         } else if (format === 6) {
           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
+              charCode,
+              glyphId
             });
           }
         } else {
-          (0, _util.warn)('cmap table has unsupported format: ' + format);
+          (0, _util.warn)("cmap table has unsupported format: " + format);
           return {
             platformId: -1,
             encodingId: -1,
@@ -1158,56 +1426,87 @@ var Font = function FontClosure() {
             hasShortCmap: false
           };
         }
+
         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
+          mappings,
+          hasShortCmap
         };
       }
-      function sanitizeMetrics(font, header, metrics, numGlyphs) {
+
+      function sanitizeMetrics(font, header, metrics, numGlyphs, dupFirstEntry) {
         if (!header) {
           if (metrics) {
             metrics.data = null;
           }
+
           return;
         }
+
         font.pos = (font.start ? font.start : 0) + header.offset;
-        font.pos += header.length - 2;
+        font.pos += 4;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 2;
+        font.pos += 8;
+        font.pos += 2;
         var numOfMetrics = font.getUint16();
+
         if (numOfMetrics > numGlyphs) {
-          (0, _util.info)('The numOfMetrics (' + numOfMetrics + ') should not be ' + 'greater than the numGlyphs (' + numGlyphs + ')');
+          (0, _util.info)("The numOfMetrics (" + numOfMetrics + ") should not be " + "greater than the numGlyphs (" + 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) {
           var entries = new Uint8Array(metrics.length + numMissing * 2);
           entries.set(metrics.data);
+
+          if (dupFirstEntry) {
+            entries[metrics.length] = metrics.data[2];
+            entries[metrics.length + 1] = metrics.data[3];
+          }
+
           metrics.data = entries;
         }
       }
+
       function sanitizeGlyph(source, sourceStart, sourceEnd, dest, destStart, hintsValid) {
         var glyphProfile = {
           length: 0,
           sizeOfInstructions: 0
         };
+
         if (sourceEnd - sourceStart <= 12) {
           return glyphProfile;
         }
+
         var glyf = source.subarray(sourceStart, sourceEnd);
         var contoursCount = signedInt16(glyf[0], glyf[1]);
+
         if (contoursCount < 0) {
           contoursCount = -1;
           writeSignedInt16(glyf, 0, contoursCount);
@@ -1215,75 +1514,111 @@ var Font = function FontClosure() {
           glyphProfile.length = glyf.length;
           return glyphProfile;
         }
+
         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;
         }
+
         var instructionsStart = j;
         var instructionsLength = glyf[j] << 8 | glyf[j + 1];
         glyphProfile.sizeOfInstructions = instructionsLength;
         j += 2 + instructionsLength;
         var instructionsEnd = j;
         var coordinatesLength = 0;
+
         for (i = 0; i < flagsCount; i++) {
           var flag = glyf[j++];
-          if (flag & 0xC0) {
-            glyf[j - 1] = flag & 0x3F;
+
+          if (flag & 0xc0) {
+            glyf[j - 1] = flag & 0x3f;
+          }
+
+          let xLength = 2;
+
+          if (flag & 2) {
+            xLength = 1;
+          } else if (flag & 16) {
+            xLength = 0;
+          }
+
+          let yLength = 2;
+
+          if (flag & 4) {
+            yLength = 1;
+          } else if (flag & 32) {
+            yLength = 0;
           }
-          var xyLength = (flag & 2 ? 1 : flag & 16 ? 0 : 2) + (flag & 4 ? 1 : flag & 32 ? 0 : 2);
+
+          const xyLength = xLength + yLength;
           coordinatesLength += xyLength;
+
           if (flag & 8) {
             var repeat = glyf[j++];
             i += repeat;
             coordinatesLength += repeat * xyLength;
           }
         }
+
         if (coordinatesLength === 0) {
           return glyphProfile;
         }
+
         var glyphDataLength = j + coordinatesLength;
+
         if (glyphDataLength > glyf.length) {
           return glyphProfile;
         }
+
         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;
           }
+
           glyphProfile.length = glyphDataLength;
           return glyphProfile;
         }
+
         if (glyf.length - glyphDataLength > 3) {
           glyphDataLength = glyphDataLength + 3 & ~3;
           dest.set(glyf.subarray(0, glyphDataLength), destStart);
           glyphProfile.length = glyphDataLength;
           return glyphProfile;
         }
+
         dest.set(glyf, destStart);
         glyphProfile.length = glyf.length;
         return glyphProfile;
       }
+
       function sanitizeHead(head, numGlyphs, locaLength) {
         var data = head.data;
         var version = int32(data[0], data[1], data[2], data[3]);
+
         if (version >> 16 !== 1) {
-          (0, _util.info)('Attempting to fix invalid version in head table: ' + version);
+          (0, _util.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) {
-          (0, _util.info)('Attempting to fix invalid indexToLocFormat in head table: ' + indexToLocFormat);
+          (0, _util.info)("Attempting to fix invalid indexToLocFormat in head table: " + indexToLocFormat);
           var numGlyphsPlusOne = numGlyphs + 1;
+
           if (locaLength === numGlyphsPlusOne << 1) {
             data[50] = 0;
             data[51] = 0;
@@ -1291,37 +1626,43 @@ var Font = function FontClosure() {
             data[50] = 0;
             data[51] = 1;
           } else {
-            throw new _util.FormatError('Could not fix indexToLocFormat: ' + indexToLocFormat);
+            throw new _util.FormatError("Could not fix indexToLocFormat: " + indexToLocFormat);
           }
         }
       }
+
       function sanitizeGlyphLocations(loca, glyf, numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry, maxSizeOfInstructions) {
         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;
+            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;
+            data[offset] = value >> 9 & 0xff;
+            data[offset + 1] = value >> 1 & 0xff;
           };
         }
+
         var numGlyphsOut = dupFirstEntry ? numGlyphs + 1 : numGlyphs;
-        var locaData = loca.data;
         var locaDataSize = itemSize * (1 + numGlyphsOut);
-        locaData = new Uint8Array(locaDataSize);
+        var locaData = new Uint8Array(locaDataSize);
         locaData.set(loca.data.subarray(0, locaDataSize));
         loca.data = locaData;
         var oldGlyfData = glyf.data;
@@ -1332,53 +1673,68 @@ var Font = function FontClosure() {
         var missingGlyphs = 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 === 0) {
             endOffset = startOffset;
           }
+
           if (endOffset > oldGlyfDataLength && (oldGlyfDataLength + 3 & ~3) === endOffset) {
             endOffset = oldGlyfDataLength;
           }
+
           if (endOffset > oldGlyfDataLength) {
             startOffset = endOffset;
           }
+
           var glyphProfile = sanitizeGlyph(oldGlyfData, startOffset, endOffset, newGlyfData, writeOffset, hintsValid);
           var newLength = glyphProfile.length;
+
           if (newLength === 0) {
             missingGlyphs[i] = true;
           }
+
           if (glyphProfile.sizeOfInstructions > maxSizeOfInstructions) {
             maxSizeOfInstructions = glyphProfile.sizeOfInstructions;
           }
+
           writeOffset += newLength;
           itemEncode(locaData, j, writeOffset);
           startOffset = endOffset;
         }
+
         if (writeOffset === 0) {
           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 < numGlyphsOut; i++, j += itemSize) {
             itemEncode(locaData, j, simpleGlyph.length);
           }
+
           glyf.data = simpleGlyph;
         } else 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 {
-          missingGlyphs: missingGlyphs,
-          maxSizeOfInstructions: maxSizeOfInstructions
+          missingGlyphs,
+          maxSizeOfInstructions
         };
       }
+
       function readPostScriptTable(post, properties, maxpNumGlyphs) {
         var start = (font.start ? font.start : 0) + post.offset;
         font.pos = start;
@@ -1389,61 +1745,84 @@ var Font = function FontClosure() {
         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(''));
+
+              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:
-            (0, _util.warn)('Unknown/unsupported post table version ' + version);
+            (0, _util.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;
@@ -1452,14 +1831,17 @@ var Font = function FontClosure() {
             end = start + length;
         var format = font.getUint16();
         var FORMAT_0_HEADER_LENGTH = 6;
+
         if (format !== 0 || length < FORMAT_0_HEADER_LENGTH) {
           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(),
@@ -1469,34 +1851,46 @@ var Font = function FontClosure() {
             length: font.getUint16(),
             offset: font.getUint16()
           };
+
           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;
           }
+
           var pos = start + stringsStart + record.offset;
+
           if (pos + record.length > end) {
             continue;
           }
+
           font.pos = pos;
           var nameIndex = record.name;
+
           if (record.encoding) {
-            var str = '';
+            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] = (0, _util.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];
+
       function sanitizeTTProgram(table, ttContext) {
         var data = table.data;
         var i = 0,
@@ -1514,10 +1908,13 @@ var Font = function FontClosure() {
         var inFDEF = false,
             ifLevel = 0,
             inELSE = 0;
+
         for (var ii = data.length; i < ii;) {
           var op = data[i++];
+
           if (op === 0x40) {
             n = data[i++];
+
             if (inFDEF || inELSE) {
               i += n;
             } else {
@@ -1527,6 +1924,7 @@ var Font = function FontClosure() {
             }
           } else if (op === 0x41) {
             n = data[i++];
+
             if (inFDEF || inELSE) {
               i += n * 2;
             } else {
@@ -1535,8 +1933,9 @@ var Font = function FontClosure() {
                 stack.push(b << 8 | data[i++]);
               }
             }
-          } else if ((op & 0xF8) === 0xB0) {
-            n = op - 0xB0 + 1;
+          } else if ((op & 0xf8) === 0xb0) {
+            n = op - 0xb0 + 1;
+
             if (inFDEF || inELSE) {
               i += n;
             } else {
@@ -1544,8 +1943,9 @@ var Font = function FontClosure() {
                 stack.push(data[i++]);
               }
             }
-          } else if ((op & 0xF8) === 0xB8) {
-            n = op - 0xB8 + 1;
+          } else if ((op & 0xf8) === 0xb8) {
+            n = op - 0xb8 + 1;
+
             if (inFDEF || inELSE) {
               i += n * 2;
             } else {
@@ -1554,62 +1954,71 @@ var Font = function FontClosure() {
                 stack.push(b << 8 | data[i++]);
               }
             }
-          } else if (op === 0x2B && !tooComplexToFollowFunctions) {
+          } else if (op === 0x2b && !tooComplexToFollowFunctions) {
             if (!inFDEF && !inELSE) {
               funcId = stack[stack.length - 1];
+
               if (isNaN(funcId)) {
-                (0, _util.info)('TT: CALL empty stack (or invalid entry).');
+                (0, _util.info)("TT: CALL empty stack (or invalid entry).");
               } else {
                 ttContext.functionsUsed[funcId] = true;
+
                 if (funcId in ttContext.functionsStackDeltas) {
-                  var newStackLength = stack.length + ttContext.functionsStackDeltas[funcId];
+                  const newStackLength = stack.length + ttContext.functionsStackDeltas[funcId];
+
                   if (newStackLength < 0) {
-                    (0, _util.warn)('TT: CALL invalid functions stack delta.');
+                    (0, _util.warn)("TT: CALL invalid functions stack delta.");
                     ttContext.hintsValid = false;
                     return;
                   }
+
                   stack.length = newStackLength;
                 } else if (funcId in ttContext.functionsDefined && !functionsCalled.includes(funcId)) {
                   callstack.push({
-                    data: data,
-                    i: i,
+                    data,
+                    i,
                     stackTop: stack.length - 1
                   });
                   functionsCalled.push(funcId);
                   pc = ttContext.functionsDefined[funcId];
+
                   if (!pc) {
-                    (0, _util.warn)('TT: CALL non-existent function');
+                    (0, _util.warn)("TT: CALL non-existent function");
                     ttContext.hintsValid = false;
                     return;
                   }
+
                   data = pc.data;
                   i = pc.i;
                 }
               }
             }
-          } else if (op === 0x2C && !tooComplexToFollowFunctions) {
+          } else if (op === 0x2c && !tooComplexToFollowFunctions) {
             if (inFDEF || inELSE) {
-              (0, _util.warn)('TT: nested FDEFs not allowed');
+              (0, _util.warn)("TT: nested FDEFs not allowed");
               tooComplexToFollowFunctions = true;
             }
+
             inFDEF = true;
             lastDeff = i;
             funcId = stack.pop();
             ttContext.functionsDefined[funcId] = {
-              data: data,
-              i: i
+              data,
+              i
             };
-          } else if (op === 0x2D) {
+          } else if (op === 0x2d) {
             if (inFDEF) {
               inFDEF = false;
               lastEndf = i;
             } else {
               pc = callstack.pop();
+
               if (!pc) {
-                (0, _util.warn)('TT: ENDF bad stack');
+                (0, _util.warn)("TT: ENDF bad stack");
                 ttContext.hintsValid = false;
                 return;
               }
+
               funcId = functionsCalled.pop();
               data = pc.data;
               i = pc.i;
@@ -1617,97 +2026,127 @@ var Font = function FontClosure() {
             }
           } else if (op === 0x89) {
             if (inFDEF || inELSE) {
-              (0, _util.warn)('TT: nested IDEFs not allowed');
+              (0, _util.warn)("TT: nested IDEFs not allowed");
               tooComplexToFollowFunctions = true;
             }
+
             inFDEF = true;
             lastDeff = i;
           } else if (op === 0x58) {
             ++ifLevel;
-          } else if (op === 0x1B) {
+          } else if (op === 0x1b) {
             inELSE = ifLevel;
           } else if (op === 0x59) {
             if (inELSE === ifLevel) {
               inELSE = 0;
             }
+
             --ifLevel;
-          } else if (op === 0x1C) {
+          } else if (op === 0x1c) {
             if (!inFDEF && !inELSE) {
               var offset = stack[stack.length - 1];
+
               if (offset > 0) {
                 i += offset - 1;
               }
             }
           }
+
           if (!inFDEF && !inELSE) {
-            var stackDelta = op <= 0x8E ? TTOpsStackDeltas[op] : op >= 0xC0 && op <= 0xDF ? -1 : op >= 0xE0 ? -2 : 0;
+            let stackDelta = 0;
+
+            if (op <= 0x8e) {
+              stackDelta = TTOpsStackDeltas[op];
+            } else if (op >= 0xc0 && op <= 0xdf) {
+              stackDelta = -1;
+            } else if (op >= 0xe0) {
+              stackDelta = -2;
+            }
+
             if (op >= 0x71 && op <= 0x75) {
               n = stack.pop();
+
               if (!isNaN(n)) {
                 stackDelta = -n * 2;
               }
             }
+
             while (stackDelta < 0 && stack.length > 0) {
               stack.pop();
               stackDelta++;
             }
+
             while (stackDelta > 0) {
               stack.push(NaN);
               stackDelta--;
             }
           }
         }
+
         ttContext.tooComplexToFollowFunctions = tooComplexToFollowFunctions;
         var content = [data];
+
         if (i > data.length) {
           content.push(new Uint8Array(i - data.length));
         }
+
         if (lastDeff > lastEndf) {
-          (0, _util.warn)('TT: complementing a missing function tail');
-          content.push(new Uint8Array([0x22, 0x2D]));
+          (0, _util.warn)("TT: complementing a missing function tail");
+          content.push(new Uint8Array([0x22, 0x2d]));
         }
+
         foldTTTable(table, content);
       }
+
       function checkInvalidFunctions(ttContext, maxFunctionDefs) {
         if (ttContext.tooComplexToFollowFunctions) {
           return;
         }
+
         if (ttContext.functionsDefined.length > maxFunctionDefs) {
-          (0, _util.warn)('TT: more functions defined than expected');
+          (0, _util.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) {
-            (0, _util.warn)('TT: invalid function id: ' + j);
+            (0, _util.warn)("TT: invalid function id: " + j);
             ttContext.hintsValid = false;
             return;
           }
+
           if (ttContext.functionsUsed[j] && !ttContext.functionsDefined[j]) {
-            (0, _util.warn)('TT: undefined function: ' + j);
+            (0, _util.warn)("TT: undefined function: " + j);
             ttContext.hintsValid = false;
             return;
           }
         }
       }
+
       function foldTTTable(table, content) {
         if (content.length > 1) {
           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: [],
@@ -1716,307 +2155,381 @@ var Font = function FontClosure() {
           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;
       }
+
       font = new _stream.Stream(new Uint8Array(font.getBytes()));
-      var header = void 0,
-          tables = void 0;
+      let header, tables;
+
       if (isTrueTypeCollectionFile(font)) {
-        var ttcData = readTrueTypeCollectionData(font, this.name);
+        const ttcData = readTrueTypeCollectionData(font, this.name);
         header = ttcData.header;
         tables = ttcData.tables;
       } else {
         header = readOpenTypeHeader(font);
         tables = readTables(font, header.numTables);
       }
-      var cff = void 0,
-          cffFile = void 0;
-      var isTrueType = !tables['CFF '];
+
+      let cff, cffFile;
+      var isTrueType = !tables["CFF "];
+
       if (!isTrueType) {
-        var isComposite = properties.composite && ((properties.cidToGidMap || []).length > 0 || !(properties.cMap instanceof _cmap.IdentityCMap));
-        if (header.version === 'OTTO' && !isComposite || !tables['head'] || !tables['hhea'] || !tables['maxp'] || !tables['post']) {
-          cffFile = new _stream.Stream(tables['CFF '].data);
+        const isComposite = properties.composite && ((properties.cidToGidMap || []).length > 0 || !(properties.cMap instanceof _cmap.IdentityCMap));
+
+        if (header.version === "OTTO" && !isComposite || !tables["head"] || !tables["hhea"] || !tables["maxp"] || !tables["post"]) {
+          cffFile = new _stream.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 '];
+
+        delete tables["glyf"];
+        delete tables["loca"];
+        delete tables["fpgm"];
+        delete tables["prep"];
+        delete tables["cvt "];
         this.isOpenType = true;
       } else {
-        if (!tables['loca']) {
+        if (!tables["loca"]) {
           throw new _util.FormatError('Required "loca" table is not found');
         }
-        if (!tables['glyf']) {
+
+        if (!tables["glyf"]) {
           (0, _util.warn)('Required "glyf" table is not found -- trying to recover.');
-          tables['glyf'] = {
-            tag: 'glyf',
+          tables["glyf"] = {
+            tag: "glyf",
             data: new Uint8Array(0)
           };
         }
+
         this.isOpenType = false;
       }
-      if (!tables['maxp']) {
+
+      if (!tables["maxp"]) {
         throw new _util.FormatError('Required "maxp" table is not found');
       }
-      font.pos = (font.start || 0) + tables['maxp'].offset;
+
+      font.pos = (font.start || 0) + tables["maxp"].offset;
       var version = font.getInt32();
-      var numGlyphs = font.getUint16();
-      var numGlyphsOut = numGlyphs + 1;
-      var dupFirstEntry = true;
-      if (numGlyphsOut > 0xFFFF) {
+      const numGlyphs = font.getUint16();
+      let numGlyphsOut = numGlyphs + 1;
+      let dupFirstEntry = true;
+
+      if (numGlyphsOut > 0xffff) {
         dupFirstEntry = false;
         numGlyphsOut = numGlyphs;
-        (0, _util.warn)('Not enough space in glyfs to duplicate first glyph.');
+        (0, _util.warn)("Not enough space in glyfs to duplicate first glyph.");
       }
+
       var maxFunctionDefs = 0;
       var maxSizeOfInstructions = 0;
-      if (version >= 0x00010000 && tables['maxp'].length >= 22) {
+
+      if (version >= 0x00010000 && tables["maxp"].length >= 22) {
         font.pos += 8;
         var maxZones = font.getUint16();
+
         if (maxZones > 2) {
-          tables['maxp'].data[14] = 0;
-          tables['maxp'].data[15] = 2;
+          tables["maxp"].data[14] = 0;
+          tables["maxp"].data[15] = 2;
         }
+
         font.pos += 4;
         maxFunctionDefs = font.getUint16();
         font.pos += 4;
         maxSizeOfInstructions = font.getUint16();
       }
-      tables['maxp'].data[4] = numGlyphsOut >> 8;
-      tables['maxp'].data[5] = numGlyphsOut & 255;
-      var hintsValid = sanitizeTTPrograms(tables['fpgm'], tables['prep'], tables['cvt '], maxFunctionDefs);
+
+      tables["maxp"].data[4] = numGlyphsOut >> 8;
+      tables["maxp"].data[5] = numGlyphsOut & 255;
+      var hintsValid = sanitizeTTPrograms(tables["fpgm"], tables["prep"], tables["cvt "], maxFunctionDefs);
+
       if (!hintsValid) {
-        delete tables['fpgm'];
-        delete tables['prep'];
-        delete tables['cvt '];
+        delete tables["fpgm"];
+        delete tables["prep"];
+        delete tables["cvt "];
       }
-      sanitizeMetrics(font, tables['hhea'], tables['hmtx'], numGlyphsOut);
-      if (!tables['head']) {
+
+      sanitizeMetrics(font, tables["hhea"], tables["hmtx"], numGlyphsOut, dupFirstEntry);
+
+      if (!tables["head"]) {
         throw new _util.FormatError('Required "head" table is not found');
       }
-      sanitizeHead(tables['head'], numGlyphs, isTrueType ? tables['loca'].length : 0);
+
+      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]);
-        var glyphsInfo = sanitizeGlyphLocations(tables['loca'], tables['glyf'], numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry, maxSizeOfInstructions);
+        var isGlyphLocationsLong = int16(tables["head"].data[50], tables["head"].data[51]);
+        var glyphsInfo = sanitizeGlyphLocations(tables["loca"], tables["glyf"], numGlyphs, isGlyphLocationsLong, hintsValid, dupFirstEntry, maxSizeOfInstructions);
         missingGlyphs = glyphsInfo.missingGlyphs;
-        if (version >= 0x00010000 && tables['maxp'].length >= 22) {
-          tables['maxp'].data[26] = glyphsInfo.maxSizeOfInstructions >> 8;
-          tables['maxp'].data[27] = glyphsInfo.maxSizeOfInstructions & 255;
+
+        if (version >= 0x00010000 && tables["maxp"].length >= 22) {
+          tables["maxp"].data[26] = glyphsInfo.maxSizeOfInstructions >> 8;
+          tables["maxp"].data[27] = glyphsInfo.maxSizeOfInstructions & 255;
         }
       }
-      if (!tables['hhea']) {
+
+      if (!tables["hhea"]) {
         throw new _util.FormatError('Required "hhea" table is not found');
       }
-      if (tables['hhea'].data[10] === 0 && tables['hhea'].data[11] === 0) {
-        tables['hhea'].data[10] = 0xFF;
-        tables['hhea'].data[11] = 0xFF;
+
+      if (tables["hhea"].data[10] === 0 && tables["hhea"].data[11] === 0) {
+        tables["hhea"].data[10] = 0xff;
+        tables["hhea"].data[11] = 0xff;
       }
+
       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])
+        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])
       };
       this.ascent = metricsOverride.ascent / metricsOverride.unitsPerEm;
       this.descent = metricsOverride.descent / metricsOverride.unitsPerEm;
-      if (tables['post']) {
-        readPostScriptTable(tables['post'], properties, numGlyphs);
+
+      if (tables["post"]) {
+        readPostScriptTable(tables["post"], properties, numGlyphs);
       }
-      tables['post'] = {
-        tag: 'post',
+
+      tables["post"] = {
+        tag: "post",
         data: createPostTable(properties)
       };
       var charCodeToGlyphId = [],
           charCode;
+
       function hasGlyph(glyphId) {
         return !missingGlyphs[glyphId];
       }
+
       if (properties.composite) {
         var cidToGidMap = properties.cidToGidMap || [];
         var isCidToGidMapEmpty = cidToGidMap.length === 0;
         properties.cMap.forEach(function (charCode, cid) {
           if (cid > 0xffff) {
-            throw new _util.FormatError('Max size of CID is 65,535');
+            throw new _util.FormatError("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)) {
             charCodeToGlyphId[charCode] = glyphId;
           }
         });
       } else {
-        var cmapTable = readCmapTable(tables['cmap'], font, this.isSymbolicFont, properties.hasEncoding);
+        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;
+
         if (properties.hasEncoding && (cmapPlatformId === 3 && cmapEncodingId === 1 || cmapPlatformId === 1 && cmapEncodingId === 0) || cmapPlatformId === -1 && cmapEncodingId === -1 && !!(0, _encodings.getEncoding)(properties.baseEncodingName)) {
           var baseEncoding = [];
-          if (properties.baseEncodingName === 'MacRomanEncoding' || properties.baseEncodingName === 'WinAnsiEncoding') {
+
+          if (properties.baseEncodingName === "MacRomanEncoding" || properties.baseEncodingName === "WinAnsiEncoding") {
             baseEncoding = (0, _encodings.getEncoding)(properties.baseEncodingName);
           }
+
           var glyphsUnicodeMap = (0, _glyphlist.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] !== '') {
+            } else if (charCode in baseEncoding && baseEncoding[charCode] !== "") {
               glyphName = baseEncoding[charCode];
             } else {
               glyphName = _encodings.StandardEncoding[charCode];
             }
+
             if (!glyphName) {
               continue;
             }
+
             standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap);
             var unicodeOrCharCode;
+
             if (cmapPlatformId === 3 && cmapEncodingId === 1) {
               unicodeOrCharCode = glyphsUnicodeMap[standardGlyphName];
             } else if (cmapPlatformId === 1 && cmapEncodingId === 0) {
               unicodeOrCharCode = _encodings.MacRomanEncoding.indexOf(standardGlyphName);
             }
+
             var found = false;
-            for (var i = 0; i < cmapMappingsLength; ++i) {
+
+            for (let i = 0; i < cmapMappingsLength; ++i) {
               if (cmapMappings[i].charCode !== unicodeOrCharCode) {
                 continue;
               }
+
               charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
               found = true;
               break;
             }
+
             if (!found && properties.glyphNames) {
               var glyphId = properties.glyphNames.indexOf(glyphName);
+
               if (glyphId === -1 && standardGlyphName !== glyphName) {
                 glyphId = properties.glyphNames.indexOf(standardGlyphName);
               }
+
               if (glyphId > 0 && hasGlyph(glyphId)) {
                 charCodeToGlyphId[charCode] = glyphId;
               }
             }
           }
         } else if (cmapPlatformId === 0 && cmapEncodingId === 0) {
-          for (var _i = 0; _i < cmapMappingsLength; ++_i) {
-            charCodeToGlyphId[cmapMappings[_i].charCode] = cmapMappings[_i].glyphId;
+          for (let i = 0; i < cmapMappingsLength; ++i) {
+            charCodeToGlyphId[cmapMappings[i].charCode] = cmapMappings[i].glyphId;
           }
         } else {
-          for (var _i2 = 0; _i2 < cmapMappingsLength; ++_i2) {
-            charCode = cmapMappings[_i2].charCode;
-            if (cmapPlatformId === 3 && charCode >= 0xF000 && charCode <= 0xF0FF) {
-              charCode &= 0xFF;
+          for (let i = 0; i < cmapMappingsLength; ++i) {
+            charCode = cmapMappings[i].charCode;
+
+            if (cmapPlatformId === 3 && charCode >= 0xf000 && charCode <= 0xf0ff) {
+              charCode &= 0xff;
             }
-            charCodeToGlyphId[charCode] = cmapMappings[_i2].glyphId;
+
+            charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;
           }
         }
       }
+
       if (charCodeToGlyphId.length === 0) {
         charCodeToGlyphId[0] = 0;
       }
-      var glyphZeroId = numGlyphsOut - 1;
+
+      let glyphZeroId = numGlyphsOut - 1;
+
       if (!dupFirstEntry) {
         glyphZeroId = 0;
       }
+
       var newMapping = adjustMapping(charCodeToGlyphId, hasGlyph, glyphZeroId);
       this.toFontChar = newMapping.toFontChar;
-      tables['cmap'] = {
-        tag: 'cmap',
+      tables["cmap"] = {
+        tag: "cmap",
         data: createCmapTable(newMapping.charCodeToGlyphId, numGlyphsOut)
       };
-      if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'])) {
-        tables['OS/2'] = {
-          tag: 'OS/2',
+
+      if (!tables["OS/2"] || !validateOS2Table(tables["OS/2"])) {
+        tables["OS/2"] = {
+          tag: "OS/2",
           data: createOS2Table(properties, newMapping.charCodeToGlyphId, metricsOverride)
         };
       }
+
       if (!isTrueType) {
         try {
-          cffFile = new _stream.Stream(tables['CFF '].data);
+          cffFile = new _stream.Stream(tables["CFF "].data);
           var parser = new _cff_parser.CFFParser(cffFile, properties, SEAC_ANALYSIS_ENABLED);
           cff = parser.parse();
           cff.duplicateFirstGlyph();
           var compiler = new _cff_parser.CFFCompiler(cff);
-          tables['CFF '].data = compiler.compile();
+          tables["CFF "].data = compiler.compile();
         } catch (e) {
-          (0, _util.warn)('Failed to compile font ' + properties.loadedName);
+          (0, _util.warn)("Failed to compile font " + properties.loadedName);
         }
       }
-      if (!tables['name']) {
-        tables['name'] = {
-          tag: 'name',
+
+      if (!tables["name"]) {
+        tables["name"] = {
+          tag: "name",
           data: createNameTable(this.name)
         };
       } else {
-        var namePrototype = readNameTable(tables['name']);
-        tables['name'].data = createNameTable(name, namePrototype);
+        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) {
       properties.fixedPitch = false;
+
       if (properties.builtInEncoding) {
         adjustToUnicode(properties, properties.builtInEncoding);
       }
-      var glyphZeroId = 1;
+
+      let glyphZeroId = 1;
+
       if (font instanceof CFFFont) {
         glyphZeroId = font.numGlyphs - 1;
       }
+
       var mapping = font.getGlyphMapping(properties);
       var newMapping = adjustMapping(mapping, font.hasGlyphId.bind(font), glyphZeroId);
       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 || _util.FONT_IDENTITY_MATRIX;
         var charset = font.getCharset();
         var seacMap = Object.create(null);
+
         for (var glyphId in seacs) {
           glyphId |= 0;
           var seac = seacs[glyphId];
@@ -2024,116 +2537,152 @@ var Font = function FontClosure() {
           var accentGlyphName = _encodings.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) {
             continue;
           }
+
           for (var i = 0, ii = charCodes.length; i < ii; i++) {
             var charCode = charCodes[i];
             var charCodeToGlyphId = newMapping.charCodeToGlyphId;
             var baseFontCharCode = createCharCode(charCodeToGlyphId, baseGlyphId);
             var accentFontCharCode = createCharCode(charCodeToGlyphId, accentGlyphId);
             seacMap[charCode] = {
-              baseFontCharCode: baseFontCharCode,
-              accentFontCharCode: accentFontCharCode,
-              accentOffset: accentOffset
+              baseFontCharCode,
+              accentFontCharCode,
+              accentOffset
             };
           }
         }
+
         properties.seacMap = seacMap;
       }
+
       var unitsPerEm = 1 / (properties.fontMatrix || _util.FONT_IDENTITY_MATRIX)[0];
-      var builder = new OpenTypeFileBuilder('\x4F\x54\x54\x4F');
-      builder.addTable('CFF ', font.data);
-      builder.addTable('OS/2', createOS2Table(properties, newMapping.charCodeToGlyphId));
-      builder.addTable('cmap', createCmapTable(newMapping.charCodeToGlyphId, numGlyphs));
-      builder.addTable('head', '\x00\x01\x00\x00' + '\x00\x00\x10\x00' + '\x00\x00\x00\x00' + '\x5F\x0F\x3C\xF5' + '\x00\x00' + safeString16(unitsPerEm) + '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + '\x00\x00' + safeString16(properties.descent) + '\x0F\xFF' + safeString16(properties.ascent) + string16(properties.italicAngle ? 2 : 0) + '\x00\x11' + '\x00\x00' + '\x00\x00' + '\x00\x00');
-      builder.addTable('hhea', '\x00\x01\x00\x00' + safeString16(properties.ascent) + safeString16(properties.descent) + '\x00\x00' + '\xFF\xFF' + '\x00\x00' + '\x00\x00' + '\x00\x00' + safeString16(properties.capHeight) + safeString16(Math.tan(properties.italicAngle) * properties.xHeight) + '\x00\x00' + '\x00\x00' + '\x00\x00' + '\x00\x00' + '\x00\x00' + '\x00\x00' + string16(numGlyphs));
-      builder.addTable('hmtx', function fontFieldsHmtx() {
+      var builder = new OpenTypeFileBuilder("\x4F\x54\x54\x4F");
+      builder.addTable("CFF ", font.data);
+      builder.addTable("OS/2", createOS2Table(properties, newMapping.charCodeToGlyphId));
+      builder.addTable("cmap", createCmapTable(newMapping.charCodeToGlyphId, numGlyphs));
+      builder.addTable("head", "\x00\x01\x00\x00" + "\x00\x00\x10\x00" + "\x00\x00\x00\x00" + "\x5F\x0F\x3C\xF5" + "\x00\x00" + safeString16(unitsPerEm) + "\x00\x00\x00\x00\x9e\x0b\x7e\x27" + "\x00\x00\x00\x00\x9e\x0b\x7e\x27" + "\x00\x00" + safeString16(properties.descent) + "\x0F\xFF" + safeString16(properties.ascent) + string16(properties.italicAngle ? 2 : 0) + "\x00\x11" + "\x00\x00" + "\x00\x00" + "\x00\x00");
+      builder.addTable("hhea", "\x00\x01\x00\x00" + safeString16(properties.ascent) + safeString16(properties.descent) + "\x00\x00" + "\xFF\xFF" + "\x00\x00" + "\x00\x00" + "\x00\x00" + safeString16(properties.capHeight) + safeString16(Math.tan(properties.italicAngle) * properties.xHeight) + "\x00\x00" + "\x00\x00" + "\x00\x00" + "\x00\x00" + "\x00\x00" + "\x00\x00" + string16(numGlyphs));
+      builder.addTable("hmtx", function fontFieldsHmtx() {
         var charstrings = font.charstrings;
         var cffWidths = font.cff ? font.cff.widths : null;
-        var hmtx = '\x00\x00\x00\x00';
+        var hmtx = "\x00\x00\x00\x00";
+
         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;
+            width = "width" in charstring ? charstring.width : 0;
           } else if (cffWidths) {
             width = Math.ceil(cffWidths[i] || 0);
           }
+
           hmtx += string16(width) + string16(0);
         }
+
         return hmtx;
       }());
-      builder.addTable('maxp', '\x00\x00\x50\x00' + string16(numGlyphs));
-      builder.addTable('name', createNameTable(fontName));
-      builder.addTable('post', createPostTable(properties));
+      builder.addTable("maxp", "\x00\x00\x50\x00" + string16(numGlyphs));
+      builder.addTable("name", createNameTable(fontName));
+      builder.addTable("post", createPostTable(properties));
       return builder.toArray();
     },
+
     get spaceWidth() {
-      if ('_shadowWidth' in this) {
+      if ("_shadowWidth" in this) {
         return this._shadowWidth;
       }
-      var possibleSpaceReplacements = ['space', 'minus', 'one', 'i', 'I'];
+
+      var possibleSpaceReplacements = ["space", "minus", "one", "i", "I"];
       var width;
+
       for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) {
         var glyphName = possibleSpaceReplacements[i];
+
         if (glyphName in this.widths) {
           width = this.widths[glyphName];
           break;
         }
+
         var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
         var glyphUnicode = glyphsUnicodeMap[glyphName];
         var charcode = 0;
+
         if (this.composite) {
           if (this.cMap.contains(glyphUnicode)) {
             charcode = this.cMap.lookup(glyphUnicode);
           }
         }
+
         if (!charcode && this.toUnicode) {
           charcode = this.toUnicode.charCodeOf(glyphUnicode);
         }
+
         if (charcode <= 0) {
           charcode = glyphUnicode;
         }
+
         width = this.widths[charcode];
+
         if (width) {
           break;
         }
       }
+
       width = width || this.defaultWidth;
       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 = (0, _util.isNum)(width) ? width : this.defaultWidth;
       var vmetric = this.vmetrics && this.vmetrics[widthCode];
-      var unicode = this.toUnicode.get(charcode) || this.fallbackToUnicode.get(charcode) || charcode;
-      if (typeof unicode === 'number') {
+      let unicode = this.toUnicode.get(charcode) || this.fallbackToUnicode.get(charcode) || charcode;
+
+      if (typeof unicode === "number") {
         unicode = String.fromCharCode(unicode);
       }
+
       var isInFont = charcode in this.toFontChar;
       fontCharCode = this.toFontChar[charcode] || charcode;
+
       if (this.missingFile) {
+        const glyphName = this.differences[charcode] || this.defaultEncoding[charcode];
+
+        if ((glyphName === ".notdef" || glyphName === "") && this.type === "Type1") {
+          fontCharCode = 0x20;
+        }
+
         fontCharCode = (0, _unicode.mapSpecialUnicodeValues)(fontCharCode);
       }
+
       if (this.isType3Font) {
         operatorListId = fontCharCode;
       }
+
       var accent = null;
+
       if (this.seacMap && this.seacMap[charcode]) {
         isInFont = true;
         var seac = this.seacMap[charcode];
@@ -2143,32 +2692,41 @@ var Font = function FontClosure() {
           offset: seac.accentOffset
         };
       }
-      var fontChar = typeof fontCharCode === 'number' ? String.fromCodePoint(fontCharCode) : '';
+
+      var fontChar = typeof fontCharCode === "number" ? String.fromCodePoint(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 (charsCache) {
         glyphs = charsCache[chars];
+
         if (glyphs) {
           return glyphs;
         }
       }
+
       if (!charsCache) {
         charsCache = this.charsCache = Object.create(null);
       }
+
       glyphs = [];
       var charsCacheKey = chars;
       var i = 0,
           ii;
+
       if (this.cMap) {
         var c = Object.create(null);
+
         while (i < chars.length) {
           this.cMap.readCharCode(chars, i, c);
           charcode = c.charcode;
@@ -2185,35 +2743,53 @@ var Font = function FontClosure() {
           glyphs.push(glyph);
         }
       }
+
       return charsCache[charsCacheKey] = glyphs;
+    },
+
+    get glyphCacheValues() {
+      return Object.values(this.glyphCache);
     }
+
   };
   return Font;
 }();
+
+exports.Font = Font;
+
 var ErrorFont = function ErrorFontClosure() {
   function ErrorFont(error) {
     this.error = error;
-    this.loadedName = 'g_font_error';
+    this.loadedName = "g_font_error";
     this.missingFile = true;
   }
+
   ErrorFont.prototype = {
     charsToGlyphs: function ErrorFont_charsToGlyphs() {
       return [];
     },
     exportData: function ErrorFont_exportData() {
-      return { error: this.error };
+      return {
+        error: this.error
+      };
     }
   };
   return ErrorFont;
 }();
+
+exports.ErrorFont = ErrorFont;
+
 function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {
   var charCodeToGlyphId = Object.create(null);
   var glyphId, charCode, baseEncoding;
   var isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);
+
   if (properties.baseEncodingName) {
     baseEncoding = (0, _encodings.getEncoding)(properties.baseEncodingName);
+
     for (charCode = 0; charCode < baseEncoding.length; charCode++) {
       glyphId = glyphNames.indexOf(baseEncoding[charCode]);
+
       if (glyphId >= 0) {
         charCodeToGlyphId[charCode] = glyphId;
       } else {
@@ -2226,8 +2802,10 @@ function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {
     }
   } else {
     baseEncoding = _encodings.StandardEncoding;
+
     for (charCode = 0; charCode < baseEncoding.length; charCode++) {
       glyphId = glyphNames.indexOf(baseEncoding[charCode]);
+
       if (glyphId >= 0) {
         charCodeToGlyphId[charCode] = glyphId;
       } else {
@@ -2235,21 +2813,27 @@ function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {
       }
     }
   }
+
   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 = (0, _glyphlist.getGlyphsUnicode)();
         }
+
         var standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap);
+
         if (standardGlyphName !== glyphName) {
           glyphId = glyphNames.indexOf(standardGlyphName);
         }
       }
+
       if (glyphId >= 0) {
         charCodeToGlyphId[charCode] = glyphId;
       } else {
@@ -2257,8 +2841,10 @@ function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {
       }
     }
   }
+
   return charCodeToGlyphId;
 }
+
 var Type1Font = function Type1FontClosure() {
   function findBlock(streamBytes, signature, startIndex) {
     var streamBytesLength = streamBytes.length;
@@ -2267,40 +2853,51 @@ var Type1Font = function Type1FontClosure() {
     var i = startIndex,
         j,
         found = false;
+
     while (i < scanLength) {
       j = 0;
+
       while (j < signatureLength && streamBytes[i + j] === signature[j]) {
         j++;
       }
+
       if (j >= signatureLength) {
         i += j;
-        while (i < streamBytesLength && (0, _util.isSpace)(streamBytes[i])) {
+
+        while (i < streamBytesLength && (0, _core_utils.isWhiteSpace)(streamBytes[i])) {
           i++;
         }
+
         found = true;
         break;
       }
+
       i++;
     }
+
     return {
-      found: found,
+      found,
       length: i
     };
   }
+
   function getHeaderBlock(stream, suggestedLength) {
     var EEXEC_SIGNATURE = [0x65, 0x65, 0x78, 0x65, 0x63];
     var streamStartPos = stream.pos;
     var headerBytes, headerBytesLength, block;
+
     try {
       headerBytes = stream.getBytes(suggestedLength);
       headerBytesLength = headerBytes.length;
     } catch (ex) {
-      if (ex instanceof _util.MissingDataException) {
+      if (ex instanceof _core_utils.MissingDataException) {
         throw ex;
       }
     }
+
     if (headerBytesLength === suggestedLength) {
       block = findBlock(headerBytes, EEXEC_SIGNATURE, suggestedLength - 2 * EEXEC_SIGNATURE.length);
+
       if (block.found && block.length === suggestedLength) {
         return {
           stream: new _stream.Stream(headerBytes),
@@ -2308,35 +2905,44 @@ var Type1Font = function Type1FontClosure() {
         };
       }
     }
+
     (0, _util.warn)('Invalid "Length1" property in Type1 font -- trying to recover.');
     stream.pos = streamStartPos;
     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;
+
       if (block.found) {
         actualLength = stream.pos - streamStartPos;
         break;
       }
     }
+
     stream.pos = streamStartPos;
+
     if (actualLength) {
       return {
         stream: new _stream.Stream(stream.getBytes(actualLength)),
         length: actualLength
       };
     }
+
     (0, _util.warn)('Unable to recover "Length1" property in Type1 font -- using as is.');
     return {
       stream: new _stream.Stream(stream.getBytes(suggestedLength)),
       length: suggestedLength
     };
   }
+
   function getEexecBlock(stream, suggestedLength) {
     var eexecBytes = stream.getBytes();
     return {
@@ -2344,29 +2950,36 @@ var Type1Font = function Type1FontClosure() {
       length: eexecBytes.length
     };
   }
+
   function Type1Font(name, file, properties) {
     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];
     }
+
     var headerBlock = getHeaderBlock(file, headerBlockLength);
     var headerBlockParser = new _type1_parser.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];
     }
+
     var eexecBlock = getEexecBlock(file, eexecBlockLength);
     var eexecBlockParser = new _type1_parser.Type1Parser(eexecBlock.stream, true, SEAC_ANALYSIS_ENABLED);
-    var data = eexecBlockParser.extractFontProgram();
+    var data = eexecBlockParser.extractFontProgram(properties);
+
     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);
@@ -2374,68 +2987,86 @@ var Type1Font = function Type1FontClosure() {
     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 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'],
+      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);
     },
     hasGlyphId: function Type1Font_hasGlyphID(id) {
       if (id < 0 || id >= this.numGlyphs) {
         return false;
       }
+
       if (id === 0) {
         return true;
       }
+
       var glyph = this.charstrings[id - 1];
       return glyph.charstring.length > 0;
     },
     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) {
           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) {
@@ -2443,14 +3074,18 @@ var Type1Font = function Type1FontClosure() {
       } else {
         bias = 32768;
       }
+
       var type2Subrs = [];
       var i;
+
       for (i = 0; i < bias; i++) {
-        type2Subrs.push([0x0B]);
+        type2Subrs.push([0x0b]);
       }
+
       for (i = 0; i < count; i++) {
         type2Subrs.push(type1Subrs[i]);
       }
+
       return type2Subrs;
     },
     wrap: function Type1Font_wrap(name, glyphs, charstrings, subrs, properties) {
@@ -2458,64 +3093,80 @@ var Type1Font = function Type1FontClosure() {
       cff.header = new _cff_parser.CFFHeader(1, 0, 4, 4);
       cff.names = [name];
       var topDict = new _cff_parser.CFFTopDict();
-      topDict.setByName('version', 391);
-      topDict.setByName('Notice', 392);
-      topDict.setByName('FullName', 393);
-      topDict.setByName('FamilyName', 394);
-      topDict.setByName('Weight', 395);
-      topDict.setByName('Encoding', null);
-      topDict.setByName('FontMatrix', properties.fontMatrix);
-      topDict.setByName('FontBBox', properties.bbox);
-      topDict.setByName('charset', null);
-      topDict.setByName('CharStrings', null);
-      topDict.setByName('Private', null);
+      topDict.setByName("version", 391);
+      topDict.setByName("Notice", 392);
+      topDict.setByName("FullName", 393);
+      topDict.setByName("FamilyName", 394);
+      topDict.setByName("Weight", 395);
+      topDict.setByName("Encoding", null);
+      topDict.setByName("FontMatrix", properties.fontMatrix);
+      topDict.setByName("FontBBox", properties.bbox);
+      topDict.setByName("charset", null);
+      topDict.setByName("CharStrings", null);
+      topDict.setByName("Private", null);
       cff.topDict = topDict;
       var strings = new _cff_parser.CFFStrings();
-      strings.add('Version 0.11');
-      strings.add('See original notice');
+      strings.add("Version 0.11");
+      strings.add("See original notice");
       strings.add(name);
       strings.add(name);
-      strings.add('Medium');
+      strings.add("Medium");
       cff.strings = strings;
       cff.globalSubrIndex = new _cff_parser.CFFIndex();
       var count = glyphs.length;
-      var charsetArray = [0];
+      var charsetArray = [".notdef"];
       var i, ii;
+
       for (i = 0; i < count; i++) {
-        var index = _cff_parser.CFFStandardStrings.indexOf(charstrings[i].glyphName);
+        const glyphName = charstrings[i].glyphName;
+
+        const index = _cff_parser.CFFStandardStrings.indexOf(glyphName);
+
         if (index === -1) {
-          index = 0;
+          strings.add(glyphName);
         }
-        charsetArray.push(index >> 8 & 0xff, index & 0xff);
+
+        charsetArray.push(glyphName);
       }
-      cff.charset = new _cff_parser.CFFCharset(false, 0, [], charsetArray);
+
+      cff.charset = new _cff_parser.CFFCharset(false, 0, charsetArray);
       var charStringsIndex = new _cff_parser.CFFIndex();
-      charStringsIndex.add([0x8B, 0x0E]);
+      charStringsIndex.add([0x8b, 0x0e]);
+
       for (i = 0; i < count; i++) {
         charStringsIndex.add(glyphs[i]);
       }
+
       cff.charStrings = charStringsIndex;
       var privateDict = new _cff_parser.CFFPrivateDict();
-      privateDict.setByName('Subrs', null);
-      var fields = ['BlueValues', 'OtherBlues', 'FamilyBlues', 'FamilyOtherBlues', 'StemSnapH', 'StemSnapV', 'BlueShift', 'BlueFuzz', 'BlueScale', 'LanguageGroup', 'ExpansionFactor', 'ForceBold', 'StdHW', 'StdVW'];
+      privateDict.setByName("Subrs", null);
+      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 (Array.isArray(value)) {
           for (var j = value.length - 1; j > 0; j--) {
             value[j] -= value[j - 1];
           }
         }
+
         privateDict.setByName(field, value);
       }
+
       cff.topDict.privateDict = privateDict;
       var subrIndex = new _cff_parser.CFFIndex();
+
       for (i = 0, ii = subrs.length; i < ii; i++) {
         subrIndex.add(subrs[i]);
       }
+
       privateDict.subrsIndex = subrIndex;
       var compiler = new _cff_parser.CFFCompiler(cff);
       return compiler.compile();
@@ -2523,6 +3174,7 @@ var Type1Font = function Type1FontClosure() {
   };
   return Type1Font;
 }();
+
 var CFFFont = function CFFFontClosure() {
   function CFFFont(file, properties) {
     this.properties = properties;
@@ -2531,17 +3183,20 @@ var CFFFont = function CFFFontClosure() {
     this.cff.duplicateFirstGlyph();
     var compiler = new _cff_parser.CFFCompiler(this.cff);
     this.seacs = this.cff.seacs;
+
     try {
       this.data = compiler.compile();
     } catch (e) {
-      (0, _util.warn)('Failed to compile font ' + properties.loadedName);
+      (0, _util.warn)("Failed to compile font " + properties.loadedName);
       this.data = file;
     }
   }
+
   CFFFont.prototype = {
     get numGlyphs() {
       return this.cff.charStrings.count;
     },
+
     getCharset: function CFFFont_getCharset() {
       return this.cff.charset.charset;
     },
@@ -2551,21 +3206,27 @@ var CFFFont = function CFFFontClosure() {
       var charsets = cff.charset.charset;
       var charCodeToGlyphId;
       var glyphId;
+
       if (properties.composite) {
         charCodeToGlyphId = Object.create(null);
+        let charCode;
+
         if (cff.isCIDFont) {
           for (glyphId = 0; glyphId < charsets.length; glyphId++) {
             var cid = charsets[glyphId];
-            var charCode = properties.cMap.charCodeOf(cid);
+            charCode = properties.cMap.charCodeOf(cid);
             charCodeToGlyphId[charCode] = glyphId;
           }
         } else {
           for (glyphId = 0; glyphId < cff.charStrings.count; glyphId++) {
-            charCodeToGlyphId[glyphId] = glyphId;
+            charCode = properties.cMap.charCodeOf(glyphId);
+            charCodeToGlyphId[charCode] = glyphId;
           }
         }
+
         return charCodeToGlyphId;
       }
+
       var encoding = cff.encoding ? cff.encoding.encoding : null;
       charCodeToGlyphId = type1FontGlyphMapping(properties, encoding, charsets);
       return charCodeToGlyphId;
@@ -2575,11 +3236,4 @@ var CFFFont = function CFFFontClosure() {
     }
   };
   return CFFFont;
-}();
-exports.SEAC_ANALYSIS_ENABLED = SEAC_ANALYSIS_ENABLED;
-exports.ErrorFont = ErrorFont;
-exports.Font = Font;
-exports.FontFlags = FontFlags;
-exports.ToUnicodeMap = ToUnicodeMap;
-exports.IdentityToUnicodeMap = IdentityToUnicodeMap;
-exports.getFontType = getFontType;
+}();