pdfjs-dist 2.0.487 → 2.1.266

package/lib/core/cff_parser.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2018 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,21 +19,23 @@
  * @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.CFFCompiler = exports.CFFPrivateDict = exports.CFFTopDict = exports.CFFCharset = exports.CFFIndex = exports.CFFStrings = exports.CFFHeader = exports.CFF = exports.CFFParser = exports.CFFStandardStrings = undefined;
+exports.CFFFDSelect = exports.CFFCompiler = exports.CFFPrivateDict = exports.CFFTopDict = exports.CFFCharset = exports.CFFIndex = exports.CFFStrings = exports.CFFHeader = exports.CFF = exports.CFFParser = exports.CFFStandardStrings = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util");
 
-var _charsets = require('./charsets');
+var _charsets = require("./charsets");
 
-var _encodings = require('./encodings');
+var _encodings = require("./encodings");
 
 var MAX_SUBR_NESTING = 10;
 var CFFStandardStrings = ['.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', 'ampersand', 'quoteright', 'parenleft', 'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore', 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown', 'cent', 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency', 'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'endash', 'dagger', 'daggerdbl', 'periodcentered', 'paragraph', 'bullet', 'quotesinglbase', 'quotedblbase', 'quotedblright', 'guillemotright', 'ellipsis', 'perthousand', 'questiondown', 'grave', 'acute', 'circumflex', 'tilde', 'macron', 'breve', 'dotaccent', 'dieresis', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron', 'emdash', 'AE', 'ordfeminine', 'Lslash', 'Oslash', 'OE', 'ordmasculine', 'ae', 'dotlessi', 'lslash', 'oslash', 'oe', 'germandbls', 'onesuperior', 'logicalnot', 'mu', 'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn', 'onequarter', 'divide', 'brokenbar', 'degree', 'thorn', 'threequarters', 'twosuperior', 'registered', 'minus', 'eth', 'multiply', 'threesuperior', 'copyright', 'Aacute', 'Acircumflex', 'Adieresis', 'Agrave', 'Aring', 'Atilde', 'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave', 'Iacute', 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde', 'Oacute', 'Ocircumflex', 'Odieresis', 'Ograve', 'Otilde', 'Scaron', 'Uacute', 'Ucircumflex', 'Udieresis', 'Ugrave', 'Yacute', 'Ydieresis', 'Zcaron', 'aacute', 'acircumflex', 'adieresis', 'agrave', 'aring', 'atilde', 'ccedilla', 'eacute', 'ecircumflex', 'edieresis', 'egrave', 'iacute', 'icircumflex', 'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex', 'odieresis', 'ograve', 'otilde', 'scaron', 'uacute', 'ucircumflex', 'udieresis', 'ugrave', 'yacute', 'ydieresis', 'zcaron', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle', 'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior', 'parenrightsuperior', 'twodotenleader', 'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle', 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'commasuperior', 'threequartersemdash', 'periodsuperior', 'questionsmall', 'asuperior', 'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior', 'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior', 'tsuperior', 'ff', 'ffi', 'ffl', 'parenleftinferior', 'parenrightinferior', 'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall', 'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', 'Tildesmall', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall', 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall', 'Caronsmall', 'Dotaccentsmall', 'Macronsmall', 'figuredash', 'hypheninferior', 'Ogoneksmall', 'Ringsmall', 'Cedillasmall', 'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths', 'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'foursuperior', 'fivesuperior', 'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior', 'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior', 'eightinferior', 'nineinferior', 'centinferior', 'dollarinferior', 'periodinferior', 'commainferior', 'Agravesmall', 'Aacutesmall', 'Acircumflexsmall', 'Atildesmall', 'Adieresissmall', 'Aringsmall', 'AEsmall', 'Ccedillasmall', 'Egravesmall', 'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall', 'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall', 'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall', 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall', 'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall', 'Ydieresissmall', '001.000', '001.001', '001.002', '001.003', 'Black', 'Bold', 'Book', 'Light', 'Medium', 'Regular', 'Roman', 'Semibold'];
+exports.CFFStandardStrings = CFFStandardStrings;
+
 var CFFParser = function CFFParserClosure() {
   var CharstringValidationData = [null, {
     id: 'hstem',
@@ -244,11 +246,13 @@ var CFFParser = function CFFParserClosure() {
     min: 11,
     resetStack: true
   }];
+
   function CFFParser(file, properties, seacAnalysisEnabled) {
     this.bytes = file.getBytes();
     this.properties = properties;
     this.seacAnalysisEnabled = !!seacAnalysisEnabled;
   }
+
   CFFParser.prototype = {
     parse: function CFFParser_parse() {
       var properties = this.properties;
@@ -271,24 +275,31 @@ var CFFParser = function CFFParserClosure() {
       var charStringOffset = topDict.getByName('CharStrings');
       var charStringIndex = this.parseIndex(charStringOffset).obj;
       var fontMatrix = topDict.getByName('FontMatrix');
+
       if (fontMatrix) {
         properties.fontMatrix = fontMatrix;
       }
+
       var fontBBox = topDict.getByName('FontBBox');
+
       if (fontBBox) {
         properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
         properties.descent = Math.min(fontBBox[1], fontBBox[3]);
         properties.ascentScaled = true;
       }
+
       var charset, encoding;
+
       if (cff.isCIDFont) {
         var fdArrayIndex = this.parseIndex(topDict.getByName('FDArray')).obj;
+
         for (var i = 0, ii = fdArrayIndex.count; i < ii; ++i) {
           var dictRaw = fdArrayIndex.get(i);
           var fontDict = this.createDict(CFFTopDict, this.parseDict(dictRaw), cff.strings);
           this.parsePrivateDict(fontDict);
           cff.fdArray.push(fontDict);
         }
+
         encoding = null;
         charset = this.parseCharsets(topDict.getByName('charset'), charStringIndex.count, cff.strings, true);
         cff.fdSelect = this.parseFDSelect(topDict.getByName('FDSelect'), charStringIndex.count);
@@ -296,6 +307,7 @@ var CFFParser = function CFFParserClosure() {
         charset = this.parseCharsets(topDict.getByName('charset'), charStringIndex.count, cff.strings, false);
         encoding = this.parseEncoding(topDict.getByName('Encoding'), properties, cff.strings, charset.charset);
       }
+
       cff.charset = charset;
       cff.encoding = encoding;
       var charStringsAndSeacs = this.parseCharStrings({
@@ -315,17 +327,21 @@ var CFFParser = function CFFParserClosure() {
       var bytes = this.bytes;
       var bytesLength = bytes.length;
       var offset = 0;
+
       while (offset < bytesLength && bytes[offset] !== 1) {
         ++offset;
       }
+
       if (offset >= bytesLength) {
         throw new _util.FormatError('Invalid CFF header');
       }
+
       if (offset !== 0) {
         (0, _util.info)('cff data is shifted');
         bytes = bytes.subarray(offset);
         this.bytes = bytes;
       }
+
       var major = bytes[0];
       var minor = bytes[1];
       var hdrSize = bytes[2];
@@ -338,8 +354,10 @@ var CFFParser = function CFFParserClosure() {
     },
     parseDict: function CFFParser_parseDict(dict) {
       var pos = 0;
+
       function parseOperand() {
         var value = dict[pos++];
+
         if (value === 30) {
           return parseFloatOperand();
         } else if (value === 28) {
@@ -359,39 +377,51 @@ var CFFParser = function CFFParserClosure() {
         } else if (value >= 251 && value <= 254) {
           return -((value - 251) * 256) - dict[pos++] - 108;
         }
+
         (0, _util.warn)('CFFParser_parseDict: "' + value + '" is a reserved command.');
         return NaN;
       }
+
       function parseFloatOperand() {
         var str = '';
         var eof = 15;
         var lookup = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', 'E', 'E-', null, '-'];
         var length = dict.length;
+
         while (pos < length) {
           var b = dict[pos++];
           var b1 = b >> 4;
           var b2 = b & 15;
+
           if (b1 === eof) {
             break;
           }
+
           str += lookup[b1];
+
           if (b2 === eof) {
             break;
           }
+
           str += lookup[b2];
         }
+
         return parseFloat(str);
       }
+
       var operands = [];
       var entries = [];
       pos = 0;
       var end = dict.length;
+
       while (pos < end) {
         var b = dict[pos];
+
         if (b <= 21) {
           if (b === 12) {
             b = b << 8 | dict[++pos];
           }
+
           entries.push([b, operands]);
           operands = [];
           ++pos;
@@ -399,6 +429,7 @@ var CFFParser = function CFFParserClosure() {
           operands.push(parseOperand());
         }
       }
+
       return entries;
     },
     parseIndex: function CFFParser_parseIndex(pos) {
@@ -408,24 +439,31 @@ var CFFParser = function CFFParserClosure() {
       var offsets = [];
       var end = pos;
       var i, ii;
+
       if (count !== 0) {
         var offsetSize = bytes[pos++];
         var startPos = pos + (count + 1) * offsetSize - 1;
+
         for (i = 0, ii = count + 1; i < ii; ++i) {
           var offset = 0;
+
           for (var j = 0; j < offsetSize; ++j) {
             offset <<= 8;
             offset += bytes[pos++];
           }
+
           offsets.push(startPos + offset);
         }
+
         end = offsets[count];
       }
+
       for (i = 0, ii = offsets.length - 1; i < ii; ++i) {
         var offsetStart = offsets[i];
         var offsetEnd = offsets[i + 1];
         cffIndex.add(bytes.subarray(offsetStart, offsetEnd));
       }
+
       return {
         obj: cffIndex,
         endPos: end
@@ -433,42 +471,52 @@ var CFFParser = function CFFParserClosure() {
     },
     parseNameIndex: function CFFParser_parseNameIndex(index) {
       var names = [];
+
       for (var i = 0, ii = index.count; i < ii; ++i) {
         var name = index.get(i);
         names.push((0, _util.bytesToString)(name));
       }
+
       return names;
     },
     parseStringIndex: function CFFParser_parseStringIndex(index) {
       var strings = new CFFStrings();
+
       for (var i = 0, ii = index.count; i < ii; ++i) {
         var data = index.get(i);
         strings.add((0, _util.bytesToString)(data));
       }
+
       return strings;
     },
     createDict: function CFFParser_createDict(Type, dict, strings) {
       var cffDict = new Type(strings);
+
       for (var i = 0, ii = dict.length; i < ii; ++i) {
         var pair = dict[i];
         var key = pair[0];
         var value = pair[1];
         cffDict.setByKey(key, value);
       }
+
       return cffDict;
     },
     parseCharString: function CFFParser_parseCharString(state, data, localSubrIndex, globalSubrIndex) {
       if (!data || state.callDepth > MAX_SUBR_NESTING) {
         return false;
       }
+
       var stackSize = state.stackSize;
       var stack = state.stack;
       var length = data.length;
+
       for (var j = 0; j < length;) {
         var value = data[j++];
         var validationCommand = null;
+
         if (value === 12) {
           var q = data[j++];
+
           if (q === 0) {
             data[j - 2] = 139;
             data[j - 1] = 22;
@@ -483,11 +531,13 @@ var CFFParser = function CFFParserClosure() {
         } else if (value === 14) {
           if (stackSize >= 4) {
             stackSize -= 4;
+
             if (this.seacAnalysisEnabled) {
               state.seac = stack.slice(stackSize, stackSize + 4);
               return false;
             }
           }
+
           validationCommand = CharstringValidationData[value];
         } else if (value >= 32 && value <= 246) {
           stack[stackSize] = value - 139;
@@ -507,34 +557,43 @@ var CFFParser = function CFFParserClosure() {
           validationCommand = CharstringValidationData[value];
         } else if (value === 10 || value === 29) {
           var subrsIndex;
+
           if (value === 10) {
             subrsIndex = localSubrIndex;
           } else {
             subrsIndex = globalSubrIndex;
           }
+
           if (!subrsIndex) {
             validationCommand = CharstringValidationData[value];
             (0, _util.warn)('Missing subrsIndex for ' + validationCommand.id);
             return false;
           }
+
           var bias = 32768;
+
           if (subrsIndex.count < 1240) {
             bias = 107;
           } else if (subrsIndex.count < 33900) {
             bias = 1131;
           }
+
           var subrNumber = stack[--stackSize] + bias;
+
           if (subrNumber < 0 || subrNumber >= subrsIndex.count || isNaN(subrNumber)) {
             validationCommand = CharstringValidationData[value];
             (0, _util.warn)('Out of bounds subrIndex for ' + validationCommand.id);
             return false;
           }
+
           state.stackSize = stackSize;
           state.callDepth++;
           var valid = this.parseCharString(state, subrsIndex.get(subrNumber), localSubrIndex, globalSubrIndex);
+
           if (!valid) {
             return false;
           }
+
           state.callDepth--;
           stackSize = state.stackSize;
           continue;
@@ -544,32 +603,46 @@ var CFFParser = function CFFParserClosure() {
         } else {
           validationCommand = CharstringValidationData[value];
         }
+
         if (validationCommand) {
           if (validationCommand.stem) {
             state.hints += stackSize >> 1;
+
+            if (value === 3 || value === 23) {
+              state.hasVStems = true;
+            } else if (state.hasVStems && (value === 1 || value === 18)) {
+              (0, _util.warn)('CFF stem hints are in wrong order');
+              data[j - 1] = value === 1 ? 3 : 23;
+            }
           }
+
           if ('min' in validationCommand) {
             if (!state.undefStack && stackSize < validationCommand.min) {
               (0, _util.warn)('Not enough parameters for ' + validationCommand.id + '; actual: ' + stackSize + ', expected: ' + validationCommand.min);
               return false;
             }
           }
+
           if (state.firstStackClearing && validationCommand.stackClearing) {
             state.firstStackClearing = false;
             stackSize -= validationCommand.min;
+
             if (stackSize >= 2 && validationCommand.stem) {
               stackSize %= 2;
             } else if (stackSize > 1) {
               (0, _util.warn)('Found too many parameters for stack-clearing command');
             }
+
             if (stackSize > 0 && stack[stackSize - 1] >= 0) {
               state.width = stack[stackSize - 1];
             }
           }
+
           if ('stackDelta' in validationCommand) {
             if ('stackFn' in validationCommand) {
               validationCommand.stackFn(stack, stackSize);
             }
+
             stackSize += validationCommand.stackDelta;
           } else if (validationCommand.stackClearing) {
             stackSize = 0;
@@ -583,6 +656,7 @@ var CFFParser = function CFFParserClosure() {
           }
         }
       }
+
       state.stackSize = stackSize;
       return true;
     },
@@ -593,10 +667,10 @@ var CFFParser = function CFFParserClosure() {
           fdSelect = _ref.fdSelect,
           fdArray = _ref.fdArray,
           privateDict = _ref.privateDict;
-
       var seacs = [];
       var widths = [];
       var count = charStrings.count;
+
       for (var i = 0; i < count; i++) {
         var charstring = charStrings.get(i);
         var state = {
@@ -607,21 +681,26 @@ var CFFParser = function CFFParserClosure() {
           hints: 0,
           firstStackClearing: true,
           seac: null,
-          width: null
+          width: null,
+          hasVStems: false
         };
         var valid = true;
         var localSubrToUse = null;
         var privateDictToUse = privateDict;
+
         if (fdSelect && fdArray.length) {
           var fdIndex = fdSelect.getFDIndex(i);
+
           if (fdIndex === -1) {
             (0, _util.warn)('Glyph index is not in fd select.');
             valid = false;
           }
+
           if (fdIndex >= fdArray.length) {
             (0, _util.warn)('Invalid fd index for glyph index.');
             valid = false;
           }
+
           if (valid) {
             privateDictToUse = fdArray[fdIndex].privateDict;
             localSubrToUse = privateDictToUse.subrsIndex;
@@ -629,9 +708,11 @@ var CFFParser = function CFFParserClosure() {
         } else if (localSubrIndex) {
           localSubrToUse = localSubrIndex;
         }
+
         if (valid) {
           valid = this.parseCharString(state, charstring, localSubrToUse, globalSubrIndex);
         }
+
         if (state.width !== null) {
           var nominalWidth = privateDictToUse.getByName('nominalWidthX');
           widths[i] = nominalWidth + state.width;
@@ -639,20 +720,22 @@ var CFFParser = function CFFParserClosure() {
           var defaultWidth = privateDictToUse.getByName('defaultWidthX');
           widths[i] = defaultWidth;
         }
+
         if (state.seac !== null) {
           seacs[i] = state.seac;
         }
+
         if (!valid) {
           charStrings.set(i, new Uint8Array([14]));
         }
       }
+
       return {
         charStrings: charStrings,
         seacs: seacs,
         widths: widths
       };
     },
-
     emptyPrivateDictionary: function CFFParser_emptyPrivateDictionary(parentDict) {
       var privateDict = this.createDict(CFFPrivateDict, [], parentDict.strings);
       parentDict.setByKey(18, [0, 0]);
@@ -663,31 +746,40 @@ var CFFParser = function CFFParserClosure() {
         this.emptyPrivateDictionary(parentDict);
         return;
       }
+
       var privateOffset = parentDict.getByName('Private');
+
       if (!Array.isArray(privateOffset) || privateOffset.length !== 2) {
         parentDict.removeByName('Private');
         return;
       }
+
       var size = privateOffset[0];
       var offset = privateOffset[1];
+
       if (size === 0 || offset >= this.bytes.length) {
         this.emptyPrivateDictionary(parentDict);
         return;
       }
+
       var privateDictEnd = offset + size;
       var dictData = this.bytes.subarray(offset, privateDictEnd);
       var dict = this.parseDict(dictData);
       var privateDict = this.createDict(CFFPrivateDict, dict, parentDict.strings);
       parentDict.privateDict = privateDict;
+
       if (!privateDict.getByName('Subrs')) {
         return;
       }
+
       var subrsOffset = privateDict.getByName('Subrs');
       var relativeOffset = offset + subrsOffset;
+
       if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {
         this.emptyPrivateDictionary(parentDict);
         return;
       }
+
       var subrsIndex = this.parseIndex(relativeOffset);
       privateDict.subrsIndex = subrsIndex.obj;
     },
@@ -699,40 +791,51 @@ var CFFParser = function CFFParserClosure() {
       } else if (pos === 2) {
         return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT_SUBSET, _charsets.ExpertSubsetCharset);
       }
+
       var bytes = this.bytes;
       var start = pos;
       var format = bytes[pos++];
       var charset = ['.notdef'];
       var id, count, i;
       length -= 1;
+
       switch (format) {
         case 0:
           for (i = 0; i < length; i++) {
             id = bytes[pos++] << 8 | bytes[pos++];
             charset.push(cid ? id : strings.get(id));
           }
+
           break;
+
         case 1:
           while (charset.length <= length) {
             id = bytes[pos++] << 8 | bytes[pos++];
             count = bytes[pos++];
+
             for (i = 0; i <= count; i++) {
               charset.push(cid ? id++ : strings.get(id++));
             }
           }
+
           break;
+
         case 2:
           while (charset.length <= length) {
             id = bytes[pos++] << 8 | bytes[pos++];
             count = bytes[pos++] << 8 | bytes[pos++];
+
             for (i = 0; i <= count; i++) {
               charset.push(cid ? id++ : strings.get(id++));
             }
           }
+
           break;
+
         default:
           throw new _util.FormatError('Unknown charset format');
       }
+
       var end = pos;
       var raw = bytes.subarray(start, end);
       return new CFFCharset(false, format, charset, raw);
@@ -743,20 +846,25 @@ var CFFParser = function CFFParserClosure() {
       var predefined = false;
       var format, i, ii;
       var raw = null;
+
       function readSupplement() {
         var supplementsCount = bytes[pos++];
+
         for (i = 0; i < supplementsCount; i++) {
           var code = bytes[pos++];
           var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
           encoding[code] = charset.indexOf(strings.get(sid));
         }
       }
+
       if (pos === 0 || pos === 1) {
         predefined = true;
         format = pos;
         var baseEncoding = pos ? _encodings.ExpertEncoding : _encodings.StandardEncoding;
+
         for (i = 0, ii = charset.length; i < ii; i++) {
           var index = baseEncoding.indexOf(charset[i]);
+
           if (index !== -1) {
             encoding[index] = i;
           }
@@ -764,85 +872,102 @@ var CFFParser = function CFFParserClosure() {
       } else {
         var dataStart = pos;
         format = bytes[pos++];
+
         switch (format & 0x7f) {
           case 0:
             var glyphsCount = bytes[pos++];
+
             for (i = 1; i <= glyphsCount; i++) {
               encoding[bytes[pos++]] = i;
             }
+
             break;
+
           case 1:
             var rangesCount = bytes[pos++];
             var gid = 1;
+
             for (i = 0; i < rangesCount; i++) {
               var start = bytes[pos++];
               var left = bytes[pos++];
+
               for (var j = start; j <= start + left; j++) {
                 encoding[j] = gid++;
               }
             }
+
             break;
+
           default:
-            throw new _util.FormatError('Unknown encoding format: ' + format + ' in CFF');
+            throw new _util.FormatError("Unknown encoding format: ".concat(format, " in CFF"));
         }
+
         var dataEnd = pos;
+
         if (format & 0x80) {
           bytes[dataStart] &= 0x7f;
           readSupplement();
         }
+
         raw = bytes.subarray(dataStart, dataEnd);
       }
+
       format = format & 0x7f;
       return new CFFEncoding(predefined, format, encoding, raw);
     },
     parseFDSelect: function CFFParser_parseFDSelect(pos, length) {
-      var start = pos;
       var bytes = this.bytes;
       var format = bytes[pos++];
-      var fdSelect = [],
-          rawBytes;
-      var i,
-          invalidFirstGID = false;
+      var fdSelect = [];
+      var i;
+
       switch (format) {
         case 0:
           for (i = 0; i < length; ++i) {
             var id = bytes[pos++];
             fdSelect.push(id);
           }
-          rawBytes = bytes.subarray(start, pos);
+
           break;
+
         case 3:
           var rangesCount = bytes[pos++] << 8 | bytes[pos++];
+
           for (i = 0; i < rangesCount; ++i) {
             var first = bytes[pos++] << 8 | bytes[pos++];
+
             if (i === 0 && first !== 0) {
               (0, _util.warn)('parseFDSelect: The first range must have a first GID of 0' + ' -- trying to recover.');
-              invalidFirstGID = true;
               first = 0;
             }
+
             var fdIndex = bytes[pos++];
             var next = bytes[pos] << 8 | bytes[pos + 1];
+
             for (var j = first; j < next; ++j) {
               fdSelect.push(fdIndex);
             }
           }
+
           pos += 2;
-          rawBytes = bytes.subarray(start, pos);
-          if (invalidFirstGID) {
-            rawBytes[3] = rawBytes[4] = 0;
-          }
           break;
+
         default:
-          throw new _util.FormatError('parseFDSelect: Unknown format "' + format + '".');
+          throw new _util.FormatError("parseFDSelect: Unknown format \"".concat(format, "\"."));
       }
+
       if (fdSelect.length !== length) {
         throw new _util.FormatError('parseFDSelect: Invalid font data.');
       }
-      return new CFFFDSelect(fdSelect, rawBytes);
+
+      return new CFFFDSelect(format, fdSelect);
     }
   };
   return CFFParser;
 }();
+
+exports.CFFParser = CFFParser;
+
 var CFF = function CFFClosure() {
   function CFF() {
     this.header = null;
@@ -857,8 +982,35 @@ var CFF = function CFFClosure() {
     this.fdSelect = null;
     this.isCIDFont = false;
   }
+
+  CFF.prototype = {
+    duplicateFirstGlyph: function CFF_duplicateFirstGlyph() {
+      if (this.charStrings.count >= 65535) {
+        (0, _util.warn)('Not enough space in charstrings to duplicate first glyph.');
+        return;
+      }
+
+      var glyphZero = this.charStrings.get(0);
+      this.charStrings.add(glyphZero);
+
+      if (this.isCIDFont) {
+        this.fdSelect.fdSelect.push(this.fdSelect.fdSelect[0]);
+      }
+    },
+    hasGlyphId: function CFF_hasGlyphID(id) {
+      if (id < 0 || id >= this.charStrings.count) {
+        return false;
+      }
+
+      var glyph = this.charStrings.get(id);
+      return glyph.length > 0;
+    }
+  };
   return CFF;
 }();
+
+exports.CFF = CFF;
+
 var CFFHeader = function CFFHeaderClosure() {
   function CFFHeader(major, minor, hdrSize, offSize) {
     this.major = major;
@@ -866,36 +1018,49 @@ var CFFHeader = function CFFHeaderClosure() {
     this.hdrSize = hdrSize;
     this.offSize = offSize;
   }
+
   return CFFHeader;
 }();
+
+exports.CFFHeader = CFFHeader;
+
 var CFFStrings = function CFFStringsClosure() {
   function CFFStrings() {
     this.strings = [];
   }
+
   CFFStrings.prototype = {
     get: function CFFStrings_get(index) {
       if (index >= 0 && index <= 390) {
         return CFFStandardStrings[index];
       }
+
       if (index - 391 <= this.strings.length) {
         return this.strings[index - 391];
       }
+
       return CFFStandardStrings[0];
     },
     add: function CFFStrings_add(value) {
       this.strings.push(value);
     },
+
     get count() {
       return this.strings.length;
     }
+
   };
   return CFFStrings;
 }();
+
+exports.CFFStrings = CFFStrings;
+
 var CFFIndex = function CFFIndexClosure() {
   function CFFIndex() {
     this.objects = [];
     this.length = 0;
   }
+
   CFFIndex.prototype = {
     add: function CFFIndex_add(data) {
       this.length += data.length;
@@ -908,12 +1073,17 @@ var CFFIndex = function CFFIndexClosure() {
     get: function CFFIndex_get(index) {
       return this.objects[index];
     },
+
     get count() {
       return this.objects.length;
     }
+
   };
   return CFFIndex;
 }();
+
+exports.CFFIndex = CFFIndex;
+
 var CFFDict = function CFFDictClosure() {
   function CFFDict(tables, strings) {
     this.keyToNameMap = tables.keyToNameMap;
@@ -925,32 +1095,40 @@ var CFFDict = function CFFDictClosure() {
     this.strings = strings;
     this.values = Object.create(null);
   }
+
   CFFDict.prototype = {
     setByKey: function CFFDict_setByKey(key, value) {
       if (!(key in this.keyToNameMap)) {
         return false;
       }
+
       var valueLength = value.length;
+
       if (valueLength === 0) {
         return true;
       }
+
       for (var i = 0; i < valueLength; i++) {
         if (isNaN(value[i])) {
           (0, _util.warn)('Invalid CFFDict value: "' + value + '" for key "' + key + '".');
           return true;
         }
       }
+
       var type = this.types[key];
+
       if (type === 'num' || type === 'sid' || type === 'offset') {
         value = value[0];
       }
+
       this.values[key] = value;
       return true;
     },
     setByName: function CFFDict_setByName(name, value) {
       if (!(name in this.nameToKeyMap)) {
-        throw new _util.FormatError('Invalid dictionary name "' + name + '"');
+        throw new _util.FormatError("Invalid dictionary name \"".concat(name, "\""));
       }
+
       this.values[this.nameToKeyMap[name]] = value;
     },
     hasName: function CFFDict_hasName(name) {
@@ -958,18 +1136,22 @@ var CFFDict = function CFFDictClosure() {
     },
     getByName: function CFFDict_getByName(name) {
       if (!(name in this.nameToKeyMap)) {
-        throw new _util.FormatError('Invalid dictionary name ' + name + '"');
+        throw new _util.FormatError("Invalid dictionary name ".concat(name, "\""));
       }
+
       var key = this.nameToKeyMap[name];
+
       if (!(key in this.values)) {
         return this.defaults[key];
       }
+
       return this.values[key];
     },
     removeByName: function CFFDict_removeByName(name) {
       delete this.values[this.nameToKeyMap[name]];
     }
   };
+
   CFFDict.createTables = function CFFDict_createTables(layout) {
     var tables = {
       keyToNameMap: {},
@@ -979,6 +1161,7 @@ var CFFDict = function CFFDictClosure() {
       opcodes: {},
       order: []
     };
+
     for (var i = 0, ii = layout.length; i < ii; ++i) {
       var entry = layout[i];
       var key = Array.isArray(entry[0]) ? (entry[0][0] << 8) + entry[0][1] : entry[0];
@@ -989,41 +1172,56 @@ var CFFDict = function CFFDictClosure() {
       tables.opcodes[key] = Array.isArray(entry[0]) ? entry[0] : [entry[0]];
       tables.order.push(key);
     }
+
     return tables;
   };
+
   return CFFDict;
 }();
+
 var CFFTopDict = function CFFTopDictClosure() {
   var layout = [[[12, 30], 'ROS', ['sid', 'sid', 'num'], null], [[12, 20], 'SyntheticBase', 'num', null], [0, 'version', 'sid', null], [1, 'Notice', 'sid', null], [[12, 0], 'Copyright', 'sid', null], [2, 'FullName', 'sid', null], [3, 'FamilyName', 'sid', null], [4, 'Weight', 'sid', null], [[12, 1], 'isFixedPitch', 'num', 0], [[12, 2], 'ItalicAngle', 'num', 0], [[12, 3], 'UnderlinePosition', 'num', -100], [[12, 4], 'UnderlineThickness', 'num', 50], [[12, 5], 'PaintType', 'num', 0], [[12, 6], 'CharstringType', 'num', 2], [[12, 7], 'FontMatrix', ['num', 'num', 'num', 'num', 'num', 'num'], [0.001, 0, 0, 0.001, 0, 0]], [13, 'UniqueID', 'num', null], [5, 'FontBBox', ['num', 'num', 'num', 'num'], [0, 0, 0, 0]], [[12, 8], 'StrokeWidth', 'num', 0], [14, 'XUID', 'array', null], [15, 'charset', 'offset', 0], [16, 'Encoding', 'offset', 0], [17, 'CharStrings', 'offset', 0], [18, 'Private', ['offset', 'offset'], null], [[12, 21], 'PostScript', 'sid', null], [[12, 22], 'BaseFontName', 'sid', null], [[12, 23], 'BaseFontBlend', 'delta', null], [[12, 31], 'CIDFontVersion', 'num', 0], [[12, 32], 'CIDFontRevision', 'num', 0], [[12, 33], 'CIDFontType', 'num', 0], [[12, 34], 'CIDCount', 'num', 8720], [[12, 35], 'UIDBase', 'num', null], [[12, 37], 'FDSelect', 'offset', null], [[12, 36], 'FDArray', 'offset', null], [[12, 38], 'FontName', 'sid', null]];
   var tables = null;
+
   function CFFTopDict(strings) {
     if (tables === null) {
       tables = CFFDict.createTables(layout);
     }
+
     CFFDict.call(this, tables, strings);
     this.privateDict = null;
   }
+
   CFFTopDict.prototype = Object.create(CFFDict.prototype);
   return CFFTopDict;
 }();
+
+exports.CFFTopDict = CFFTopDict;
+
 var CFFPrivateDict = function CFFPrivateDictClosure() {
   var layout = [[6, 'BlueValues', 'delta', null], [7, 'OtherBlues', 'delta', null], [8, 'FamilyBlues', 'delta', null], [9, 'FamilyOtherBlues', 'delta', null], [[12, 9], 'BlueScale', 'num', 0.039625], [[12, 10], 'BlueShift', 'num', 7], [[12, 11], 'BlueFuzz', 'num', 1], [10, 'StdHW', 'num', null], [11, 'StdVW', 'num', null], [[12, 12], 'StemSnapH', 'delta', null], [[12, 13], 'StemSnapV', 'delta', null], [[12, 14], 'ForceBold', 'num', 0], [[12, 17], 'LanguageGroup', 'num', 0], [[12, 18], 'ExpansionFactor', 'num', 0.06], [[12, 19], 'initialRandomSeed', 'num', 0], [20, 'defaultWidthX', 'num', 0], [21, 'nominalWidthX', 'num', 0], [19, 'Subrs', 'offset', null]];
   var tables = null;
+
   function CFFPrivateDict(strings) {
     if (tables === null) {
       tables = CFFDict.createTables(layout);
     }
+
     CFFDict.call(this, tables, strings);
     this.subrsIndex = null;
   }
+
   CFFPrivateDict.prototype = Object.create(CFFDict.prototype);
   return CFFPrivateDict;
 }();
+
+exports.CFFPrivateDict = CFFPrivateDict;
 var CFFCharsetPredefinedTypes = {
   ISO_ADOBE: 0,
   EXPERT: 1,
   EXPERT_SUBSET: 2
 };
+
 var CFFCharset = function CFFCharsetClosure() {
   function CFFCharset(predefined, format, charset, raw) {
     this.predefined = predefined;
@@ -1031,8 +1229,12 @@ var CFFCharset = function CFFCharsetClosure() {
     this.charset = charset;
     this.raw = raw;
   }
+
   return CFFCharset;
 }();
+
+exports.CFFCharset = CFFCharset;
+
 var CFFEncoding = function CFFEncodingClosure() {
   function CFFEncoding(predefined, format, encoding, raw) {
     this.predefined = predefined;
@@ -1040,35 +1242,44 @@ var CFFEncoding = function CFFEncodingClosure() {
     this.encoding = encoding;
     this.raw = raw;
   }
+
   return CFFEncoding;
 }();
+
 var CFFFDSelect = function CFFFDSelectClosure() {
-  function CFFFDSelect(fdSelect, raw) {
+  function CFFFDSelect(format, fdSelect) {
+    this.format = format;
     this.fdSelect = fdSelect;
-    this.raw = raw;
   }
+
   CFFFDSelect.prototype = {
     getFDIndex: function CFFFDSelect_get(glyphIndex) {
       if (glyphIndex < 0 || glyphIndex >= this.fdSelect.length) {
         return -1;
       }
+
       return this.fdSelect[glyphIndex];
     }
   };
   return CFFFDSelect;
 }();
+
+exports.CFFFDSelect = CFFFDSelect;
+
 var CFFOffsetTracker = function CFFOffsetTrackerClosure() {
   function CFFOffsetTracker() {
     this.offsets = Object.create(null);
   }
+
   CFFOffsetTracker.prototype = {
     isTracking: function CFFOffsetTracker_isTracking(key) {
       return key in this.offsets;
     },
     track: function CFFOffsetTracker_track(key, location) {
       if (key in this.offsets) {
-        throw new _util.FormatError('Already tracking location of ' + key);
+        throw new _util.FormatError("Already tracking location of ".concat(key));
       }
+
       this.offsets[key] = location;
     },
     offset: function CFFOffsetTracker_offset(value) {
@@ -1078,20 +1289,24 @@ var CFFOffsetTracker = function CFFOffsetTrackerClosure() {
     },
     setEntryLocation: function CFFOffsetTracker_setEntryLocation(key, values, output) {
       if (!(key in this.offsets)) {
-        throw new _util.FormatError('Not tracking location of ' + key);
+        throw new _util.FormatError("Not tracking location of ".concat(key));
       }
+
       var data = output.data;
       var dataOffset = this.offsets[key];
       var size = 5;
+
       for (var i = 0, ii = values.length; i < ii; ++i) {
         var offset0 = i * size + dataOffset;
         var offset1 = offset0 + 1;
         var offset2 = offset0 + 2;
         var offset3 = offset0 + 3;
         var offset4 = offset0 + 4;
+
         if (data[offset0] !== 0x1d || data[offset1] !== 0 || data[offset2] !== 0 || data[offset3] !== 0 || data[offset4] !== 0) {
           throw new _util.FormatError('writing to an offset that is not empty');
         }
+
         var value = values[i];
         data[offset0] = 0x1d;
         data[offset1] = value >> 24 & 0xFF;
@@ -1103,10 +1318,12 @@ var CFFOffsetTracker = function CFFOffsetTrackerClosure() {
   };
   return CFFOffsetTracker;
 }();
+
 var CFFCompiler = function CFFCompilerClosure() {
   function CFFCompiler(cff) {
     this.cff = cff;
   }
+
   CFFCompiler.prototype = {
     compile: function CFFCompiler_compile() {
       var cff = this.cff;
@@ -1122,20 +1339,26 @@ var CFFCompiler = function CFFCompilerClosure() {
       output.add(header);
       var nameIndex = this.compileNameIndex(cff.names);
       output.add(nameIndex);
+
       if (cff.isCIDFont) {
         if (cff.topDict.hasName('FontMatrix')) {
           var base = cff.topDict.getByName('FontMatrix');
           cff.topDict.removeByName('FontMatrix');
+
           for (var i = 0, ii = cff.fdArray.length; i < ii; i++) {
             var subDict = cff.fdArray[i];
             var matrix = base.slice(0);
+
             if (subDict.hasName('FontMatrix')) {
               matrix = _util.Util.transform(matrix, subDict.getByName('FontMatrix'));
             }
+
             subDict.setByName('FontMatrix', matrix);
           }
         }
       }
+
+      cff.topDict.setByName('charset', 0);
       var compiled = this.compileTopDicts([cff.topDict], output.length, cff.isCIDFont);
       output.add(compiled.output);
       var topDictTracker = compiled.trackers[0];
@@ -1143,6 +1366,7 @@ var CFFCompiler = function CFFCompilerClosure() {
       output.add(stringIndex);
       var globalSubrIndex = this.compileIndex(cff.globalSubrIndex);
       output.add(globalSubrIndex);
+
       if (cff.encoding && cff.topDict.hasName('Encoding')) {
         if (cff.encoding.predefined) {
           topDictTracker.setEntryLocation('Encoding', [cff.encoding.format], output);
@@ -1152,21 +1376,17 @@ var CFFCompiler = function CFFCompilerClosure() {
           output.add(encoding);
         }
       }
-      if (cff.charset && cff.topDict.hasName('charset')) {
-        if (cff.charset.predefined) {
-          topDictTracker.setEntryLocation('charset', [cff.charset.format], output);
-        } else {
-          var charset = this.compileCharset(cff.charset);
-          topDictTracker.setEntryLocation('charset', [output.length], output);
-          output.add(charset);
-        }
-      }
+
+      var charset = this.compileCharset(cff.charset);
+      topDictTracker.setEntryLocation('charset', [output.length], output);
+      output.add(charset);
       var charStrings = this.compileCharStrings(cff.charStrings);
       topDictTracker.setEntryLocation('CharStrings', [output.length], output);
       output.add(charStrings);
+
       if (cff.isCIDFont) {
         topDictTracker.setEntryLocation('FDSelect', [output.length], output);
-        var fdSelect = this.compileFDSelect(cff.fdSelect.raw);
+        var fdSelect = this.compileFDSelect(cff.fdSelect);
         output.add(fdSelect);
         compiled = this.compileTopDicts(cff.fdArray, output.length, true);
         topDictTracker.setEntryLocation('FDArray', [output.length], output);
@@ -1174,6 +1394,7 @@ var CFFCompiler = function CFFCompilerClosure() {
         var fontDictTrackers = compiled.trackers;
         this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output);
       }
+
       this.compilePrivateDicts([cff.topDict], [topDictTracker], output);
       output.add([0]);
       return output.data;
@@ -1182,19 +1403,24 @@ var CFFCompiler = function CFFCompilerClosure() {
       if (parseFloat(value) === parseInt(value, 10) && !isNaN(value)) {
         return this.encodeInteger(value);
       }
+
       return this.encodeFloat(value);
     },
     encodeFloat: function CFFCompiler_encodeFloat(num) {
       var value = num.toString();
       var m = /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(value);
+
       if (m) {
         var epsilon = parseFloat('1e' + ((m[2] ? +m[2] : 0) + m[1].length));
         value = (Math.round(num * epsilon) / epsilon).toString();
       }
+
       var nibbles = '';
       var i, ii;
+
       for (i = 0, ii = value.length; i < ii; ++i) {
         var a = value[i];
+
         if (a === 'e') {
           nibbles += value[++i] === '-' ? 'c' : 'b';
         } else if (a === '.') {
@@ -1205,15 +1431,19 @@ var CFFCompiler = function CFFCompilerClosure() {
           nibbles += a;
         }
       }
+
       nibbles += nibbles.length & 1 ? 'f' : 'ff';
       var out = [30];
+
       for (i = 0, ii = nibbles.length; i < ii; i += 2) {
-        out.push(parseInt(nibbles.substr(i, 2), 16));
+        out.push(parseInt(nibbles.substring(i, i + 2), 16));
       }
+
       return out;
     },
     encodeInteger: function CFFCompiler_encodeInteger(value) {
       var code;
+
       if (value >= -107 && value <= 107) {
         code = [value + 139];
       } else if (value >= 108 && value <= 1131) {
@@ -1227,6 +1457,7 @@ var CFFCompiler = function CFFCompilerClosure() {
       } else {
         code = [0x1d, value >> 24 & 0xFF, value >> 16 & 0xFF, value >> 8 & 0xFF, value & 0xFF];
       }
+
       return code;
     },
     compileHeader: function CFFCompiler_compileHeader(header) {
@@ -1234,30 +1465,40 @@ var CFFCompiler = function CFFCompilerClosure() {
     },
     compileNameIndex: function CFFCompiler_compileNameIndex(names) {
       var nameIndex = new CFFIndex();
+
       for (var i = 0, ii = names.length; i < ii; ++i) {
         var name = names[i];
         var length = Math.min(name.length, 127);
         var sanitizedName = new Array(length);
+
         for (var j = 0; j < length; j++) {
           var char = name[j];
+
           if (char < '!' || char > '~' || char === '[' || char === ']' || char === '(' || char === ')' || char === '{' || char === '}' || char === '<' || char === '>' || char === '/' || char === '%') {
             char = '_';
           }
+
           sanitizedName[j] = char;
         }
+
         sanitizedName = sanitizedName.join('');
+
         if (sanitizedName === '') {
           sanitizedName = 'Bad_Font_Name';
         }
+
         nameIndex.add((0, _util.stringToBytes)(sanitizedName));
       }
+
       return this.compileIndex(nameIndex);
     },
     compileTopDicts: function CFFCompiler_compileTopDicts(dicts, length, removeCidKeys) {
       var fontDictTrackers = [];
       var fdArrayIndex = new CFFIndex();
+
       for (var i = 0, ii = dicts.length; i < ii; ++i) {
         var fontDict = dicts[i];
+
         if (removeCidKeys) {
           fontDict.removeByName('CIDFontVersion');
           fontDict.removeByName('CIDFontRevision');
@@ -1265,12 +1506,14 @@ var CFFCompiler = function CFFCompilerClosure() {
           fontDict.removeByName('CIDCount');
           fontDict.removeByName('UIDBase');
         }
+
         var fontDictTracker = new CFFOffsetTracker();
         var fontDictData = this.compileDict(fontDict, fontDictTracker);
         fontDictTrackers.push(fontDictTracker);
         fdArrayIndex.add(fontDictData);
         fontDictTracker.offset(length);
       }
+
       fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers);
       return {
         trackers: fontDictTrackers,
@@ -1281,18 +1524,23 @@ var CFFCompiler = function CFFCompilerClosure() {
       for (var i = 0, ii = dicts.length; i < ii; ++i) {
         var fontDict = dicts[i];
         var privateDict = fontDict.privateDict;
+
         if (!privateDict || !fontDict.hasName('Private')) {
           throw new _util.FormatError('There must be a private dictionary.');
         }
+
         var privateDictTracker = new CFFOffsetTracker();
         var privateDictData = this.compileDict(privateDict, privateDictTracker);
         var outputLength = output.length;
         privateDictTracker.offset(outputLength);
+
         if (!privateDictData.length) {
           outputLength = 0;
         }
+
         trackers[i].setEntryLocation('Private', [privateDictData.length, outputLength], output);
         output.add(privateDictData);
+
         if (privateDict.subrsIndex && privateDict.hasName('Subrs')) {
           var subrs = this.compileIndex(privateDict.subrsIndex);
           privateDictTracker.setEntryLocation('Subrs', [privateDictData.length], output);
@@ -1303,57 +1551,76 @@ var CFFCompiler = function CFFCompilerClosure() {
     compileDict: function CFFCompiler_compileDict(dict, offsetTracker) {
       var out = [];
       var order = dict.order;
+
       for (var i = 0; i < order.length; ++i) {
         var key = order[i];
+
         if (!(key in dict.values)) {
           continue;
         }
+
         var values = dict.values[key];
         var types = dict.types[key];
+
         if (!Array.isArray(types)) {
           types = [types];
         }
+
         if (!Array.isArray(values)) {
           values = [values];
         }
+
         if (values.length === 0) {
           continue;
         }
+
         for (var j = 0, jj = types.length; j < jj; ++j) {
           var type = types[j];
           var value = values[j];
+
           switch (type) {
             case 'num':
             case 'sid':
               out = out.concat(this.encodeNumber(value));
               break;
+
             case 'offset':
               var name = dict.keyToNameMap[key];
+
               if (!offsetTracker.isTracking(name)) {
                 offsetTracker.track(name, out.length);
               }
+
               out = out.concat([0x1d, 0, 0, 0, 0]);
               break;
+
             case 'array':
             case 'delta':
               out = out.concat(this.encodeNumber(value));
+
               for (var k = 1, kk = values.length; k < kk; ++k) {
                 out = out.concat(this.encodeNumber(values[k]));
               }
+
               break;
+
             default:
-              throw new _util.FormatError('Unknown data type of ' + type);
+              throw new _util.FormatError("Unknown data type of ".concat(type));
           }
         }
+
         out = out.concat(dict.opcodes[key]);
       }
+
       return out;
     },
     compileStringIndex: function CFFCompiler_compileStringIndex(strings) {
       var stringIndex = new CFFIndex();
+
       for (var i = 0, ii = strings.length; i < ii; ++i) {
         stringIndex.add((0, _util.stringToBytes)(strings[i]));
       }
+
       return this.compileIndex(stringIndex);
     },
     compileGlobalSubrIndex: function CFFCompiler_compileGlobalSubrIndex() {
@@ -1361,38 +1628,96 @@ var CFFCompiler = function CFFCompilerClosure() {
       this.out.writeByteArray(this.compileIndex(globalSubrIndex));
     },
     compileCharStrings: function CFFCompiler_compileCharStrings(charStrings) {
-      return this.compileIndex(charStrings);
+      var charStringsIndex = new CFFIndex();
+
+      for (var i = 0; i < charStrings.count; i++) {
+        var glyph = charStrings.get(i);
+
+        if (glyph.length === 0) {
+          charStringsIndex.add(new Uint8Array([0x8B, 0x0E]));
+          continue;
+        }
+
+        charStringsIndex.add(glyph);
+      }
+
+      return this.compileIndex(charStringsIndex);
     },
     compileCharset: function CFFCompiler_compileCharset(charset) {
-      return this.compileTypedArray(charset.raw);
+      var length = 1 + (this.cff.charStrings.count - 1) * 2;
+      var out = new Uint8Array(length);
+      return this.compileTypedArray(out);
     },
     compileEncoding: function CFFCompiler_compileEncoding(encoding) {
       return this.compileTypedArray(encoding.raw);
     },
     compileFDSelect: function CFFCompiler_compileFDSelect(fdSelect) {
-      return this.compileTypedArray(fdSelect);
+      var format = fdSelect.format;
+      var out, i;
+
+      switch (format) {
+        case 0:
+          out = new Uint8Array(1 + fdSelect.fdSelect.length);
+          out[0] = format;
+
+          for (i = 0; i < fdSelect.fdSelect.length; i++) {
+            out[i + 1] = fdSelect.fdSelect[i];
+          }
+
+          break;
+
+        case 3:
+          var start = 0;
+          var lastFD = fdSelect.fdSelect[0];
+          var ranges = [format, 0, 0, start >> 8 & 0xFF, start & 0xFF, lastFD];
+
+          for (i = 1; i < fdSelect.fdSelect.length; i++) {
+            var currentFD = fdSelect.fdSelect[i];
+
+            if (currentFD !== lastFD) {
+              ranges.push(i >> 8 & 0xFF, i & 0xFF, currentFD);
+              lastFD = currentFD;
+            }
+          }
+
+          var numRanges = (ranges.length - 3) / 3;
+          ranges[1] = numRanges >> 8 & 0xFF;
+          ranges[2] = numRanges & 0xFF;
+          ranges.push(i >> 8 & 0xFF, i & 0xFF);
+          out = new Uint8Array(ranges);
+          break;
+      }
+
+      return this.compileTypedArray(out);
     },
     compileTypedArray: function CFFCompiler_compileTypedArray(data) {
       var out = [];
+
       for (var i = 0, ii = data.length; i < ii; ++i) {
         out[i] = data[i];
       }
+
       return out;
     },
     compileIndex: function CFFCompiler_compileIndex(index, trackers) {
       trackers = trackers || [];
       var objects = index.objects;
       var count = objects.length;
+
       if (count === 0) {
         return [0, 0, 0];
       }
+
       var data = [count >> 8 & 0xFF, count & 0xff];
       var lastOffset = 1,
           i;
+
       for (i = 0; i < count; ++i) {
         lastOffset += objects[i].length;
       }
+
       var offsetSize;
+
       if (lastOffset < 0x100) {
         offsetSize = 1;
       } else if (lastOffset < 0x10000) {
@@ -1402,8 +1727,10 @@ var CFFCompiler = function CFFCompilerClosure() {
       } else {
         offsetSize = 4;
       }
+
       data.push(offsetSize);
       var relativeOffset = 1;
+
       for (i = 0; i < count + 1; i++) {
         if (offsetSize === 1) {
           data.push(relativeOffset & 0xFF);
@@ -1414,30 +1741,26 @@ var CFFCompiler = function CFFCompilerClosure() {
         } else {
           data.push(relativeOffset >>> 24 & 0xFF, relativeOffset >> 16 & 0xFF, relativeOffset >> 8 & 0xFF, relativeOffset & 0xFF);
         }
+
         if (objects[i]) {
           relativeOffset += objects[i].length;
         }
       }
+
       for (i = 0; i < count; i++) {
         if (trackers[i]) {
           trackers[i].offset(data.length);
         }
+
         for (var j = 0, jj = objects[i].length; j < jj; j++) {
           data.push(objects[i][j]);
         }
       }
+
       return data;
     }
   };
   return CFFCompiler;
 }();
-exports.CFFStandardStrings = CFFStandardStrings;
-exports.CFFParser = CFFParser;
-exports.CFF = CFF;
-exports.CFFHeader = CFFHeader;
-exports.CFFStrings = CFFStrings;
-exports.CFFIndex = CFFIndex;
-exports.CFFCharset = CFFCharset;
-exports.CFFTopDict = CFFTopDict;
-exports.CFFPrivateDict = CFFPrivateDict;
+
 exports.CFFCompiler = CFFCompiler;