static open(filename) {

return new AFMFont(fs.readFileSync(filename, 'utf8'));

}

constructor(contents) {

this.contents = contents;

this.attributes = {};

this.glyphWidths = {};

this.boundingBoxes = {};

this.kernPairs = {};

this.parse();

// todo: remove charWidths since appears to not be used

this.charWidths = new Array(256);

for (let char = 0; char <= 255; char++) {

this.charWidths[char] = this.glyphWidths[characters[char]];

}

this.bbox = this.attributes['FontBBox'].split(/\s+/).map((e) => +e);

this.ascender = +(this.attributes['Ascender'] || 0);

this.descender = +(this.attributes['Descender'] || 0);

this.xHeight = +(this.attributes['XHeight'] || 0);

this.capHeight = +(this.attributes['CapHeight'] || 0);

this.lineGap =

this.bbox[3] - this.bbox[1] - (this.ascender - this.descender);

}

parse() {

let section = '';

for (let line of this.contents.split('\n')) {

var match;

var a;

if ((match = line.match(/^Start(\w+)/))) {

section = match[1];

continue;

} else if ((match = line.match(/^End(\w+)/))) {

section = '';

continue;

}

switch (section) {

case 'FontMetrics':

match = line.match(/(^\w+)\s+(.*)/);

var key = match[1];

var value = match[2];

if ((a = this.attributes[key])) {

if (!Array.isArray(a)) {

a = this.attributes[key] = [a];

}

a.push(value);

} else {

this.attributes[key] = value;

}

break;

case 'CharMetrics':

if (!/^CH?\s/.test(line)) {

continue;

}

var name = line.match(/\bN\s+(\.?\w+)\s*;/)[1];

this.glyphWidths[name] = +line.match(/\bWX\s+(\d+)\s*;/)[1];

break;

case 'KernPairs':

match = line.match(/^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/);

if (match) {

this.kernPairs[match[1] + '\0' + match[2]] = parseInt(match[3]);

}

break;

}

}

}

encodeText(text) {

const res = [];

for (let i = 0, len = text.length; i < len; i++) {

let char = text.charCodeAt(i);

char = WIN_ANSI_MAP[char] || char;

res.push(char.toString(16));

}

return res;

}

glyphsForString(string) {

const glyphs = [];

for (let i = 0, len = string.length; i < len; i++) {

const charCode = string.charCodeAt(i);

glyphs.push(this.characterToGlyph(charCode));

}

return glyphs;

}

characterToGlyph(character) {

return characters[WIN_ANSI_MAP[character] || character] || '.notdef';

}

widthOfGlyph(glyph) {

return this.glyphWidths[glyph] || 0;

}

getKernPair(left, right) {

return this.kernPairs[left + '\0' + right] || 0;

}

advancesForGlyphs(glyphs) {

const advances = [];

for (let index = 0; index < glyphs.length; index++) {

const left = glyphs[index];

const right = glyphs[index + 1];

advances.push(this.widthOfGlyph(left) + this.getKernPair(left, right));

}

return advances;

}