@cantoo/fontkit 2.0.4

package/src/aat/AATMorxProcessor.js

@@ -0,0 +1,429 @@
+import AATStateMachine from './AATStateMachine';
+import AATLookupTable from './AATLookupTable';
+import {cache} from '../decorators';
+
+// indic replacement flags
+const MARK_FIRST = 0x8000;
+const MARK_LAST  = 0x2000;
+const VERB       = 0x000F;
+
+// contextual substitution and glyph insertion flag
+const SET_MARK = 0x8000;
+
+// ligature entry flags
+const SET_COMPONENT  = 0x8000;
+const PERFORM_ACTION = 0x2000;
+
+// ligature action masks
+const LAST_MASK   = 0x80000000;
+const STORE_MASK  = 0x40000000;
+const OFFSET_MASK = 0x3FFFFFFF;
+
+const _VERTICAL_ONLY           = 0x800000;
+const REVERSE_DIRECTION        = 0x400000;
+const _HORIZONTAL_AND_VERTICAL = 0x200000;
+
+// glyph insertion flags
+const _CURRENT_IS_KASHIDA_LIKE = 0x2000;
+const _MARKED_IS_KASHIDA_LIKE  = 0x1000;
+const CURRENT_INSERT_BEFORE   = 0x0800;
+const MARKED_INSERT_BEFORE    = 0x0400;
+const CURRENT_INSERT_COUNT    = 0x03E0;
+const MARKED_INSERT_COUNT     = 0x001F;
+
+export default class AATMorxProcessor {
+  constructor(font) {
+    this.processIndicRearragement = this.processIndicRearragement.bind(this);
+    this.processContextualSubstitution = this.processContextualSubstitution.bind(this);
+    this.processLigature = this.processLigature.bind(this);
+    this.processNoncontextualSubstitutions = this.processNoncontextualSubstitutions.bind(this);
+    this.processGlyphInsertion = this.processGlyphInsertion.bind(this);
+    this.font = font;
+    this.morx = font.morx;
+    this.inputCache = null;
+  }
+
+  // Processes an array of glyphs and applies the specified features
+  // Features should be in the form of {featureType:{featureSetting:boolean}}
+  process(glyphs, features = {}) {
+    for (let chain of this.morx.chains) {
+      let flags = chain.defaultFlags;
+
+      // enable/disable the requested features
+      for (let feature of chain.features) {
+        let f;
+        if ((f = features[feature.featureType])) {
+          if (f[feature.featureSetting]) {
+            flags &= feature.disableFlags;
+            flags |= feature.enableFlags;
+          } else if (f[feature.featureSetting] === false) {
+            flags |= ~feature.disableFlags;
+            flags &= ~feature.enableFlags;
+          }
+        }
+      }
+
+      for (let subtable of chain.subtables) {
+        if (subtable.subFeatureFlags & flags) {
+          this.processSubtable(subtable, glyphs);
+        }
+      }
+    }
+
+    // remove deleted glyphs
+    let index = glyphs.length - 1;
+    while (index >= 0) {
+      if (glyphs[index].id === 0xffff) {
+        glyphs.splice(index, 1);
+      }
+
+      index--;
+    }
+
+    return glyphs;
+  }
+
+  processSubtable(subtable, glyphs) {
+    this.subtable = subtable;
+    this.glyphs = glyphs;
+    if (this.subtable.type === 4) {
+      this.processNoncontextualSubstitutions(this.subtable, this.glyphs);
+      return;
+    }
+
+    this.ligatureStack = [];
+    this.markedGlyph = null;
+    this.firstGlyph = null;
+    this.lastGlyph = null;
+    this.markedIndex = null;
+
+    let stateMachine = this.getStateMachine(subtable);
+    let process = this.getProcessor();
+
+    let reverse = !!(this.subtable.coverage & REVERSE_DIRECTION);
+    return stateMachine.process(this.glyphs, reverse, process);
+  }
+
+  @cache
+  getStateMachine(subtable) {
+    return new AATStateMachine(subtable.table.stateTable);
+  }
+
+  getProcessor() {
+    switch (this.subtable.type) {
+      case 0:
+        return this.processIndicRearragement;
+      case 1:
+        return this.processContextualSubstitution;
+      case 2:
+        return this.processLigature;
+      case 4:
+        return this.processNoncontextualSubstitutions;
+      case 5:
+        return this.processGlyphInsertion;
+      default:
+        throw new Error(`Invalid morx subtable type: ${this.subtable.type}`);
+    }
+  }
+
+  processIndicRearragement(glyph, entry, index) {
+    if (entry.flags & MARK_FIRST) {
+      this.firstGlyph = index;
+    }
+
+    if (entry.flags & MARK_LAST) {
+      this.lastGlyph = index;
+    }
+
+    reorderGlyphs(this.glyphs, entry.flags & VERB, this.firstGlyph, this.lastGlyph);
+  }
+
+  processContextualSubstitution(glyph, entry, index) {
+    let subsitutions = this.subtable.table.substitutionTable.items;
+    if (entry.markIndex !== 0xffff) {
+      let lookup = subsitutions.getItem(entry.markIndex);
+      let lookupTable = new AATLookupTable(lookup);
+      glyph = this.glyphs[this.markedGlyph];
+      let gid = lookupTable.lookup(glyph.id);
+      if (gid) {
+        this.glyphs[this.markedGlyph] = this.font.getGlyph(gid, glyph.codePoints);
+      }
+    }
+
+    if (entry.currentIndex !== 0xffff) {
+      let lookup = subsitutions.getItem(entry.currentIndex);
+      let lookupTable = new AATLookupTable(lookup);
+      glyph = this.glyphs[index];
+      let gid = lookupTable.lookup(glyph.id);
+      if (gid) {
+        this.glyphs[index] = this.font.getGlyph(gid, glyph.codePoints);
+      }
+    }
+
+    if (entry.flags & SET_MARK) {
+      this.markedGlyph = index;
+    }
+  }
+
+  processLigature(glyph, entry, index) {
+    if (entry.flags & SET_COMPONENT) {
+      this.ligatureStack.push(index);
+    }
+
+    if (entry.flags & PERFORM_ACTION) {
+      let actions = this.subtable.table.ligatureActions;
+      let components = this.subtable.table.components;
+      let ligatureList = this.subtable.table.ligatureList;
+
+      let actionIndex = entry.action;
+      let last = false;
+      let ligatureIndex = 0;
+      let codePoints = [];
+      let ligatureGlyphs = [];
+
+      while (!last) {
+        let componentGlyph = this.ligatureStack.pop();
+        codePoints.unshift(...this.glyphs[componentGlyph].codePoints);
+
+        let action = actions.getItem(actionIndex++);
+        last = !!(action & LAST_MASK);
+        let store = !!(action & STORE_MASK);
+        let offset = (action & OFFSET_MASK) << 2 >> 2; // sign extend 30 to 32 bits
+        offset += this.glyphs[componentGlyph].id;
+
+        let component = components.getItem(offset);
+        ligatureIndex += component;
+
+        if (last || store) {
+          let ligatureEntry = ligatureList.getItem(ligatureIndex);
+          this.glyphs[componentGlyph] = this.font.getGlyph(ligatureEntry, codePoints);
+          ligatureGlyphs.push(componentGlyph);
+          ligatureIndex = 0;
+          codePoints = [];
+        } else {
+          this.glyphs[componentGlyph] = this.font.getGlyph(0xffff);
+        }
+      }
+
+      // Put ligature glyph indexes back on the stack
+      this.ligatureStack.push(...ligatureGlyphs);
+    }
+  }
+
+  processNoncontextualSubstitutions(subtable, glyphs, index) {
+    let lookupTable = new AATLookupTable(subtable.table.lookupTable);
+
+    for (index = 0; index < glyphs.length; index++) {
+      let glyph = glyphs[index];
+      if (glyph.id !== 0xffff) {
+        let gid = lookupTable.lookup(glyph.id);
+        if (gid) { // 0 means do nothing
+          glyphs[index] = this.font.getGlyph(gid, glyph.codePoints);
+        }
+      }
+    }
+  }
+
+  _insertGlyphs(glyphIndex, insertionActionIndex, count, isBefore) {
+    let insertions = [];
+    while (count--) {
+      let gid = this.subtable.table.insertionActions.getItem(insertionActionIndex++);
+      insertions.push(this.font.getGlyph(gid));
+    }
+
+    if (!isBefore) {
+      glyphIndex++;
+    }
+
+    this.glyphs.splice(glyphIndex, 0, ...insertions);
+  }
+
+  processGlyphInsertion(glyph, entry, index) {
+    if (entry.flags & SET_MARK) {
+      this.markedIndex = index;
+    }
+
+    if (entry.markedInsertIndex !== 0xffff) {
+      let count = (entry.flags & MARKED_INSERT_COUNT) >>> 5;
+      let isBefore = !!(entry.flags & MARKED_INSERT_BEFORE);
+      this._insertGlyphs(this.markedIndex, entry.markedInsertIndex, count, isBefore);
+    }
+
+    if (entry.currentInsertIndex !== 0xffff) {
+      let count = (entry.flags & CURRENT_INSERT_COUNT) >>> 5;
+      let isBefore = !!(entry.flags & CURRENT_INSERT_BEFORE);
+      this._insertGlyphs(index, entry.currentInsertIndex, count, isBefore);
+    }
+  }
+
+  getSupportedFeatures() {
+    let features = [];
+    for (let chain of this.morx.chains) {
+      for (let feature of chain.features) {
+        features.push([feature.featureType, feature.featureSetting]);
+      }
+    }
+
+    return features;
+  }
+
+  generateInputs(gid) {
+    if (!this.inputCache) {
+      this.generateInputCache();
+    }
+
+    return this.inputCache[gid] || [];
+  }
+
+  generateInputCache() {
+    this.inputCache = {};
+
+    for (let chain of this.morx.chains) {
+      let flags = chain.defaultFlags;
+
+      for (let subtable of chain.subtables) {
+        if (subtable.subFeatureFlags & flags) {
+          this.generateInputsForSubtable(subtable);
+        }
+      }
+    }
+  }
+
+  generateInputsForSubtable(subtable) {
+    // Currently, only supporting ligature subtables.
+    if (subtable.type !== 2) {
+      return;
+    }
+
+    let reverse = !!(subtable.coverage & REVERSE_DIRECTION);
+    if (reverse) {
+      throw new Error('Reverse subtable, not supported.');
+    }
+
+    this.subtable = subtable;
+    this.ligatureStack = [];
+
+    let stateMachine = this.getStateMachine(subtable);
+    let process = this.getProcessor();
+
+    let input = [];
+    let stack = [];
+    this.glyphs = [];
+
+    stateMachine.traverse({
+      enter: (glyph, entry) => {
+        let glyphs = this.glyphs;
+        stack.push({
+          glyphs: glyphs.slice(),
+          ligatureStack: this.ligatureStack.slice()
+        });
+
+        // Add glyph to input and glyphs to process.
+        let g = this.font.getGlyph(glyph);
+        input.push(g);
+        glyphs.push(input[input.length - 1]);
+
+        // Process ligature substitution
+        process(glyphs[glyphs.length - 1], entry, glyphs.length - 1);
+
+        // Add input to result if only one matching (non-deleted) glyph remains.
+        let count = 0;
+        let found = 0;
+        for (let i = 0; i < glyphs.length && count <= 1; i++) {
+          if (glyphs[i].id !== 0xffff) {
+            count++;
+            found = glyphs[i].id;
+          }
+        }
+
+        if (count === 1) {
+          let result = input.map(g => g.id);
+          let cache = this.inputCache[found];
+          if (cache) {
+            cache.push(result);
+          } else {
+            this.inputCache[found] = [result];
+          }
+        }
+      },
+
+      exit: () => {
+        ({glyphs: this.glyphs, ligatureStack: this.ligatureStack} = stack.pop());
+        input.pop();
+      }
+    });
+  }
+}
+
+// swaps the glyphs in rangeA with those in rangeB
+// reverse the glyphs inside those ranges if specified
+// ranges are in [offset, length] format
+function swap(glyphs, rangeA, rangeB, reverseA = false, reverseB = false) {
+  let end = glyphs.splice(rangeB[0] - (rangeB[1] - 1), rangeB[1]);
+  if (reverseB) {
+    end.reverse();
+  }
+
+  let start = glyphs.splice(rangeA[0], rangeA[1], ...end);
+  if (reverseA) {
+    start.reverse();
+  }
+
+  glyphs.splice(rangeB[0] - (rangeA[1] - 1), 0, ...start);
+  return glyphs;
+}
+
+function reorderGlyphs(glyphs, verb, firstGlyph, lastGlyph) {
+  switch (verb) {
+    case 0: // no change
+      return glyphs;
+
+    case 1: // Ax => xA
+      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 0]);
+
+    case 2: // xD => Dx
+      return swap(glyphs, [firstGlyph, 0], [lastGlyph, 1]);
+
+    case 3: // AxD => DxA
+      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 1]);
+
+    case 4: // ABx => xAB
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 0]);
+
+    case 5: // ABx => xBA
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 0], true, false);
+
+    case 6: // xCD => CDx
+      return swap(glyphs, [firstGlyph, 0], [lastGlyph, 2]);
+
+    case 7: // xCD => DCx
+      return swap(glyphs, [firstGlyph, 0], [lastGlyph, 2], false, true);
+
+    case 8: // AxCD => CDxA
+      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 2]);
+
+    case 9: // AxCD => DCxA
+      return swap(glyphs, [firstGlyph, 1], [lastGlyph, 2], false, true);
+
+    case 10: // ABxD => DxAB
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 1]);
+
+    case 11: // ABxD => DxBA
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 1], true, false);
+
+    case 12: // ABxCD => CDxAB
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2]);
+
+    case 13: // ABxCD => CDxBA
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2], true, false);
+
+    case 14: // ABxCD => DCxAB
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2], false, true);
+
+    case 15: // ABxCD => DCxBA
+      return swap(glyphs, [firstGlyph, 2], [lastGlyph, 2], true, true);
+
+    default:
+      throw new Error(`Unknown verb: ${verb}`);
+  }
+}

package/src/aat/AATStateMachine.js

@@ -0,0 +1,96 @@
+import AATLookupTable from './AATLookupTable';
+
+const START_OF_TEXT_STATE = 0;
+const _START_OF_LINE_STATE = 1;
+
+const END_OF_TEXT_CLASS = 0;
+const OUT_OF_BOUNDS_CLASS = 1;
+const DELETED_GLYPH_CLASS = 2;
+const _END_OF_LINE_CLASS = 3;
+
+const DONT_ADVANCE = 0x4000;
+
+export default class AATStateMachine {
+  constructor(stateTable) {
+    this.stateTable = stateTable;
+    this.lookupTable = new AATLookupTable(stateTable.classTable);
+  }
+
+  process(glyphs, reverse, processEntry) {
+    let currentState = START_OF_TEXT_STATE; // START_OF_LINE_STATE is used for kashida glyph insertions sometimes I think?
+    let index = reverse ? glyphs.length - 1 : 0;
+    let dir = reverse ? -1 : 1;
+
+    while ((dir === 1 && index <= glyphs.length) || (dir === -1 && index >= -1)) {
+      let glyph = null;
+      let classCode;
+      let shouldAdvance = true;
+
+      if (index === glyphs.length || index === -1) {
+        classCode = END_OF_TEXT_CLASS;
+      } else {
+        glyph = glyphs[index];
+        if (glyph.id === 0xffff) { // deleted glyph
+          classCode = DELETED_GLYPH_CLASS;
+        } else {
+          classCode = this.lookupTable.lookup(glyph.id);
+          if (classCode == null) {
+            classCode = OUT_OF_BOUNDS_CLASS;
+          }
+        }
+      }
+
+      let row = this.stateTable.stateArray.getItem(currentState);
+      let entryIndex = row[classCode];
+      let entry = this.stateTable.entryTable.getItem(entryIndex);
+
+      if (classCode !== END_OF_TEXT_CLASS && classCode !==  DELETED_GLYPH_CLASS) {
+        processEntry(glyph, entry, index);
+        shouldAdvance = !(entry.flags & DONT_ADVANCE);
+      }
+
+      currentState = entry.newState;
+      if (shouldAdvance) {
+        index += dir;
+      }
+    }
+
+    return glyphs;
+  }
+
+  /**
+   * Performs a depth-first traversal of the glyph strings
+   * represented by the state machine.
+   */
+  traverse(opts, state = 0, visited = new Set) {
+    if (visited.has(state)) {
+      return;
+    }
+
+    visited.add(state);
+
+    let {nClasses, stateArray, entryTable} = this.stateTable;
+    let row = stateArray.getItem(state);
+
+    // Skip predefined classes
+    for (let classCode = 4; classCode < nClasses; classCode++) {
+      let entryIndex = row[classCode];
+      let entry = entryTable.getItem(entryIndex);
+
+      // Try all glyphs in the class
+      for (let glyph of this.lookupTable.glyphsForValue(classCode)) {
+        if (opts.enter) {
+          opts.enter(glyph, entry);
+        }
+
+        if (entry.newState !== 0) {
+          this.traverse(opts, entry.newState, visited);
+        }
+
+        if (opts.exit) {
+          opts.exit(glyph, entry);
+        }
+      }
+    }
+  }
+}

package/src/base.js

@@ -0,0 +1,29 @@
+import {DecodeStream} from 'restructure';
+
+export let logErrors = false;
+
+let formats = [];
+export function registerFormat(format) {
+  formats.push(format);
+};
+
+export function create(buffer, postscriptName) {
+  for (let i = 0; i < formats.length; i++) {
+    let format = formats[i];
+    if (format.probe(buffer)) {
+      let font = new format(new DecodeStream(buffer));
+      if (postscriptName) {
+        return font.getFont(postscriptName);
+      }
+
+      return font;
+    }
+  }
+
+  throw new Error('Unknown font format');
+};
+
+export let defaultLanguage = 'en';
+export function setDefaultLanguage(lang = 'en') {
+  defaultLanguage = lang;
+};

package/src/cff/CFFCharsets.js

@@ -0,0 +1,99 @@
+export let ISOAdobeCharset = [
+  '.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'
+];
+
+export let ExpertCharset = [
+  '.notdef', 'space', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle',
+  'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior',
+  'parenrightsuperior', 'twodotenleader', 'onedotenleader', 'comma',
+  'hyphen', 'period', 'fraction', 'zerooldstyle', 'oneoldstyle',
+  'twooldstyle', 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle',
+  'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle',
+  'colon', 'semicolon', 'commasuperior', 'threequartersemdash',
+  'periodsuperior', 'questionsmall', 'asuperior', 'bsuperior',
+  'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior',
+  'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior',
+  'tsuperior', 'ff', 'fi', 'fl', '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', 'onequarter', 'onehalf', 'threequarters',
+  'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths',
+  'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'onesuperior',
+  'twosuperior', 'threesuperior', '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'
+];
+
+export let ExpertSubsetCharset = [
+  '.notdef', 'space', 'dollaroldstyle', 'dollarsuperior',
+  'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',
+  'onedotenleader', 'comma', 'hyphen', 'period', 'fraction',
+  'zerooldstyle', 'oneoldstyle', 'twooldstyle', 'threeoldstyle',
+  'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle',
+  'eightoldstyle', 'nineoldstyle', 'colon', 'semicolon', 'commasuperior',
+  'threequartersemdash', 'periodsuperior', 'asuperior', 'bsuperior',
+  'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior',
+  'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior',
+  'tsuperior', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior',
+  'parenrightinferior', 'hyphensuperior', 'colonmonetary', 'onefitted',
+  'rupiah', 'centoldstyle', 'figuredash', 'hypheninferior', 'onequarter',
+  'onehalf', 'threequarters', 'oneeighth', 'threeeighths', 'fiveeighths',
+  'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'onesuperior',
+  'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior',
+  'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior',
+  'zeroinferior', 'oneinferior', 'twoinferior', 'threeinferior',
+  'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior',
+  'eightinferior', 'nineinferior', 'centinferior', 'dollarinferior',
+  'periodinferior', 'commainferior'
+];