"'\x00\x01' + // encodingID string32(4 + numTables * 8); // start of the table record var i, ii, j, jj; for (i = ranges.length - 1; i >= 0; --i) { if (ranges[i][0] <= 0xFFFF) { break; } } var bmpLength = i + 1; if (ranges[i][0] < 0xFFFF && ranges[i][1] === 0xFFFF) { ranges[i][1] = 0xFFFE; } var trailingRangesCount = ranges[i][1] < 0xFFFF ? 1 : 0; var segCount = bmpLength + trailingRangesCount; var searchParams = OpenTypeFileBuilder.getSearchParams(segCount, 2); // Fill up the 4 parallel arrays describing the segments. var startCount = ''; var endCount = ''; var idDeltas = ''; var idRangeOffsets = ''; var glyphsIds = ''; var bias = 0; var range, start, end, codes; for (i = 0, ii = bmpLength; i < ii; i++) { range = ranges[i]; start = range[0]; end = range[1]; startCount += string16(start); endCount += string16(end); codes = range[2]; var contiguous = true; for (j = 1, jj = codes.length; j < jj; ++j) { if (codes[j] !== codes[j - 1] + 1) { contiguous = false; break; } } if (!contiguous) { var offset = (segCount - i) * 2 + bias * 2; bias += (end - start + 1); idDeltas += string16(0); idRangeOffsets += string16(offset); for (j = 0, jj = codes.length; j < jj; ++j) { glyphsIds += string16(codes[j]); } } else { var startCode = codes[0]; idDeltas += string16((startCode - start) & 0xFFFF); idRangeOffsets += string16(0); } } if (trailingRangesCount > 0) { endCount += '\xFF\xFF'; startCount += '\xFF\xFF'; idDeltas += '\x00\x01'; idRangeOffsets += '\x00\x00'; } var format314 = '\x00\x00' + // language string16(2 * segCount) + string16(searchParams.range) + string16(searchParams.entry) + string16(searchParams.rangeShift) + endCount + '\x00\x00' + startCount + idDeltas + idRangeOffsets + glyphsIds; var format31012 = ''; var header31012 = ''; if (numTables > 1) { cmap += '\x00\x03' + // platformID '\x00\x0A' + // encodingID string32(4 + numTables * 8 + 4 + format314.length); // start of the table record format31012 = ''; for (i = 0, ii = ranges.length; i < ii; i++) { range = ranges[i]; start = range[0]; codes = range[2]; var code = codes[0]; for (j = 1, jj = codes.length; j < jj; ++j) { if (codes[j] !== codes[j - 1] + 1) { end = range[0] + j - 1; format31012 += string32(start) + // startCharCode string32(end) + // endCharCode string32(code); // startGlyphID start = end + 1; code = codes[j]; } } format31012 += string32(start) + // startCharCode string32(range[1]) + // endCharCode string32(code); // startGlyphID } header31012 = '\x00\x0C' + // format '\x00\x00' + // reserved string32(format31012.length + 16) + // length '\x00\x00\x00\x00' + // language string32(format31012.length / 12); // nGroups } return cmap + '\x00\x04' + // format string16(format314.length + 4) + // length format314 + header31012 + format31012; } function validateOS2Table(os2) { var stream = new Stream(os2.data); var version = stream.getUint16(); // TODO verify all OS/2 tables fields, but currently we validate only those // that give us issues stream.getBytes(60); // skipping type, misc sizes, panose, unicode ranges var selection = stream.getUint16(); if (version < 4 && (selection & 0x0300)) { return false; } var firstChar = stream.getUint16(); var lastChar = stream.getUint16(); if (firstChar > lastChar) { return false; } stream.getBytes(6); // skipping sTypoAscender/Descender/LineGap var usWinAscent = stream.getUint16(); if (usWinAscent === 0) { // makes font unreadable by windows return false; } // OS/2 appears to be valid, resetting some fields os2.data[8] = os2.data[9] = 0; // IE rejects fonts if fsType != 0 return true; } function createOS2Table(properties, charstrings, override) { override = override || { unitsPerEm: 0, yMax: 0, yMin: 0, ascent: 0, descent: 0 }; var ulUnicodeRange1 = 0; var ulUnicodeRange2 = 0; var ulUnicodeRange3 = 0; var ulUnicodeRange4 = 0; var firstCharIndex = null; var lastCharIndex = 0; if (charstrings) { for (var code in charstrings) { code |= 0; if (firstCharIndex > code || !firstCharIndex) { firstCharIndex = code; } if (lastCharIndex < code) { lastCharIndex = code; } var position = getUnicodeRangeFor(code); if (position < 32) { ulUnicodeRange1 |= 1 << position; } else if (position < 64) { ulUnicodeRange2 |= 1 << position - 32; } else if (position < 96) { ulUnicodeRange3 |= 1 << position - 64; } else if (position < 123) { ulUnicodeRange4 |= 1 << position - 96; } else { error('Unicode ranges Bits > 123 are reserved for internal usage'); } } } else { // TODO firstCharIndex = 0; lastCharIndex = 255; } var bbox = properties.bbox || [0, 0, 0, 0]; var unitsPerEm = (override.unitsPerEm || 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0]); // if the font units differ to the PDF glyph space units // then scale up the values var scale = (properties.ascentScaled ? 1.0 : unitsPerEm / PDF_GLYPH_SPACE_UNITS); var typoAscent = (override.ascent || Math.round(scale * (properties.ascent || bbox[3]))); var typoDescent = (override.descent || Math.round(scale * (properties.descent || bbox[1]))); if (typoDescent > 0 && properties.descent > 0 && bbox[1] < 0) { typoDescent = -typoDescent; // fixing incorrect descent } var winAscent = override.yMax || typoAscent; var winDescent = -override.yMin || -typoDescent; return '\x00\x03' + // version '\x02\x24' + // xAvgCharWidth '\x01\xF4' + // usWeightClass '\x00\x05' + // usWidthClass '\x00\x00' + // fstype (0 to let the font loads via font-face on IE) '\x02\x8A' + // ySubscriptXSize '\x02\xBB' + // ySubscriptYSize '\x00\x00' + // ySubscriptXOffset '\x00\x8C' + // ySubscriptYOffset '\x02\x8A' + // ySuperScriptXSize '\x02\xBB' + // ySuperScriptYSize '\x00\x00' + // ySuperScriptXOffset '\x01\xDF' + // ySuperScriptYOffset '\x00\x31' + // yStrikeOutSize '\x01\x02' + // yStrikeOutPosition '\x00\x00' + // sFamilyClass '\x00\x00\x06' + String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) + '\x00\x00\x00\x00\x00\x00' + // Panose string32(ulUnicodeRange1) + // ulUnicodeRange1 (Bits 0-31) string32(ulUnicodeRange2) + // ulUnicodeRange2 (Bits 32-63) string32(ulUnicodeRange3) + // ulUnicodeRange3 (Bits 64-95) string32(ulUnicodeRange4) + // ulUnicodeRange4 (Bits 96-127) '\x2A\x32\x31\x2A' + // achVendID string16(properties.italicAngle ? 1 : 0) + // fsSelection string16(firstCharIndex || properties.firstChar) + // usFirstCharIndex string16(lastCharIndex || properties.lastChar) + // usLastCharIndex string16(typoAscent) + // sTypoAscender string16(typoDescent) + // sTypoDescender '\x00\x64' + // sTypoLineGap (7%-10% of the unitsPerEM value) string16(winAscent) + // usWinAscent string16(winDescent) + // usWinDescent '\x00\x00\x00\x00' + // ulCodePageRange1 (Bits 0-31) '\x00\x00\x00\x00' + // ulCodePageRange2 (Bits 32-63) string16(properties.xHeight) + // sxHeight string16(properties.capHeight) + // sCapHeight string16(0) + // usDefaultChar string16(firstCharIndex || properties.firstChar) + // usBreakChar '\x00\x03'; // usMaxContext } function createPostTable(properties) { var angle = Math.floor(properties.italicAngle * (Math.pow(2, 16))); return ('\x00\x03\x00\x00' + // Version number string32(angle) + // italicAngle '\x00\x00' + // underlinePosition '\x00\x00' + // underlineThickness string32(properties.fixedPitch) + // isFixedPitch '\x00\x00\x00\x00' + // minMemType42 '\x00\x00\x00\x00' + // maxMemType42 '\x00\x00\x00\x00' + // minMemType1 '\x00\x00\x00\x00'); // maxMemType1 } function createNameTable(name, proto) { if (!proto) { proto = [[], []]; // no strings and unicode strings } var strings = [ proto[0][0] || 'Original licence', // 0.Copyright proto[0][1] || name, // 1.Font family proto[0][2] || 'Unknown', // 2.Font subfamily (font weight) proto[0][3] || 'uniqueID', // 3.Unique ID proto[0][4] || name, // 4.Full font name proto[0][5] || 'Version 0.11', // 5.Version proto[0][6] || '', // 6.Postscript name proto[0][7] || 'Unknown', // 7.Trademark proto[0][8] || 'Unknown', // 8.Manufacturer proto[0][9] || 'Unknown' // 9.Designer ]; // Mac want 1-byte per character strings while Windows want // 2-bytes per character, so duplicate the names table var stringsUnicode = []; var i, ii, j, jj, str; for (i = 0, ii = strings.length; i < ii; i++) { str = proto[1][i] || strings[i]; var strBufUnicode = []; for (j = 0, jj = str.length; j < jj; j++) { strBufUnicode.push(string16(str.charCodeAt(j))); } stringsUnicode.push(strBufUnicode.join('')); } var names = [strings, stringsUnicode]; var platforms = ['\x00\x01', '\x00\x03']; var encodings = ['\x00\x00', '\x00\x01']; var languages = ['\x00\x00', '\x04\x09']; var namesRecordCount = strings.length * platforms.length; var nameTable = '\x00\x00' + // format string16(namesRecordCount) + // Number of names Record string16(namesRecordCount * 12 + 6); // Storage // Build the name records field var strOffset = 0; for (i = 0, ii = platforms.length; i < ii; i++) { var strs = names[i]; for (j = 0, jj = strs.length; j < jj; j++) { str = strs[j]; var nameRecord = platforms[i] + // platform ID encodings[i] + // encoding ID languages[i] + // language ID string16(j) + // name ID string16(str.length) + string16(strOffset); nameTable += nameRecord; strOffset += str.length; } } nameTable += strings.join('') + stringsUnicode.join(''); return nameTable; } Font.prototype = { name: null, font: null, mimetype: null, encoding: null, get renderer() { var renderer = FontRendererFactory.create(this, SEAC_ANALYSIS_ENABLED); return shadow(this, 'renderer', renderer); }, exportData: function Font_exportData() { // TODO remove enumerating of the properties, e.g. hardcode exact names. var data = {}; for (var i in this) { if (this.hasOwnProperty(i)) { data[i] = this[i]; } } return data; }, checkAndRepair: function Font_checkAndRepair(name, font, properties) { function readTableEntry(file) { var tag = bytesToString(file.getBytes(4)); var checksum = file.getInt32() >>> 0; var offset = file.getInt32() >>> 0; var length = file.getInt32() >>> 0; // Read the table associated data var previousPosition = file.pos; file.pos = file.start ? file.start : 0; file.skip(offset); var data = file.getBytes(length); file.pos = previousPosition; if (tag === 'head') { // clearing checksum adjustment data[8] = data[9] = data[10] = data[11] = 0; data[17] |= 0x20; //Set font optimized for cleartype flag } return { tag: tag, checksum: checksum, length: length, offset: offset, data: data }; } function readOpenTypeHeader(ttf) { return { version: bytesToString(ttf.getBytes(4)), numTables: ttf.getUint16(), searchRange: ttf.getUint16(), entrySelector: ttf.getUint16(), rangeShift: ttf.getUint16() }; } /** * Read the appropriate subtable from the cmap according to 9.6.6.4 from * PDF spec */ function readCmapTable(cmap, font, isSymbolicFont, hasEncoding) { if (!cmap) { warn('No cmap table available.'); return { platformId: -1, encodingId: -1, mappings: [], hasShortCmap: false }; } var segment; var start = (font.start ? font.start : 0) + cmap.offset; font.pos = start; var version = font.getUint16(); var numTables = font.getUint16(); var potentialTable; var canBreak = false; // There's an order of preference in terms of which cmap subtable to // use: // - non-symbolic fonts the preference is a 3,1 table then a 1,0 table // - symbolic fonts the preference is a 3,0 table then a 1,0 table // The following takes advantage of the fact that the tables are sorted // to work. for (var i = 0; i < numTables; i++) { var platformId = font.getUint16(); var encodingId = font.getUint16(); var offset = font.getInt32() >>> 0; var useTable = false; if (platformId === 0 && encodingId === 0) { useTable = true; // Continue the loop since there still may be a higher priority // table. } else if (platformId === 1 && encodingId === 0) { useTable = true; // Continue the loop since there still may be a higher priority // table. } else if (platformId === 3 && encodingId === 1 && ((!isSymbolicFont && hasEncoding) || !potentialTable)) { useTable = true; if (!isSymbolicFont) { canBreak = true; } } else if (isSymbolicFont && platformId === 3 && encodingId === 0) { useTable = true; canBreak = true; } if (useTable) { potentialTable = { platformId: platformId, encodingId: encodingId, offset: offset }; } if (canBreak) { break; } } if (potentialTable) { font.pos = start + potentialTable.offset; } if (!potentialTable || font.peekByte() === -1) { warn('Could not find a preferred cmap table.'); return { platformId: -1, encodingId: -1, mappings: [], hasShortCmap: false }; } var format = font.getUint16(); var length = font.getUint16(); var language = font.getUint16(); var hasShortCmap = false; var mappings = []; var j, glyphId; // TODO(mack): refactor this cmap subtable reading logic out if (format === 0) { for (j = 0; j < 256; j++) { var index = font.getByte(); if (!index) { continue; }" "| toUnicode.length === 0x10000); // Helper function to try to skip mapping of empty glyphs. // Note: In some cases, just relying on the glyph data doesn't work, // hence we also use a few heuristics to fix various PDF files. function hasGlyph(glyphId, charCode, widthCode) { if (!missingGlyphs[glyphId]) { return true; } if (!skipToUnicode && charCode >= 0 && toUnicode.has(charCode)) { return true; } if (widths && widthCode >= 0 && isNum(widths[widthCode])) { return true; } return false; } // Some bad PDF generators, e.g. Scribus PDF, include glyph names // in a 'uniXXXX' format -- attempting to recover proper ones. function recoverGlyphName(name, glyphsUnicodeMap) { if (glyphsUnicodeMap[name] !== undefined) { return name; } // The glyph name is non-standard, trying to recover. var unicode = getUnicodeForGlyph(name, glyphsUnicodeMap); if (unicode !== -1) { for (var key in glyphsUnicodeMap) { if (glyphsUnicodeMap[key] === unicode) { return key; } } } warn('Unable to recover a standard glyph name for: ' + name); return name; } if (properties.type === 'CIDFontType2') { var cidToGidMap = properties.cidToGidMap || []; var isCidToGidMapEmpty = cidToGidMap.length === 0; properties.cMap.forEach(function(charCode, cid) { assert(cid <= 0xffff, 'Max size of CID is 65,535'); var glyphId = -1; if (isCidToGidMapEmpty) { glyphId = cid; } else if (cidToGidMap[cid] !== undefined) { glyphId = cidToGidMap[cid]; } if (glyphId >= 0 && glyphId < numGlyphs && hasGlyph(glyphId, charCode, cid)) { charCodeToGlyphId[charCode] = glyphId; } }); if (dupFirstEntry) { charCodeToGlyphId[0] = numGlyphs - 1; } } else { // Most of the following logic in this code branch is based on the // 9.6.6.4 of the PDF spec. var hasEncoding = properties.differences.length > 0 || !!properties.baseEncodingName; var cmapTable = readCmapTable(tables['cmap'], font, this.isSymbolicFont, hasEncoding); var cmapPlatformId = cmapTable.platformId; var cmapEncodingId = cmapTable.encodingId; var cmapMappings = cmapTable.mappings; var cmapMappingsLength = cmapMappings.length; // The spec seems to imply that if the font is symbolic the encoding // should be ignored, this doesn't appear to work for 'preistabelle.pdf' // where the the font is symbolic and it has an encoding. if (hasEncoding && (cmapPlatformId === 3 && cmapEncodingId === 1 || cmapPlatformId === 1 && cmapEncodingId === 0) || (cmapPlatformId === -1 && cmapEncodingId === -1 && // Temporary hack !!getEncoding(properties.baseEncodingName))) { // Temporary hack // When no preferred cmap table was found and |baseEncodingName| is // one of the predefined encodings, we seem to obtain a better // |charCodeToGlyphId| map from the code below (fixes bug 1057544). // TODO: Note that this is a hack which should be removed as soon as // we have proper support for more exotic cmap tables. var baseEncoding = []; if (properties.baseEncodingName === 'MacRomanEncoding' || properties.baseEncodingName === 'WinAnsiEncoding') { baseEncoding = getEncoding(properties.baseEncodingName); } var glyphsUnicodeMap = getGlyphsUnicode(); for (charCode = 0; charCode < 256; charCode++) { var glyphName, standardGlyphName; if (this.differences && charCode in this.differences) { glyphName = this.differences[charCode]; } else if (charCode in baseEncoding && baseEncoding[charCode] !== '') { glyphName = baseEncoding[charCode]; } else { glyphName = StandardEncoding[charCode]; } if (!glyphName) { continue; } // Ensure that non-standard glyph names are resolved to valid ones. standardGlyphName = recoverGlyphName(glyphName, glyphsUnicodeMap); var unicodeOrCharCode, isUnicode = false; if (cmapPlatformId === 3 && cmapEncodingId === 1) { unicodeOrCharCode = glyphsUnicodeMap[standardGlyphName]; isUnicode = true; } else if (cmapPlatformId === 1 && cmapEncodingId === 0) { // TODO: the encoding needs to be updated with mac os table. unicodeOrCharCode = MacRomanEncoding.indexOf(standardGlyphName); } var found = false; for (i = 0; i < cmapMappingsLength; ++i) { if (cmapMappings[i].charCode !== unicodeOrCharCode) { continue; } var code = isUnicode ? charCode : unicodeOrCharCode; if (hasGlyph(cmapMappings[i].glyphId, code, -1)) { charCodeToGlyphId[charCode] = cmapMappings[i].glyphId; found = true; break; } } if (!found && properties.glyphNames) { // Try to map using the post table. var glyphId = properties.glyphNames.indexOf(glyphName); // The post table ought to use the same kind of glyph names as the // `differences` array, but check the standard ones as a fallback. if (glyphId === -1 && standardGlyphName !== glyphName) { glyphId = properties.glyphNames.indexOf(standardGlyphName); } if (glyphId > 0 && hasGlyph(glyphId, -1, -1)) { charCodeToGlyphId[charCode] = glyphId; found = true; } } if (!found) { charCodeToGlyphId[charCode] = 0; // notdef } } } else if (cmapPlatformId === 0 && cmapEncodingId === 0) { // Default Unicode semantics, use the charcodes as is. for (i = 0; i < cmapMappingsLength; ++i) { charCodeToGlyphId[cmapMappings[i].charCode] = cmapMappings[i].glyphId; } } else { // For (3, 0) cmap tables: // The charcode key being stored in charCodeToGlyphId is the lower // byte of the two-byte charcodes of the cmap table since according to // the spec: 'each byte from the string shall be prepended with the // high byte of the range [of charcodes in the cmap table], to form // a two-byte character, which shall be used to select the // associated glyph description from the subtable'. // // For (1, 0) cmap tables: // 'single bytes from the string shall be used to look up the // associated glyph descriptions from the subtable'. This means // charcodes in the cmap will be single bytes, so no-op since // glyph.charCode & 0xFF === glyph.charCode for (i = 0; i < cmapMappingsLength; ++i) { charCode = cmapMappings[i].charCode & 0xFF; charCodeToGlyphId[charCode] = cmapMappings[i].glyphId; } } } if (charCodeToGlyphId.length === 0) { // defines at least one glyph charCodeToGlyphId[0] = 0; } // Converting glyphs and ids into font's cmap table var newMapping = adjustMapping(charCodeToGlyphId, properties); this.toFontChar = newMapping.toFontChar; tables['cmap'] = { tag: 'cmap', data: createCmapTable(newMapping.charCodeToGlyphId, numGlyphs) }; if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'])) { tables['OS/2'] = { tag: 'OS/2', data: createOS2Table(properties, newMapping.charCodeToGlyphId, metricsOverride) }; } // Rewrite the 'post' table if needed if (!tables['post']) { tables['post'] = { tag: 'post', data: createPostTable(properties) }; } if (!isTrueType) { try { // Trying to repair CFF file cffFile = new Stream(tables['CFF '].data); var parser = new CFFParser(cffFile, properties, SEAC_ANALYSIS_ENABLED); cff = parser.parse(); var compiler = new CFFCompiler(cff); tables['CFF '].data = compiler.compile(); } catch (e) { warn('Failed to compile font ' + properties.loadedName); } } // Re-creating 'name' table if (!tables['name']) { tables['name'] = { tag: 'name', data: createNameTable(this.name) }; } else { // ... using existing 'name' table as prototype var namePrototype = readNameTable(tables['name']); tables['name'].data = createNameTable(name, namePrototype); } var builder = new OpenTypeFileBuilder(header.version); for (var tableTag in tables) { builder.addTable(tableTag, tables[tableTag].data); } return builder.toArray(); }, convert: function Font_convert(fontName, font, properties) { // TODO: Check the charstring widths to determine this. properties.fixedPitch = false; var mapping = font.getGlyphMapping(properties); var newMapping = adjustMapping(mapping, properties); this.toFontChar = newMapping.toFontChar; var numGlyphs = font.numGlyphs; function getCharCodes(charCodeToGlyphId, glyphId) { var charCodes = null; for (var charCode in charCodeToGlyphId) { if (glyphId === charCodeToGlyphId[charCode]) { if (!charCodes) { charCodes = []; } charCodes.push(charCode | 0); } } return charCodes; } function createCharCode(charCodeToGlyphId, glyphId) { for (var charCode in charCodeToGlyphId) { if (glyphId === charCodeToGlyphId[charCode]) { return charCode | 0; } } newMapping.charCodeToGlyphId[newMapping.nextAvailableFontCharCode] = glyphId; return newMapping.nextAvailableFontCharCode++; } var seacs = font.seacs; if (SEAC_ANALYSIS_ENABLED && seacs && seacs.length) { var matrix = properties.fontMatrix || FONT_IDENTITY_MATRIX; var charset = font.getCharset(); var seacMap = Object.create(null); for (var glyphId in seacs) { glyphId |= 0; var seac = seacs[glyphId]; var baseGlyphName = StandardEncoding[seac[2]]; var accentGlyphName = StandardEncoding[seac[3]]; var baseGlyphId = charset.indexOf(baseGlyphName); var accentGlyphId = charset.indexOf(accentGlyphName); if (baseGlyphId < 0 || accentGlyphId < 0) { continue; } var accentOffset = { x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4], y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5] }; var charCodes = getCharCodes(mapping, glyphId); if (!charCodes) { // There's no point in mapping it if the char code was never mapped // to begin with. continue; } for (var i = 0, ii = charCodes.length; i < ii; i++) { var charCode = charCodes[i]; // Find a fontCharCode that maps to the base and accent glyphs. // If one doesn't exists, create it. var charCodeToGlyphId = newMapping.charCodeToGlyphId; var baseFontCharCode = createCharCode(charCodeToGlyphId, baseGlyphId); var accentFontCharCode = createCharCode(charCodeToGlyphId, accentGlyphId); seacMap[charCode] = { baseFontCharCode: baseFontCharCode, accentFontCharCode: accentFontCharCode, accentOffset: accentOffset }; } } properties.seacMap = seacMap; } var unitsPerEm = 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0]; var builder = new OpenTypeFileBuilder('\x4F\x54\x54\x4F'); // PostScript Font Program builder.addTable('CFF ', font.data); // OS/2 and Windows Specific metrics builder.addTable('OS/2', createOS2Table(properties, newMapping.charCodeToGlyphId)); // Character to glyphs mapping builder.addTable('cmap', createCmapTable(newMapping.charCodeToGlyphId, numGlyphs)); // Font header builder.addTable('head', '\x00\x01\x00\x00' + // Version number '\x00\x00\x10\x00' + // fontRevision '\x00\x00\x00\x00' + // checksumAdjustement '\x5F\x0F\x3C\xF5' + // magicNumber '\x00\x00' + // Flags safeString16(unitsPerEm) + // unitsPerEM '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // creation date '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // modifification date '\x00\x00' + // xMin safeString16(properties.descent) + // yMin '\x0F\xFF' + // xMax safeString16(properties.ascent) + // yMax string16(properties.italicAngle ? 2 : 0) + // macStyle '\x00\x11' + // lowestRecPPEM '\x00\x00' + // fontDirectionHint '\x00\x00' + // indexToLocFormat '\x00\x00'); // glyphDataFormat // Horizontal header builder.addTable('hhea', '\x00\x01\x00\x00' + // Version number safeString16(properties.ascent) + // Typographic Ascent safeString16(properties.descent) + // Typographic Descent '\x00\x00' + // Line Gap '\xFF\xFF' + // advanceWidthMax '\x00\x00' + // minLeftSidebearing '\x00\x00' + // minRightSidebearing '\x00\x00' + // xMaxExtent safeString16(properties.capHeight) + // caretSlopeRise safeString16(Math.tan(properties.italicAngle) * properties.xHeight) + // caretSlopeRun '\x00\x00' + // caretOffset '\x00\x00' + // -reserved- '\x00\x00' + // -reserved- '\x00\x00' + // -reserved- '\x00\x00' + // -reserved- '\x00\x00' + // metricDataFormat string16(numGlyphs)); // Number of HMetrics // Horizontal metrics builder.addTable('hmtx', (function fontFieldsHmtx() { var charstrings = font.charstrings; var cffWidths = font.cff ? font.cff.widths : null; var hmtx = '\x00\x00\x00\x00'; // Fake .notdef for (var i = 1, ii = numGlyphs; i < ii; i++) { var width = 0; if (charstrings) { var charstring = charstrings[i - 1]; width = 'width' in charstring ? charstring.width : 0; } else if (cffWidths) { width = Math.ceil(cffWidths[i] || 0); } hmtx += string16(width) + string16(0); } return hmtx; })()); // Maximum profile builder.addTable('maxp', '\x00\x00\x50\x00' + // Version number string16(numGlyphs)); // Num of glyphs // Naming tables builder.addTable('name', createNameTable(fontName)); // PostScript informations builder.addTable('post', createPostTable(properties)); return builder.toArray(); }, get spaceWidth() { if ('_shadowWidth' in this) { return this._shadowWidth; } // trying to estimate space character width var possibleSpaceReplacements = ['space', 'minus', 'one', 'i']; var width; for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) { var glyphName = possibl"