opentype.js
Version:
OpenType font parser
334 lines (305 loc) • 14.7 kB
JavaScript
// The `GSUB` table contains ligatures, among other things.
// https://www.microsoft.com/typography/OTSPEC/gsub.htm
import check from '../check';
import { Parser } from '../parse';
import table from '../table';
const subtableParsers = new Array(9); // subtableParsers[0] is unused
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#SS
subtableParsers[1] = function parseLookup1() {
const start = this.offset + this.relativeOffset;
const substFormat = this.parseUShort();
if (substFormat === 1) {
return {
substFormat: 1,
coverage: this.parsePointer(Parser.coverage),
deltaGlyphId: this.parseUShort()
};
} else if (substFormat === 2) {
return {
substFormat: 2,
coverage: this.parsePointer(Parser.coverage),
substitute: this.parseOffset16List()
};
}
check.assert(false, '0x' + start.toString(16) + ': lookup type 1 format must be 1 or 2.');
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#MS
subtableParsers[2] = function parseLookup2() {
const substFormat = this.parseUShort();
check.argument(substFormat === 1, 'GSUB Multiple Substitution Subtable identifier-format must be 1');
return {
substFormat: substFormat,
coverage: this.parsePointer(Parser.coverage),
sequences: this.parseListOfLists()
};
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#AS
subtableParsers[3] = function parseLookup3() {
const substFormat = this.parseUShort();
check.argument(substFormat === 1, 'GSUB Alternate Substitution Subtable identifier-format must be 1');
return {
substFormat: substFormat,
coverage: this.parsePointer(Parser.coverage),
alternateSets: this.parseListOfLists()
};
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#LS
subtableParsers[4] = function parseLookup4() {
const substFormat = this.parseUShort();
check.argument(substFormat === 1, 'GSUB ligature table identifier-format must be 1');
return {
substFormat: substFormat,
coverage: this.parsePointer(Parser.coverage),
ligatureSets: this.parseListOfLists(function() {
return {
ligGlyph: this.parseUShort(),
components: this.parseUShortList(this.parseUShort() - 1)
};
})
};
};
const lookupRecordDesc = {
sequenceIndex: Parser.uShort,
lookupListIndex: Parser.uShort
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#CSF
subtableParsers[5] = function parseLookup5() {
const start = this.offset + this.relativeOffset;
const substFormat = this.parseUShort();
if (substFormat === 1) {
return {
substFormat: substFormat,
coverage: this.parsePointer(Parser.coverage),
ruleSets: this.parseListOfLists(function() {
const glyphCount = this.parseUShort();
const substCount = this.parseUShort();
return {
input: this.parseUShortList(glyphCount - 1),
lookupRecords: this.parseRecordList(substCount, lookupRecordDesc)
};
})
};
} else if (substFormat === 2) {
return {
substFormat: substFormat,
coverage: this.parsePointer(Parser.coverage),
classDef: this.parsePointer(Parser.classDef),
classSets: this.parseListOfLists(function() {
const glyphCount = this.parseUShort();
const substCount = this.parseUShort();
return {
classes: this.parseUShortList(glyphCount - 1),
lookupRecords: this.parseRecordList(substCount, lookupRecordDesc)
};
})
};
} else if (substFormat === 3) {
const glyphCount = this.parseUShort();
const substCount = this.parseUShort();
return {
substFormat: substFormat,
coverages: this.parseList(glyphCount, Parser.pointer(Parser.coverage)),
lookupRecords: this.parseRecordList(substCount, lookupRecordDesc)
};
}
check.assert(false, '0x' + start.toString(16) + ': lookup type 5 format must be 1, 2 or 3.');
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#CC
subtableParsers[6] = function parseLookup6() {
const start = this.offset + this.relativeOffset;
const substFormat = this.parseUShort();
if (substFormat === 1) {
return {
substFormat: 1,
coverage: this.parsePointer(Parser.coverage),
chainRuleSets: this.parseListOfLists(function() {
return {
backtrack: this.parseUShortList(),
input: this.parseUShortList(this.parseShort() - 1),
lookahead: this.parseUShortList(),
lookupRecords: this.parseRecordList(lookupRecordDesc)
};
})
};
} else if (substFormat === 2) {
return {
substFormat: 2,
coverage: this.parsePointer(Parser.coverage),
backtrackClassDef: this.parsePointer(Parser.classDef),
inputClassDef: this.parsePointer(Parser.classDef),
lookaheadClassDef: this.parsePointer(Parser.classDef),
chainClassSet: this.parseListOfLists(function() {
return {
backtrack: this.parseUShortList(),
input: this.parseUShortList(this.parseShort() - 1),
lookahead: this.parseUShortList(),
lookupRecords: this.parseRecordList(lookupRecordDesc)
};
})
};
} else if (substFormat === 3) {
return {
substFormat: 3,
backtrackCoverage: this.parseList(Parser.pointer(Parser.coverage)),
inputCoverage: this.parseList(Parser.pointer(Parser.coverage)),
lookaheadCoverage: this.parseList(Parser.pointer(Parser.coverage)),
lookupRecords: this.parseRecordList(lookupRecordDesc)
};
}
check.assert(false, '0x' + start.toString(16) + ': lookup type 6 format must be 1, 2 or 3.');
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#ES
subtableParsers[7] = function parseLookup7() {
// Extension Substitution subtable
const substFormat = this.parseUShort();
check.argument(substFormat === 1, 'GSUB Extension Substitution subtable identifier-format must be 1');
const extensionLookupType = this.parseUShort();
const extensionParser = new Parser(this.data, this.offset + this.parseULong());
return {
substFormat: 1,
lookupType: extensionLookupType,
extension: subtableParsers[extensionLookupType].call(extensionParser)
};
};
// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#RCCS
subtableParsers[8] = function parseLookup8() {
const substFormat = this.parseUShort();
check.argument(substFormat === 1, 'GSUB Reverse Chaining Contextual Single Substitution Subtable identifier-format must be 1');
return {
substFormat: substFormat,
coverage: this.parsePointer(Parser.coverage),
backtrackCoverage: this.parseList(Parser.pointer(Parser.coverage)),
lookaheadCoverage: this.parseList(Parser.pointer(Parser.coverage)),
substitutes: this.parseUShortList()
};
};
// https://www.microsoft.com/typography/OTSPEC/gsub.htm
function parseGsubTable(data, start) {
start = start || 0;
const p = new Parser(data, start);
const tableVersion = p.parseVersion(1);
check.argument(tableVersion === 1 || tableVersion === 1.1, 'Unsupported GSUB table version.');
if (tableVersion === 1) {
return {
version: tableVersion,
scripts: p.parseScriptList(),
features: p.parseFeatureList(),
lookups: p.parseLookupList(subtableParsers)
};
} else {
return {
version: tableVersion,
scripts: p.parseScriptList(),
features: p.parseFeatureList(),
lookups: p.parseLookupList(subtableParsers),
variations: p.parseFeatureVariationsList()
};
}
}
// GSUB Writing //////////////////////////////////////////////
const subtableMakers = new Array(9);
subtableMakers[1] = function makeLookup1(subtable) {
if (subtable.substFormat === 1) {
return new table.Table('substitutionTable', [
{name: 'substFormat', type: 'USHORT', value: 1},
{name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
{name: 'deltaGlyphID', type: 'USHORT', value: subtable.deltaGlyphId}
]);
} else {
return new table.Table('substitutionTable', [
{name: 'substFormat', type: 'USHORT', value: 2},
{name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
].concat(table.ushortList('substitute', subtable.substitute)));
}
check.fail('Lookup type 1 substFormat must be 1 or 2.');
};
subtableMakers[2] = function makeLookup2(subtable) {
check.assert(subtable.substFormat === 1, 'Lookup type 2 substFormat must be 1.');
return new table.Table('substitutionTable', [
{name: 'substFormat', type: 'USHORT', value: 1},
{name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
].concat(table.tableList('seqSet', subtable.sequences, function(sequenceSet) {
return new table.Table('sequenceSetTable', table.ushortList('sequence', sequenceSet));
})));
};
subtableMakers[3] = function makeLookup3(subtable) {
check.assert(subtable.substFormat === 1, 'Lookup type 3 substFormat must be 1.');
return new table.Table('substitutionTable', [
{name: 'substFormat', type: 'USHORT', value: 1},
{name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
].concat(table.tableList('altSet', subtable.alternateSets, function(alternateSet) {
return new table.Table('alternateSetTable', table.ushortList('alternate', alternateSet));
})));
};
subtableMakers[4] = function makeLookup4(subtable) {
check.assert(subtable.substFormat === 1, 'Lookup type 4 substFormat must be 1.');
return new table.Table('substitutionTable', [
{name: 'substFormat', type: 'USHORT', value: 1},
{name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
].concat(table.tableList('ligSet', subtable.ligatureSets, function(ligatureSet) {
return new table.Table('ligatureSetTable', table.tableList('ligature', ligatureSet, function(ligature) {
return new table.Table('ligatureTable',
[{name: 'ligGlyph', type: 'USHORT', value: ligature.ligGlyph}]
.concat(table.ushortList('component', ligature.components, ligature.components.length + 1))
);
}));
})));
};
subtableMakers[6] = function makeLookup6(subtable) {
if (subtable.substFormat === 1) {
let returnTable = new table.Table('chainContextTable', [
{name: 'substFormat', type: 'USHORT', value: subtable.substFormat},
{name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
].concat(table.tableList('chainRuleSet', subtable.chainRuleSets, function(chainRuleSet) {
return new table.Table('chainRuleSetTable', table.tableList('chainRule', chainRuleSet, function(chainRule) {
let tableData = table.ushortList('backtrackGlyph', chainRule.backtrack, chainRule.backtrack.length)
.concat(table.ushortList('inputGlyph', chainRule.input, chainRule.input.length + 1))
.concat(table.ushortList('lookaheadGlyph', chainRule.lookahead, chainRule.lookahead.length))
.concat(table.ushortList('substitution', [], chainRule.lookupRecords.length));
chainRule.lookupRecords.forEach((record, i) => {
tableData = tableData
.concat({name: 'sequenceIndex' + i, type: 'USHORT', value: record.sequenceIndex})
.concat({name: 'lookupListIndex' + i, type: 'USHORT', value: record.lookupListIndex});
});
return new table.Table('chainRuleTable', tableData);
}));
})));
return returnTable;
} else if (subtable.substFormat === 2) {
check.assert(false, 'lookup type 6 format 2 is not yet supported.');
} else if (subtable.substFormat === 3) {
let tableData = [
{name: 'substFormat', type: 'USHORT', value: subtable.substFormat},
];
tableData.push({name: 'backtrackGlyphCount', type: 'USHORT', value: subtable.backtrackCoverage.length});
subtable.backtrackCoverage.forEach((coverage, i) => {
tableData.push({name: 'backtrackCoverage' + i, type: 'TABLE', value: new table.Coverage(coverage)});
});
tableData.push({name: 'inputGlyphCount', type: 'USHORT', value: subtable.inputCoverage.length});
subtable.inputCoverage.forEach((coverage, i) => {
tableData.push({name: 'inputCoverage' + i, type: 'TABLE', value: new table.Coverage(coverage)});
});
tableData.push({name: 'lookaheadGlyphCount', type: 'USHORT', value: subtable.lookaheadCoverage.length});
subtable.lookaheadCoverage.forEach((coverage, i) => {
tableData.push({name: 'lookaheadCoverage' + i, type: 'TABLE', value: new table.Coverage(coverage)});
});
tableData.push({name: 'substitutionCount', type: 'USHORT', value: subtable.lookupRecords.length});
subtable.lookupRecords.forEach((record, i) => {
tableData = tableData
.concat({name: 'sequenceIndex' + i, type: 'USHORT', value: record.sequenceIndex})
.concat({name: 'lookupListIndex' + i, type: 'USHORT', value: record.lookupListIndex});
});
let returnTable = new table.Table('chainContextTable', tableData);
return returnTable;
}
check.assert(false, 'lookup type 6 format must be 1, 2 or 3.');
};
function makeGsubTable(gsub) {
return new table.Table('GSUB', [
{name: 'version', type: 'ULONG', value: 0x10000},
{name: 'scripts', type: 'TABLE', value: new table.ScriptList(gsub.scripts)},
{name: 'features', type: 'TABLE', value: new table.FeatureList(gsub.features)},
{name: 'lookups', type: 'TABLE', value: new table.LookupList(gsub.lookups, subtableMakers)}
]);
}
export default { parse: parseGsubTable, make: makeGsubTable };