diff --git a/.eslintignore b/.eslintignore
new file mode 100644
index 00000000..1befadb8
--- /dev/null
+++ b/.eslintignore
@@ -0,0 +1 @@
+src/plugins/pdfjs
\ No newline at end of file
diff --git a/docs/font-inspector.html b/docs/font-inspector.html
index c03175bf..cd711b67 100644
--- a/docs/font-inspector.html
+++ b/docs/font-inspector.html
@@ -100,6 +100,11 @@ <h1>Free Software</h1>
 
 <script type="module">
 import * as opentype from "/dist/opentype.module.js";
+import cff1filePlugin from '/dist/plugins/opentypejs.plugin.cff1file.module.js';
+import type1Plugin from '/dist/plugins/opentypejs.plugin.type1.module.js';
+
+opentype.plugins.push(cff1filePlugin);
+opentype.plugins.push(type1Plugin);
 
 var font = null;
 const fontSize = 32;
diff --git a/docs/glyph-inspector.html b/docs/glyph-inspector.html
index 401a3aec..7ce5f46c 100644
--- a/docs/glyph-inspector.html
+++ b/docs/glyph-inspector.html
@@ -70,6 +70,11 @@ <h1>Free Software</h1>
 
 <script type="module">
 import * as opentype from "/dist/opentype.module.js";
+import cff1filePlugin from '/dist/plugins/opentypejs.plugin.cff1file.module.js';
+import type1Plugin from '/dist/plugins/opentypejs.plugin.type1.module.js';
+
+opentype.plugins.push(cff1filePlugin);
+opentype.plugins.push(type1Plugin);
 
 window.opentype = opentype;
 
@@ -162,7 +167,8 @@ <h1>Free Software</h1>
     }
     html += '</dl>';
     if (glyph.numberOfContours > 0) {
-        var contours = glyph.getContours(window.font.variation.getTransform(glyph, window.fontOptions.variation).points);
+        const points = window.font.variation &&window.font.variation.getTransform(glyph, window.fontOptions.variation).points || glyph.points;
+        var contours = glyph.getContours(points);
         html += 'contours:<div id="glyph-contours">' + contours.map(contourToString).join('\n') + '</div>';
     } else if (glyph.isComposite) {
         html += '<br>This composite glyph is a combination of :<ul><li>' +
@@ -387,8 +393,8 @@ <h1>Free Software</h1>
     hline('yMin', font.tables.head.yMin);
     hline('Ascender', font.tables.hhea.ascender);
     hline('Descender', font.tables.hhea.descender);
-    hline('Typo Ascender', font.tables.os2.sTypoAscender);
-    hline('Typo Descender', font.tables.os2.sTypoDescender);
+    hline('Typo Ascender', font.tables?.os2?.sTypoAscender);
+    hline('Typo Descender', font.tables?.os2?.sTypoDescender);
 }
 
 window.redraw = function(options = { withColors: true, withVariations: true }) {
@@ -581,6 +587,8 @@ <h1>Free Software</h1>
 if ( fontData ) {
     const arrayBuffer = base64ToArrayBuffer(fontData);
     onFontLoaded(opentype.parse(arrayBuffer));
+    // redraw with correct widths
+    window.redraw();
 } else {
     const fontFileName = 'fonts/FiraSansMedium.woff';
     display(await fetch(fontFileName), fontFileName);
diff --git a/docs/index.html b/docs/index.html
index 5f8fd629..de534fa0 100755
--- a/docs/index.html
+++ b/docs/index.html
@@ -77,6 +77,11 @@ <h1>Free Software</h1>
 
 <script type="module">
 import * as opentype from "/dist/opentype.module.js";
+import cff1filePlugin from '/dist/plugins/opentypejs.plugin.cff1file.module.js';
+import type1Plugin from '/dist/plugins/opentypejs.plugin.type1.module.js';
+
+opentype.plugins.push(cff1filePlugin);
+opentype.plugins.push(type1Plugin);
 
 const form = document.forms.demo;
 form.oninput = renderText;
diff --git a/package.json b/package.json
index d770c672..ed15c502 100644
--- a/package.json
+++ b/package.json
@@ -24,16 +24,22 @@
   "browser": "./dist/opentype.js",
   "module": "./dist/opentype.module.js",
   "scripts": {
-    "build": "npm run b:umd && npm run b:esm",
-    "dist": " npm run d:umd && npm run d:esm",
+    "build": "npm run b:umd && npm run b:esm && npm run build:plugins",
+    "dist": " npm run d:umd && npm run d:esm && npm run dist:plugins",
+    "build:plugins": "npm run b:plugins:umd && npm run b:plugins:esm",
+    "dist:plugins": "npm run d:plugins:umd && npm run d:plugins:esm",
     "test": "npm run build && npm run dist && mocha --require reify --recursive && npm run lint",
     "lint": "eslint src",
     "lint-fix": "eslint src --fix",
-    "start": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=esm  --out-extension:.js=.module.js --global-name=opentype --define:DEBUG=false --footer:js=\"(function (root, factory) { if (typeof define === 'function' && define.amd)define(factory); else if (typeof module === 'object' && module.exports)module.exports = factory(); else root.opentype = factory(); }(typeof self !== 'undefined' ? self : this, () => ({...opentype,'default':opentype})));\" --watch --servedir=. --footer:js=\"new EventSource('/esbuild').addEventListener('change', () => location.reload())\"",
-    "b:umd": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=iife --out-extension:.js=.js --define:DEBUG=false --global-name=opentype --footer:js=\"(function (root, factory) { if (typeof define === 'function' && define.amd)define(factory); else if (typeof module === 'object' && module.exports)module.exports = factory(); else root.opentype = factory(); }(typeof self !== 'undefined' ? self : this, () => ({...opentype,'default':opentype})));\"",
-    "d:umd": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=iife --out-extension:.js=.min.js --define:DEBUG=false --global-name=opentype --footer:js=\"(function (root, factory) { if (typeof define === 'function' && define.amd)define(factory); else if (typeof module === 'object' && module.exports)module.exports = factory(); else root.opentype = factory(); }(typeof self !== 'undefined' ? self : this, () => ({...opentype,'default':opentype})));\" --minify --sourcemap",
-    "b:esm": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=esm  --out-extension:.js=.module.js --define:DEBUG=false",
-    "d:esm": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=esm  --out-extension:.js=.module.min.js --define:DEBUG=false --minify --sourcemap"
+    "start": "esbuild --bundle src/opentype.js --bundle src/plugins/*.js --outdir=dist --external:fs --external:http --external:https --target=esnext --format=esm --out-extension:.js=.module.js --global-name=opentype --define:DEBUG=false --footer:js=\"(function (root, factory) { if (typeof define === 'function' && define.amd)define(factory); else if (typeof module === 'object' && module.exports)module.exports = factory(); else root.opentype = factory(); }(typeof self !== 'undefined' ? self : this, () => ({...opentype,'default':opentype})));\" --watch --servedir=. --footer:js=\"new EventSource('/esbuild').addEventListener('change', () => location.reload())\"",
+    "b:umd": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=iife --out-extension:.js=.js --define:DEBUG=false --global-name=opentype --footer:js=\"(function (root, factory) { if (typeof define === 'function' && define.amd)define(factory); else if (typeof module === 'object' && module.exports)module.exports = factory(); else root.opentype = factory(); }(typeof self !== 'undefined' ? self : this, () => ({...opentype,'default':opentype})));\" --legal-comments=inline",
+    "d:umd": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=iife --out-extension:.js=.min.js --define:DEBUG=false --global-name=opentype --footer:js=\"(function (root, factory) { if (typeof define === 'function' && define.amd)define(factory); else if (typeof module === 'object' && module.exports)module.exports = factory(); else root.opentype = factory(); }(typeof self !== 'undefined' ? self : this, () => ({...opentype,'default':opentype})));\" --minify --sourcemap --legal-comments=inline",
+    "b:esm": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=esm  --out-extension:.js=.module.js --define:DEBUG=false --legal-comments=inline",
+    "d:esm": "esbuild --bundle src/opentype.js --outdir=dist --external:fs --external:http --external:https --target=es2018 --format=esm  --out-extension:.js=.module.min.js --define:DEBUG=false --minify --sourcemap --legal-comments=inline",
+    "b:plugins:umd": "esbuild --bundle src/plugins/*.js --outdir=dist/plugins --external:fs --external:http --external:https --target=es2018 --format=iife --out-extension:.js=.js --define:DEBUG=false --tree-shaking=true --legal-comments=inline",
+    "d:plugins:umd": "esbuild --bundle src/plugins/*.js --outdir=dist/plugins --external:fs --external:http --external:https --target=es2018 --format=iife --out-extension:.js=.min.js --define:DEBUG=false --minify --sourcemap --legal-comments=inline",
+    "b:plugins:esm": "esbuild --bundle src/plugins/*.js --outdir=dist/plugins --external:fs --external:http --external:https --target=es2018 --format=esm --out-extension:.js=.mjs --define:DEBUG=false --tree-shaking=true --legal-comments=inline",
+    "d:plugins:esm": "esbuild --bundle src/plugins/*.js --outdir=dist/plugins --external:fs --external:http --external:https --target=es2018 --format=esm --out-extension:.js=.min.mjs --define:DEBUG=false --minify --sourcemap --legal-comments=inline"
   },
   "devDependencies": {
     "mocha": "^8.4.0",
diff --git a/src/encoding.js b/src/encoding.js
index 0902b8c8..35ac5cc0 100644
--- a/src/encoding.js
+++ b/src/encoding.js
@@ -317,7 +317,7 @@ function addGlyphNamesAll(font) {
         const c = charCodes[i];
         const glyphIndex = glyphIndexMap[c];
         glyph = font.glyphs.get(glyphIndex);
-        glyph.addUnicode(parseInt(c));
+        glyph && glyph.addUnicode(parseInt(c));
     }
 
     for (let i = 0; i < font.glyphs.length; i += 1) {
diff --git a/src/font.js b/src/font.js
index 3029019e..7ce46f26 100644
--- a/src/font.js
+++ b/src/font.js
@@ -15,13 +15,13 @@ import HintingTrueType from './hintingtt.js';
 import Bidi from './bidi.js';
 import { applyPaintType } from './tables/cff.js';
 
-function createDefaultNamesInfo(options) {
+export function createDefaultNamesInfo(options) {
     return {
         fontFamily: {en: options.familyName || ' '},
         fontSubfamily: {en: options.styleName || ' '},
         fullName: {en: options.fullName || options.familyName + ' ' + options.styleName},
         // postScriptName may not contain any whitespace
-        postScriptName: {en: options.postScriptName || (options.familyName + options.styleName).replace(/\s/g, '')},
+        postScriptName: {en: options.postScriptName || (options.familyName + options.styleName).toString().replace(/\s/g, '')},
         designer: {en: options.designer || ' '},
         designerURL: {en: options.designerURL || ' '},
         manufacturer: {en: options.manufacturer || ' '},
diff --git a/src/glyphset.js b/src/glyphset.js
index 4b73d3fc..3a9c27fc 100644
--- a/src/glyphset.js
+++ b/src/glyphset.js
@@ -66,7 +66,7 @@ if(typeof Symbol !== 'undefined' && Symbol.iterator) {
  */
 GlyphSet.prototype.get = function(index) {
     // this.glyphs[index] is 'undefined' when low memory mode is on. glyph is pushed on request only.
-    if (this.glyphs[index] === undefined) {
+    if (index != null && this.glyphs[index] === undefined && index < (this.font.numGlyphs || this.font.nGlyphs)) {
         this.font._push(index);
         if (typeof this.glyphs[index] === 'function') {
             this.glyphs[index] = this.glyphs[index]();
@@ -153,7 +153,6 @@ function ttfGlyphLoader(font, index, parseGlyph, data, position, buildPath) {
  * @alias opentype.cffGlyphLoader
  * @param  {opentype.Font} font
  * @param  {number} index
- * @param  {Function} parseCFFCharstring
  * @param  {string} charstring
  * @return {opentype.Glyph}
  */
diff --git a/src/opentype.js b/src/opentype.js
index 256b4d75..5da00f6a 100644
--- a/src/opentype.js
+++ b/src/opentype.js
@@ -1,12 +1,14 @@
-// opentype.js
-// https://github.com/opentypejs/opentype.js
-// (c) 2015 Frederik De Bleser
-// opentype.js may be freely distributed under the MIT license.
+/*! opentype.js
+ * https://github.com/opentypejs/opentype.js
+ * (c) 2015-present Frederik De Bleser and contributors
+ * opentype.js may be freely distributed under the MIT license.
+ */
 
 import { tinf_uncompress as inflate } from './tiny-inflate@1.0.3.esm.js'; // from code4fukui/tiny-inflate-es
 import { isNode } from './util.js';
-import Font from './font.js';
+import Font, { createDefaultNamesInfo } from './font.js';
 import Glyph from './glyph.js';
+import glyphset from './glyphset.js';
 import { CmapEncoding, GlyphNames, addGlyphNames } from './encoding.js';
 import parse from './parse.js';
 import BoundingBox from './bbox.js';
@@ -39,6 +41,9 @@ import meta from './tables/meta.js';
 import gasp from './tables/gasp.js';
 import svg from './tables/svg.js';
 import { PaletteManager } from './palettes.js';
+import { sizeOf } from './types.js';
+import { plugins, applyPlugins } from './plugins.mjs';
+
 /**
  * The opentype library.
  * @namespace opentype
@@ -261,6 +266,20 @@ function parseBuffer(buffer, opt={}) {
     } else if (signature === 'wOF2') {
         var issue = 'https://github.com/opentypejs/opentype.js/issues/183#issuecomment-1147228025';
         throw new Error('WOFF2 require an external decompressor library, see examples at: ' + issue);
+    } else if(
+        applyPlugins(
+            'parseBuffer_signature',
+            { font, opt, cff, CmapEncoding, Glyph, GlyphNames, glyphset, signature, data, createDefaultNamesInfo, parse, sizeOf, tableEntries }
+        )
+    ) {
+        numTables = tableEntries.length;
+    } else if (
+        signature.substring(0,2) === '%!' ||
+        (parse.getByte(data, 0) === 0x80 && parse.getByte(data, 1) === 0x01)
+    ) {
+        throw new Error('PostScript/PS1/T1/Adobe Type 1 fonts are not supported directly, but you can use the plugin "opentypejs.plugin.type1"');
+    } else if (data.buffer.byteLength > (3 * sizeOf.Card8() + sizeOf.OffSize()) && parse.getByte(data, 0) === 0x01) {
+        throw new Error('Standalone CFF1 files are not supported directly, but you can use the plugin "opentypejs.plugin.cff1file"');
     } else {
         throw new Error('Unsupported OpenType signature ' + signature);
     }
@@ -412,9 +431,19 @@ function parseBuffer(buffer, opt={}) {
         }
     }
 
-    const nameTable = uncompressTable(data, nameTableEntry);
-    font.tables.name = _name.parse(nameTable.data, nameTable.offset, ltagTable);
-    font.names = font.tables.name;
+    applyPlugins('parseBuffer_processed', {opentype: this, font, opt, data});
+
+    if (nameTableEntry) {
+        const nameTable = uncompressTable(data, nameTableEntry);
+        font.tables.name = _name.parse(nameTable.data, nameTable.offset, ltagTable);
+        font.names = font.tables.name;
+    } else if(!font.names) {
+        console.error('Font is missing the required table "name"');
+        font.names = {};
+        font.names.unicode = createDefaultNamesInfo({});
+        font.names.macintosh = createDefaultNamesInfo({});
+        font.names.windows = createDefaultNamesInfo({});
+    }
 
     if (glyfTableEntry && locaTableEntry) {
         const shortVersion = indexToLocFormat === 0;
@@ -428,13 +457,27 @@ function parseBuffer(buffer, opt={}) {
     } else if (cff2TableEntry) {
         const cffTable2 = uncompressTable(data, cff2TableEntry);
         cff.parse(cffTable2.data, cffTable2.offset, font, opt);
-    } else {
+    } else if (!font.nGLyphs && !font.numGlyphs) {
         throw new Error('Font doesn\'t contain TrueType, CFF or CFF2 outlines.');
     }
 
-    const hmtxTable = uncompressTable(data, hmtxTableEntry);
-    hmtx.parse(font, hmtxTable.data, hmtxTable.offset, font.numberOfHMetrics, font.numGlyphs, font.glyphs, opt);
-    addGlyphNames(font, opt);
+
+    if(hmtxTableEntry) {
+        const hmtxTable = uncompressTable(data, hmtxTableEntry);
+        hmtx.parse(font, hmtxTable.data, hmtxTable.offset, font.numberOfHMetrics, font.numGlyphs, font.glyphs, opt);
+    } else if(!font._hmtxTableData) {
+        console.error('Font is missing the required table "hmtx"');
+    }
+
+    applyPlugins('parseBuffer_before_addGlyphNames', { opentype: this, font, opt, data, createDefaultNamesInfo});
+
+    if(font.tables.cmap) {
+        addGlyphNames(font, opt);
+    } else {
+        font._IndexToUnicodeMap = font._IndexToUnicodeMap || {};
+        font.glyphNames = font.glyphNames || new GlyphNames({});
+        console.warn('This font has no "cmap" table');
+    }
 
     if (kernTableEntry) {
         const kernTable = uncompressTable(data, kernTableEntry);
@@ -523,6 +566,8 @@ function parseBuffer(buffer, opt={}) {
     
     font.palettes = new PaletteManager(font);
 
+    applyPlugins('parseBuffer_parsed', { opentype: this, font, opt, data, tableEntries});
+
     return font;
 }
 
@@ -580,13 +625,18 @@ function loadSync(url, opt) {
     return parseBuffer(require('fs').readFileSync(url), opt);
 }
 
+const { GlyphSet } = glyphset;
+
 export {
     Font,
+    GlyphSet,
     Glyph,
+    GlyphNames,
     Path,
     BoundingBox,
     parse as _parse,
     parseBuffer as parse,
     load,
-    loadSync
+    loadSync,
+    plugins
 };
diff --git a/src/parse.js b/src/parse.js
index 4b405260..3545121c 100644
--- a/src/parse.js
+++ b/src/parse.js
@@ -1079,4 +1079,18 @@ export default {
     Parser,
 };
 
-export { Parser };
+export {
+    getByte,
+    getByte as getCard8,
+    getUShort,
+    getUShort as getCard16,
+    getShort,
+    getUInt24,
+    getULong,
+    getFixed,
+    getTag,
+    getOffset,
+    getBytes,
+    bytesToString,
+    Parser
+};
diff --git a/src/plugins.mjs b/src/plugins.mjs
new file mode 100644
index 00000000..7dde2f4d
--- /dev/null
+++ b/src/plugins.mjs
@@ -0,0 +1,33 @@
+export const plugins = [];
+
+/**
+ * Plugins are registered by pushing them to the opentype.plugins array.
+ * They need to export any supported entry point names as functions, which will be passed a returnData object
+ * and different params depending on the entry point, which should be documented.
+ * 
+ * The returnData object is shared by all plugins handling the same entry point and can be used to return
+ * data which can be handled by the code following an entry point. Data can also be mutated on any references
+ * to arrays or objects passed via the params.
+ * What returnData is expected/supported by each entry point should be documented as well.
+ * An entry point function returning a falsy value for returnData signals that it has not handled that entry point.
+ */
+
+/**
+ * checks if any registered plugin covers the given entry point and data
+ * @param {string} entryPoint - name of an entry point from where the plugin is called
+ * @param {Object} params - object of parameters to pass on to the plugin entry point
+ * @returns {Object|boolean} returnData object if the entry point was handled successfully by at least one plugin, false if not
+ */
+export function applyPlugins(entryPoint, params) {
+    let handled = false;
+    let returnData = {};
+    for(const plugin of plugins) {
+        if(typeof plugin[entryPoint] !== 'function') continue;
+        const pluginReturnData = plugin[entryPoint](returnData, params);
+        if(typeof pluginReturnData === 'object') {
+            returnData = Object.assign({}, returnData, pluginReturnData);
+        }
+        if(!!pluginReturnData) handled = true;
+    }
+    return handled ? returnData : false;
+}
diff --git a/src/plugins/opentypejs.plugin.cff1file.js b/src/plugins/opentypejs.plugin.cff1file.js
new file mode 100644
index 00000000..69bed5fb
--- /dev/null
+++ b/src/plugins/opentypejs.plugin.cff1file.js
@@ -0,0 +1,75 @@
+/*!
+ * OpenType.js plugin to support parsing of standalone CFF1 font files
+ * 
+ * https://adobe-type-tools.github.io/font-tech-notes/pdfs/5176.CFF.pdf
+ * 
+ * opentype.js
+ * https://github.com/opentypejs/opentype.js
+ * (c) 2015-present Frederik De Bleser and contributors
+ * opentype.js may be freely distributed under the MIT license.
+ */
+
+let isResponsible = new WeakMap();
+
+const plugin_cff1file = {
+    parseBuffer_signature: function(returnData, params) {
+        const { font, data, sizeOf, parse, tableEntries } = params;
+        if(!(data.buffer.byteLength > (3 * sizeOf.Card8() + sizeOf.OffSize()) && parse.getByte(data, 0) === 0x01)) return false;
+        isResponsible.set(font, true);
+
+        tableEntries.push({ tag: 'CFF ', offset: 0 });
+        tableEntries.push({ tag: 'name' });
+        tableEntries.push({ tag: 'hmtx' });
+        return true;
+    },
+    parseBuffer_before_addGlyphNames: function(returnData, params) {
+        if(!isResponsible.get(params.font)) return false;
+
+        const { font, createDefaultNamesInfo } = params;
+
+        font.numGlyphs = font.nGlyphs;
+
+        const cffTable = font.tables.cff;
+        const topDict = cffTable.topDict;
+        const psName = cffTable.nameIndex && cffTable.nameIndex.objects.length && cffTable.nameIndex.objects[0] || '';
+        const metaData = {
+            copyright: topDict.copyright || topDict.notice,
+            familyName: topDict.familyName || '',
+            styleName: topDict.weight || '',
+            fullName: topDict.fullName,
+            version: topDict.version,
+            postScriptName: psName
+        };
+        font.names.unicode = font.names.macintosh = font.names.windows = createDefaultNamesInfo(metaData);
+
+        const bBox = topDict.fontBBox;
+        const fMatrix = topDict.fontMatrix;
+        font.ascender = font.ascender || bBox && bBox.length > 2 && bBox[2] || 0;
+        font.descender = font.descender || bBox && bBox.length > 1 && bBox[1] || -200;
+        font.unitsPerEm = font.unitsPerEm || fMatrix && fMatrix.length && (1/fMatrix[0]) || 1000;
+
+        font.tables.cmap = {
+            glyphIndexMap: []
+        };
+        font.tables.head = {
+            xMin: bBox && bBox.length && bBox[1],
+            xMax: bBox && bBox.length > 3 && bBox[3],
+            yMin: font.descender,
+            yMax: font.ascender,
+        };
+        font.tables.hhea = {
+            descender: font.descender,
+            ascender: font.ascender,
+        };
+        font.tables.os2 = {
+            sTypoDescender: font.descender,
+            sTypoAscender: font.ascender,
+        };
+        font._hmtxTableData = {};
+        for(let i = 0; i < font.numGlyphs; i++) {
+            font._hmtxTableData[i] = {};
+        }
+    }
+};
+
+export default plugin_cff1file;
\ No newline at end of file
diff --git a/src/plugins/opentypejs.plugin.type1.js b/src/plugins/opentypejs.plugin.type1.js
new file mode 100644
index 00000000..10d73a0b
--- /dev/null
+++ b/src/plugins/opentypejs.plugin.type1.js
@@ -0,0 +1,262 @@
+/*!
+ * OpenType.js plugin to support parsing of PostScript/PS1/T1/Adobe Type 1 font files
+ * 
+ * https://adobe-type-tools.github.io/font-tech-notes/pdfs/T1_SPEC.pdf
+ * https://personal.math.ubc.ca/~cass/piscript/type1.pdf
+ * 
+ * opentype.js
+ * https://github.com/opentypejs/opentype.js
+ * (c) 2015-present Frederik De Bleser and contributors
+ * opentype.js and its plugins may be freely distributed under the MIT license.
+ * 
+ * Part of this plugin code based on mozilla/pdf.js
+ * https://github.com/mozilla/pdf.js
+ * Copyright 2012-2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Type1Parser } from './pdfjs/core/type1_parser.js';
+import { Stream } from './pdfjs/core/stream.js';
+
+let isResponsible = new WeakMap();
+
+function findEexecPosition(dataView, pfbHeader) {
+    const sequence = [0x65, 0x65, 0x78, 0x65, 0x63]; // "eexec"
+    for (let i = pfbHeader; i < dataView.byteLength - sequence.length + 1; i++) {
+        let match = true;
+        for (let j = 0; j < sequence.length; j++) {
+            if (dataView.getUint8(i + j) !== sequence[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            let pos = i + sequence.length + pfbHeader;
+            return pos;
+        }
+    }
+    return -1;
+}
+
+function extractExtendedHeader(properties) {
+    let token;
+    let skippedToken;
+    let prevToken;
+    let supported = true;
+    while ((token = this.getToken()) !== null) {
+        if (token !== '/') {
+            skippedToken = token;
+            continue;
+        }
+
+        token = this.getToken();
+        
+        if(skippedToken === undefined && !properties.postScriptName) {
+            properties.postScriptName = token;
+        } else if(prevToken === 'FontName') {
+            properties.fullName = token;
+        } else switch (token) {
+            case 'FontBBox':
+                properties.fontBBox = this.readNumberArray();
+                break;
+            case '$Blend':
+            case 'Blend':
+            case 'BlendAxisTypes':
+            case 'BlendDesignMap':
+            case 'BlendDesignPositions':
+            case 'WeightVector':
+                if(supported) {
+                    supported = false;
+                    console.warn('Type1 multiple master fonts are not supported and will contain incorrect data');
+                }
+                break;
+        }
+        prevToken = token;
+    }        
+}
+
+const plugin_cff1file = {
+    parseBuffer_signature: function(returnData, params) {
+        const { font, createDefaultNamesInfo, data, signature, parse } = params;
+        const pfbHeader = parse.getByte(data, 0) === 0x80 && parse.getByte(data, 1) === 0x01 ? 6 : 0;
+        if(signature.substring(0,2) !== '%!' && !pfbHeader) return false;
+        isResponsible.set(font, true);
+
+        const eexecDelimiter = findEexecPosition(data, pfbHeader);
+        
+        if ( eexecDelimiter > -1 ) {
+            const fontHeader = new Stream(data.buffer, 0, eexecDelimiter, {});
+            const fontData = new Stream(data.buffer, eexecDelimiter + 1, undefined, {});
+
+            const fontHeaderParser = new Type1Parser(
+                fontHeader,
+                false,
+                true
+            );
+            const extendedHeaderParser = new Type1Parser(
+                fontHeader,
+                false,
+                true
+            );
+            const fontDataParser = new Type1Parser(
+                fontData,
+                true,
+                true
+            );
+
+            const properties = {
+                widths: []
+            };
+            
+            fontHeaderParser.extractFontHeader(properties);
+            extendedHeaderParser.stream.reset();
+            extractExtendedHeader.call(extendedHeaderParser, properties);
+            
+            const glyphData = fontDataParser.extractFontProgram(properties);
+
+            if(properties.builtInEncoding) {
+                const charset = [];
+                if(properties.builtInEncoding[0] !== '.notdef') {
+                    charset.push('.notdef');
+                }
+            }
+
+            params.numTables = 0;
+
+            font.handledByPlugin = true;
+            font.outlinesFormat = 'cff';
+            font.nGlyphs = font.numGlyphs = glyphData.charstrings.length || 0;
+            const topDict = properties;
+
+            const metaData = {
+                copyright: topDict.copyright || topDict.notice,
+                familyName: topDict.familyName || '',
+                styleName: topDict.weight || '',
+                fullName: topDict.fullName,
+                version: topDict.version,
+                postScriptName: topDict.postScriptName || '',
+            };
+
+            font.glyphNames = new params.GlyphNames({});
+            font.names = {};
+            font.names.unicode = font.names.macintosh = font.names.windows = createDefaultNamesInfo(metaData);
+
+            const fMatrix = properties.fontMatrix || [0.001, 0, 0, 0.001, 0, 0];
+            const bBox = properties.fontBBox || [0,0,0,0];
+            
+            font.tables.cff = {
+                topDict: {
+                    _defaultWidthX: 0,
+                    _nominalWidthX: 0,
+                    fontBBox: bBox,
+                    fontMatrix: fMatrix
+                }
+            };
+
+            font.unitsPerEm = fMatrix && fMatrix.length && (1/fMatrix[0]) || 1000;
+            
+            bBox[0] = bBox[0] || font.unitsPerEm;
+            bBox[1] = bBox[1] || properties.descend || -200;
+            bBox[2] = bBox[2] || properties.ascend || font.unitsPerEm;
+            bBox[3] = bBox[3] || font.unitsPerEm;
+
+            font.ascender = properties.ascend || bBox[2];
+            font.descender = properties.descend || bBox[1];
+
+            font.tables.cmap = {
+                glyphIndexMap: {}
+            };
+
+            font.tables.head = {
+                xMin: bBox && bBox.length && bBox[1],
+                xMax: bBox && bBox.length > 3 && bBox[3],
+                yMin: font.descender,
+                yMax: font.ascender,
+            };
+            font.tables.hhea = {
+                descender: font.descender,
+                ascender: font.ascender,
+            };
+            font.tables.os2 = {
+                sTypoDescender: font.descender,
+                sTypoAscender: font.ascender,
+            };
+            font._hmtxTableData = {};
+            for(let i = 0; i < font.numGlyphs; i++) {
+                font._hmtxTableData[i] = {
+                    advanceWidth: 0,
+                    leftSideBearing: 0
+                };
+            }
+
+            font.gsubrs = glyphData.subrs;
+            font.gsubrsBias = params.cff.calcCFFSubroutineBias(font.gsubrs);
+
+            font.glyphs = new params.glyphset.GlyphSet(font);
+            if(!glyphData.charstrings.length && properties.builtInEncoding) {
+                if(properties.builtInEncoding[0] !== '.notdef') {
+                    font.glyphs.push(0, new params.Glyph({ name: '.notdef' }));
+                    font.glyphNames.names.push('.notdef');
+                }
+                for(let i = 0; i < properties.builtInEncoding.length; i++) {
+                    const index = font.glyphs.length;
+                    font.glyphs.push(index, new params.Glyph({ index, name: properties.builtInEncoding[i], advanceWidth: properties.widths && properties.widths[i] }));
+                }
+            } else {
+                for (let i = 0; i < font.nGlyphs; i += 1) {
+                    font._hmtxTableData[i] = {
+                        advanceWidth: glyphData.charstrings[i].width,
+                        leftSideBearing: glyphData.charstrings[i].lsb,
+                    };
+                    const name = glyphData.charstrings[i].glyphName;
+                    font.glyphNames.names.push(name);
+                    if(properties.builtInEncoding) {
+                        const charIndex = properties.builtInEncoding.indexOf(name);
+                        (charIndex > -1) && (font.tables.cmap.glyphIndexMap[charIndex] = i);
+                    }
+                }
+                const glyphLoader = function(font, i, glyphName, charString) {
+                    return function() {
+                        const glyph = params.glyphset.cffGlyphLoader(font, i, params.cff.parseCFFCharString, charString, 1)();
+                        glyph.name = glyphName;
+                        glyph.advanceWidth = glyphData.charstrings[i].width;
+                        glyph.leftSideBearing = glyphData.charstrings[i].lsb;
+                        return glyph;
+                    };
+                };
+                if (params.opt.lowMemory) {
+                    font._push = function(i) {
+                        const charString = glyphData.charstrings[i].charstring;
+                        const glyphName = glyphData.charstrings[i].glyphName;
+                        font.glyphs.push(i, glyphLoader(font, i, glyphName, charString));
+                    };
+                } else {
+                    for (let i = 0; i < font.nGlyphs; i += 1) {
+                        const charString = glyphData.charstrings[i].charstring;
+                        const glyphName = glyphData.charstrings[i].glyphName;
+                        font.glyphs.push(i, glyphLoader(font, i, glyphName, charString));
+                    }
+                }
+            }
+
+            font.encoding = new params.CmapEncoding(font.tables.cmap);
+        } else {
+            console.error('Type 1 font is missing eexec comand or binary data');
+            return false;
+        }
+
+        return true;
+    },
+};
+
+export default plugin_cff1file;
\ No newline at end of file
diff --git a/src/plugins/pdfjs/core/base_stream.js b/src/plugins/pdfjs/core/base_stream.js
new file mode 100644
index 00000000..f10d266e
--- /dev/null
+++ b/src/plugins/pdfjs/core/base_stream.js
@@ -0,0 +1,110 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { bytesToString, shadow, unreachable } from "../shared/util.js";
+
+class BaseStream {
+  constructor() {
+    if (this.constructor === BaseStream) {
+      unreachable("Cannot initialize BaseStream.");
+    }
+  }
+
+  // eslint-disable-next-line getter-return
+  get length() {
+    unreachable("Abstract getter `length` accessed");
+  }
+
+  // eslint-disable-next-line getter-return
+  get isEmpty() {
+    unreachable("Abstract getter `isEmpty` accessed");
+  }
+
+  get isDataLoaded() {
+    return shadow(this, "isDataLoaded", true);
+  }
+
+  getByte() {
+    unreachable("Abstract method `getByte` called");
+  }
+
+  getBytes(length) {
+    unreachable("Abstract method `getBytes` called");
+  }
+
+  peekByte() {
+    const peekedByte = this.getByte();
+    if (peekedByte !== -1) {
+      this.pos--;
+    }
+    return peekedByte;
+  }
+
+  peekBytes(length) {
+    const bytes = this.getBytes(length);
+    this.pos -= bytes.length;
+    return bytes;
+  }
+
+  getUint16() {
+    const b0 = this.getByte();
+    const b1 = this.getByte();
+    if (b0 === -1 || b1 === -1) {
+      return -1;
+    }
+    return (b0 << 8) + b1;
+  }
+
+  getInt32() {
+    const b0 = this.getByte();
+    const b1 = this.getByte();
+    const b2 = this.getByte();
+    const b3 = this.getByte();
+    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
+  }
+
+  getByteRange(begin, end) {
+    unreachable("Abstract method `getByteRange` called");
+  }
+
+  getString(length) {
+    return bytesToString(this.getBytes(length));
+  }
+
+  skip(n) {
+    this.pos += n || 1;
+  }
+
+  reset() {
+    unreachable("Abstract method `reset` called");
+  }
+
+  moveStart() {
+    unreachable("Abstract method `moveStart` called");
+  }
+
+  makeSubStream(start, length, dict = null) {
+    unreachable("Abstract method `makeSubStream` called");
+  }
+
+  /**
+   * @returns {Array | null}
+   */
+  getBaseStreams() {
+    return null;
+  }
+}
+
+export { BaseStream };
diff --git a/src/plugins/pdfjs/core/core_utils.js b/src/plugins/pdfjs/core/core_utils.js
new file mode 100644
index 00000000..f46e41f9
--- /dev/null
+++ b/src/plugins/pdfjs/core/core_utils.js
@@ -0,0 +1,23 @@
+/* Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Checks if ch is one of the following characters: SPACE, TAB, CR or LF.
+function isWhiteSpace(ch) {
+  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
+}
+
+export {
+  isWhiteSpace,
+};
diff --git a/src/plugins/pdfjs/core/encodings.js b/src/plugins/pdfjs/core/encodings.js
new file mode 100644
index 00000000..8ebbd7be
--- /dev/null
+++ b/src/plugins/pdfjs/core/encodings.js
@@ -0,0 +1,301 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// prettier-ignore
+const ExpertEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "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"];
+
+// prettier-ignore
+const MacExpertEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "space", "exclamsmall", "Hungarumlautsmall", "centoldstyle",
+  "dollaroldstyle", "dollarsuperior", "ampersandsmall", "Acutesmall",
+  "parenleftsuperior", "parenrightsuperior", "twodotenleader",
+  "onedotenleader", "comma", "hyphen", "period", "fraction", "zerooldstyle",
+  "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle",
+  "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle",
+  "nineoldstyle", "colon", "semicolon", "", "threequartersemdash", "",
+  "questionsmall", "", "", "", "", "Ethsmall", "", "", "onequarter",
+  "onehalf", "threequarters", "oneeighth", "threeeighths", "fiveeighths",
+  "seveneighths", "onethird", "twothirds", "", "", "", "", "", "", "ff",
+  "fi", "fl", "ffi", "ffl", "parenleftinferior", "", "parenrightinferior",
+  "Circumflexsmall", "hypheninferior", "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", "", "", "asuperior", "centsuperior", "", "", "", "",
+  "Aacutesmall", "Agravesmall", "Acircumflexsmall", "Adieresissmall",
+  "Atildesmall", "Aringsmall", "Ccedillasmall", "Eacutesmall", "Egravesmall",
+  "Ecircumflexsmall", "Edieresissmall", "Iacutesmall", "Igravesmall",
+  "Icircumflexsmall", "Idieresissmall", "Ntildesmall", "Oacutesmall",
+  "Ogravesmall", "Ocircumflexsmall", "Odieresissmall", "Otildesmall",
+  "Uacutesmall", "Ugravesmall", "Ucircumflexsmall", "Udieresissmall", "",
+  "eightsuperior", "fourinferior", "threeinferior", "sixinferior",
+  "eightinferior", "seveninferior", "Scaronsmall", "", "centinferior",
+  "twoinferior", "", "Dieresissmall", "", "Caronsmall", "osuperior",
+  "fiveinferior", "", "commainferior", "periodinferior", "Yacutesmall", "",
+  "dollarinferior", "", "", "Thornsmall", "", "nineinferior", "zeroinferior",
+  "Zcaronsmall", "AEsmall", "Oslashsmall", "questiondownsmall",
+  "oneinferior", "Lslashsmall", "", "", "", "", "", "", "Cedillasmall", "",
+  "", "", "", "", "OEsmall", "figuredash", "hyphensuperior", "", "", "", "",
+  "exclamdownsmall", "", "Ydieresissmall", "", "onesuperior", "twosuperior",
+  "threesuperior", "foursuperior", "fivesuperior", "sixsuperior",
+  "sevensuperior", "ninesuperior", "zerosuperior", "", "esuperior",
+  "rsuperior", "tsuperior", "", "", "isuperior", "ssuperior", "dsuperior",
+  "", "", "", "", "", "lsuperior", "Ogoneksmall", "Brevesmall",
+  "Macronsmall", "bsuperior", "nsuperior", "msuperior", "commasuperior",
+  "periodsuperior", "Dotaccentsmall", "Ringsmall", "", "", "", ""];
+
+// prettier-ignore
+const MacRomanEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "space", "exclam", "quotedbl", "numbersign", "dollar", "percent",
+  "ampersand", "quotesingle", "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", "grave", "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", "",
+  "Adieresis", "Aring", "Ccedilla", "Eacute", "Ntilde", "Odieresis",
+  "Udieresis", "aacute", "agrave", "acircumflex", "adieresis", "atilde",
+  "aring", "ccedilla", "eacute", "egrave", "ecircumflex", "edieresis",
+  "iacute", "igrave", "icircumflex", "idieresis", "ntilde", "oacute",
+  "ograve", "ocircumflex", "odieresis", "otilde", "uacute", "ugrave",
+  "ucircumflex", "udieresis", "dagger", "degree", "cent", "sterling",
+  "section", "bullet", "paragraph", "germandbls", "registered", "copyright",
+  "trademark", "acute", "dieresis", "notequal", "AE", "Oslash", "infinity",
+  "plusminus", "lessequal", "greaterequal", "yen", "mu", "partialdiff",
+  "summation", "product", "pi", "integral", "ordfeminine", "ordmasculine",
+  "Omega", "ae", "oslash", "questiondown", "exclamdown", "logicalnot",
+  "radical", "florin", "approxequal", "Delta", "guillemotleft",
+  "guillemotright", "ellipsis", "space", "Agrave", "Atilde", "Otilde", "OE",
+  "oe", "endash", "emdash", "quotedblleft", "quotedblright", "quoteleft",
+  "quoteright", "divide", "lozenge", "ydieresis", "Ydieresis", "fraction",
+  "currency", "guilsinglleft", "guilsinglright", "fi", "fl", "daggerdbl",
+  "periodcentered", "quotesinglbase", "quotedblbase", "perthousand",
+  "Acircumflex", "Ecircumflex", "Aacute", "Edieresis", "Egrave", "Iacute",
+  "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex", "apple",
+  "Ograve", "Uacute", "Ucircumflex", "Ugrave", "dotlessi", "circumflex",
+  "tilde", "macron", "breve", "dotaccent", "ring", "cedilla", "hungarumlaut",
+  "ogonek", "caron"];
+
+// prettier-ignore
+const StandardEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "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", "",
+  "", "", ""];
+
+// prettier-ignore
+const WinAnsiEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "space", "exclam", "quotedbl", "numbersign", "dollar", "percent",
+  "ampersand", "quotesingle", "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", "grave", "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",
+  "bullet", "Euro", "bullet", "quotesinglbase", "florin", "quotedblbase",
+  "ellipsis", "dagger", "daggerdbl", "circumflex", "perthousand", "Scaron",
+  "guilsinglleft", "OE", "bullet", "Zcaron", "bullet", "bullet", "quoteleft",
+  "quoteright", "quotedblleft", "quotedblright", "bullet", "endash",
+  "emdash", "tilde", "trademark", "scaron", "guilsinglright", "oe", "bullet",
+  "zcaron", "Ydieresis", "space", "exclamdown", "cent", "sterling",
+  "currency", "yen", "brokenbar", "section", "dieresis", "copyright",
+  "ordfeminine", "guillemotleft", "logicalnot", "hyphen", "registered",
+  "macron", "degree", "plusminus", "twosuperior", "threesuperior", "acute",
+  "mu", "paragraph", "periodcentered", "cedilla", "onesuperior",
+  "ordmasculine", "guillemotright", "onequarter", "onehalf", "threequarters",
+  "questiondown", "Agrave", "Aacute", "Acircumflex", "Atilde", "Adieresis",
+  "Aring", "AE", "Ccedilla", "Egrave", "Eacute", "Ecircumflex", "Edieresis",
+  "Igrave", "Iacute", "Icircumflex", "Idieresis", "Eth", "Ntilde", "Ograve",
+  "Oacute", "Ocircumflex", "Otilde", "Odieresis", "multiply", "Oslash",
+  "Ugrave", "Uacute", "Ucircumflex", "Udieresis", "Yacute", "Thorn",
+  "germandbls", "agrave", "aacute", "acircumflex", "atilde", "adieresis",
+  "aring", "ae", "ccedilla", "egrave", "eacute", "ecircumflex", "edieresis",
+  "igrave", "iacute", "icircumflex", "idieresis", "eth", "ntilde", "ograve",
+  "oacute", "ocircumflex", "otilde", "odieresis", "divide", "oslash",
+  "ugrave", "uacute", "ucircumflex", "udieresis", "yacute", "thorn",
+  "ydieresis"];
+
+// prettier-ignore
+const SymbolSetEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "space", "exclam", "universal", "numbersign", "existential", "percent",
+  "ampersand", "suchthat", "parenleft", "parenright", "asteriskmath", "plus",
+  "comma", "minus", "period", "slash", "zero", "one", "two", "three", "four",
+  "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less",
+  "equal", "greater", "question", "congruent", "Alpha", "Beta", "Chi",
+  "Delta", "Epsilon", "Phi", "Gamma", "Eta", "Iota", "theta1", "Kappa",
+  "Lambda", "Mu", "Nu", "Omicron", "Pi", "Theta", "Rho", "Sigma", "Tau",
+  "Upsilon", "sigma1", "Omega", "Xi", "Psi", "Zeta", "bracketleft",
+  "therefore", "bracketright", "perpendicular", "underscore", "radicalex",
+  "alpha", "beta", "chi", "delta", "epsilon", "phi", "gamma", "eta", "iota",
+  "phi1", "kappa", "lambda", "mu", "nu", "omicron", "pi", "theta", "rho",
+  "sigma", "tau", "upsilon", "omega1", "omega", "xi", "psi", "zeta",
+  "braceleft", "bar", "braceright", "similar", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "Euro", "Upsilon1", "minute", "lessequal",
+  "fraction", "infinity", "florin", "club", "diamond", "heart", "spade",
+  "arrowboth", "arrowleft", "arrowup", "arrowright", "arrowdown", "degree",
+  "plusminus", "second", "greaterequal", "multiply", "proportional",
+  "partialdiff", "bullet", "divide", "notequal", "equivalence",
+  "approxequal", "ellipsis", "arrowvertex", "arrowhorizex", "carriagereturn",
+  "aleph", "Ifraktur", "Rfraktur", "weierstrass", "circlemultiply",
+  "circleplus", "emptyset", "intersection", "union", "propersuperset",
+  "reflexsuperset", "notsubset", "propersubset", "reflexsubset", "element",
+  "notelement", "angle", "gradient", "registerserif", "copyrightserif",
+  "trademarkserif", "product", "radical", "dotmath", "logicalnot",
+  "logicaland", "logicalor", "arrowdblboth", "arrowdblleft", "arrowdblup",
+  "arrowdblright", "arrowdbldown", "lozenge", "angleleft", "registersans",
+  "copyrightsans", "trademarksans", "summation", "parenlefttp",
+  "parenleftex", "parenleftbt", "bracketlefttp", "bracketleftex",
+  "bracketleftbt", "bracelefttp", "braceleftmid", "braceleftbt", "braceex",
+  "", "angleright", "integral", "integraltp", "integralex", "integralbt",
+  "parenrighttp", "parenrightex", "parenrightbt", "bracketrighttp",
+  "bracketrightex", "bracketrightbt", "bracerighttp", "bracerightmid",
+  "bracerightbt", ""];
+
+// prettier-ignore
+const ZapfDingbatsEncoding = [
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+  "space", "a1", "a2", "a202", "a3", "a4", "a5", "a119", "a118", "a117",
+  "a11", "a12", "a13", "a14", "a15", "a16", "a105", "a17", "a18", "a19",
+  "a20", "a21", "a22", "a23", "a24", "a25", "a26", "a27", "a28", "a6", "a7",
+  "a8", "a9", "a10", "a29", "a30", "a31", "a32", "a33", "a34", "a35", "a36",
+  "a37", "a38", "a39", "a40", "a41", "a42", "a43", "a44", "a45", "a46",
+  "a47", "a48", "a49", "a50", "a51", "a52", "a53", "a54", "a55", "a56",
+  "a57", "a58", "a59", "a60", "a61", "a62", "a63", "a64", "a65", "a66",
+  "a67", "a68", "a69", "a70", "a71", "a72", "a73", "a74", "a203", "a75",
+  "a204", "a76", "a77", "a78", "a79", "a81", "a82", "a83", "a84", "a97",
+  "a98", "a99", "a100", "", "a89", "a90", "a93", "a94", "a91", "a92", "a205",
+  "a85", "a206", "a86", "a87", "a88", "a95", "a96", "", "", "", "", "", "",
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "a101", "a102", "a103",
+  "a104", "a106", "a107", "a108", "a112", "a111", "a110", "a109", "a120",
+  "a121", "a122", "a123", "a124", "a125", "a126", "a127", "a128", "a129",
+  "a130", "a131", "a132", "a133", "a134", "a135", "a136", "a137", "a138",
+  "a139", "a140", "a141", "a142", "a143", "a144", "a145", "a146", "a147",
+  "a148", "a149", "a150", "a151", "a152", "a153", "a154", "a155", "a156",
+  "a157", "a158", "a159", "a160", "a161", "a163", "a164", "a196", "a165",
+  "a192", "a166", "a167", "a168", "a169", "a170", "a171", "a172", "a173",
+  "a162", "a174", "a175", "a176", "a177", "a178", "a179", "a193", "a180",
+  "a199", "a181", "a200", "a182", "", "a201", "a183", "a184", "a197", "a185",
+  "a194", "a198", "a186", "a195", "a187", "a188", "a189", "a190", "a191", ""];
+
+function getEncoding(encodingName) {
+  switch (encodingName) {
+    case "WinAnsiEncoding":
+      return WinAnsiEncoding;
+    case "StandardEncoding":
+      return StandardEncoding;
+    case "MacRomanEncoding":
+      return MacRomanEncoding;
+    case "SymbolSetEncoding":
+      return SymbolSetEncoding;
+    case "ZapfDingbatsEncoding":
+      return ZapfDingbatsEncoding;
+    case "ExpertEncoding":
+      return ExpertEncoding;
+    case "MacExpertEncoding":
+      return MacExpertEncoding;
+    default:
+      return null;
+  }
+}
+
+export {
+  ExpertEncoding,
+  getEncoding,
+  MacRomanEncoding,
+  StandardEncoding,
+  SymbolSetEncoding,
+  WinAnsiEncoding,
+  ZapfDingbatsEncoding,
+};
diff --git a/src/plugins/pdfjs/core/stream.js b/src/plugins/pdfjs/core/stream.js
new file mode 100644
index 00000000..250cd808
--- /dev/null
+++ b/src/plugins/pdfjs/core/stream.js
@@ -0,0 +1,86 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { BaseStream } from "./base_stream.js";
+
+class Stream extends BaseStream {
+  constructor(arrayBuffer, start, length, dict) {
+    super();
+
+    this.bytes =
+      arrayBuffer instanceof Uint8Array
+        ? arrayBuffer
+        : new Uint8Array(arrayBuffer);
+    this.start = start || 0;
+    this.pos = this.start;
+    this.end = start + length || this.bytes.length;
+    this.dict = dict;
+  }
+
+  get length() {
+    return this.end - this.start;
+  }
+
+  get isEmpty() {
+    return this.length === 0;
+  }
+
+  getByte() {
+    if (this.pos >= this.end) {
+      return -1;
+    }
+    return this.bytes[this.pos++];
+  }
+
+  getBytes(length) {
+    const bytes = this.bytes;
+    const pos = this.pos;
+    const strEnd = this.end;
+
+    if (!length) {
+      return bytes.subarray(pos, strEnd);
+    }
+    let end = pos + length;
+    if (end > strEnd) {
+      end = strEnd;
+    }
+    this.pos = end;
+    return bytes.subarray(pos, end);
+  }
+
+  getByteRange(begin, end) {
+    if (begin < 0) {
+      begin = 0;
+    }
+    if (end > this.end) {
+      end = this.end;
+    }
+    return this.bytes.subarray(begin, end);
+  }
+
+  reset() {
+    this.pos = this.start;
+  }
+
+  moveStart() {
+    this.start = this.pos;
+  }
+
+  makeSubStream(start, length, dict = null) {
+    return new Stream(this.bytes.buffer, start, length, dict);
+  }
+}
+
+export { Stream };
diff --git a/src/plugins/pdfjs/core/type1_parser.js b/src/plugins/pdfjs/core/type1_parser.js
new file mode 100644
index 00000000..13d04396
--- /dev/null
+++ b/src/plugins/pdfjs/core/type1_parser.js
@@ -0,0 +1,773 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getEncoding } from "./encodings.js";
+import { isWhiteSpace } from "./core_utils.js";
+import { Stream } from "./stream.js";
+import { warn } from "../shared/util.js";
+
+// Hinting is currently disabled due to unknown problems on windows
+// in tracemonkey and various other pdfs with type1 fonts.
+const HINTING_ENABLED = false;
+
+const COMMAND_MAP = {
+  hstem: [1],
+  vstem: [3],
+  vmoveto: [4],
+  rlineto: [5],
+  hlineto: [6],
+  vlineto: [7],
+  rrcurveto: [8],
+  callsubr: [10],
+  flex: [12, 35],
+  drop: [12, 18],
+  endchar: [14],
+  rmoveto: [21],
+  hmoveto: [22],
+  vhcurveto: [30],
+  hvcurveto: [31],
+};
+
+/**
+ * CharStrings are encoded following the the CharString Encoding sequence
+ * describe in Chapter 6 of the "Adobe Type1 Font Format" specification.
+ * The value in a byte indicates a command, a number, or subsequent bytes
+ * that are to be interpreted in a special way.
+ *
+ * CharString Number Encoding:
+ *  A CharString byte containing the values from 32 through 255 inclusive
+ *  indicate an integer. These values are decoded in four ranges.
+ *
+ * 1. A CharString byte containing a value, v, between 32 and 246 inclusive,
+ * indicate the integer v - 139. Thus, the integer values from -107 through
+ * 107 inclusive may be encoded in single byte.
+ *
+ * 2. A CharString byte containing a value, v, between 247 and 250 inclusive,
+ * indicates an integer involving the next byte, w, according to the formula:
+ * [(v - 247) x 256] + w + 108
+ *
+ * 3. A CharString byte containing a value, v, between 251 and 254 inclusive,
+ * indicates an integer involving the next byte, w, according to the formula:
+ * -[(v - 251) * 256] - w - 108
+ *
+ * 4. A CharString containing the value 255 indicates that the next 4 bytes
+ * are a two complement signed integer. The first of these bytes contains the
+ * highest order bits, the second byte contains the next higher order bits
+ * and the fourth byte contain the lowest order bits.
+ *
+ *
+ * CharString Command Encoding:
+ *  CharStrings commands are encoded in 1 or 2 bytes.
+ *
+ *  Single byte commands are encoded in 1 byte that contains a value between
+ *  0 and 31 inclusive.
+ *  If a command byte contains the value 12, then the value in the next byte
+ *  indicates a command. This "escape" mechanism allows many extra commands
+ *  to be encoded and this encoding technique helps to minimize the length of
+ *  the charStrings.
+ */
+class Type1CharString {
+  constructor() {
+    this.width = 0;
+    this.lsb = 0;
+    this.flexing = false;
+    this.output = [];
+    this.stack = [];
+  }
+
+  convert(encoded, subrs, seacAnalysisEnabled) {
+    const count = encoded.length;
+    let error = false;
+    let wx, sbx, subrNumber;
+    for (let i = 0; i < count; i++) {
+      let value = encoded[i];
+      if (value < 32) {
+        if (value === 12) {
+          value = (value << 8) + encoded[++i];
+        }
+        switch (value) {
+          case 1: // hstem
+            if (!HINTING_ENABLED) {
+              this.stack = [];
+              break;
+            }
+            error = this.executeCommand(2, COMMAND_MAP.hstem);
+            break;
+          case 3: // vstem
+            if (!HINTING_ENABLED) {
+              this.stack = [];
+              break;
+            }
+            error = this.executeCommand(2, COMMAND_MAP.vstem);
+            break;
+          case 4: // vmoveto
+            if (this.flexing) {
+              if (this.stack.length < 1) {
+                error = true;
+                break;
+              }
+              // Add the dx for flex and but also swap the values so they are
+              // the right order.
+              const dy = this.stack.pop();
+              this.stack.push(0, dy);
+              break;
+            }
+            error = this.executeCommand(1, COMMAND_MAP.vmoveto);
+            break;
+          case 5: // rlineto
+            error = this.executeCommand(2, COMMAND_MAP.rlineto);
+            break;
+          case 6: // hlineto
+            error = this.executeCommand(1, COMMAND_MAP.hlineto);
+            break;
+          case 7: // vlineto
+            error = this.executeCommand(1, COMMAND_MAP.vlineto);
+            break;
+          case 8: // rrcurveto
+            error = this.executeCommand(6, COMMAND_MAP.rrcurveto);
+            break;
+          case 9: // closepath
+            // closepath is a Type1 command that does not take argument and is
+            // useless in Type2 and it can simply be ignored.
+            this.stack = [];
+            break;
+          case 10: // callsubr
+            if (this.stack.length < 1) {
+              error = true;
+              break;
+            }
+            subrNumber = this.stack.pop();
+            if (!subrs[subrNumber]) {
+              error = true;
+              break;
+            }
+            error = this.convert(subrs[subrNumber], subrs, seacAnalysisEnabled);
+            break;
+          case 11: // return
+            return error;
+          case 13: // hsbw
+            if (this.stack.length < 2) {
+              error = true;
+              break;
+            }
+            // To convert to type2 we have to move the width value to the
+            // first part of the charstring and then use hmoveto with lsb.
+            wx = this.stack.pop();
+            sbx = this.stack.pop();
+            this.lsb = sbx;
+            this.width = wx;
+            this.stack.push(wx, sbx);
+            error = this.executeCommand(2, COMMAND_MAP.hmoveto);
+            break;
+          case 14: // endchar
+            this.output.push(COMMAND_MAP.endchar[0]);
+            break;
+          case 21: // rmoveto
+            if (this.flexing) {
+              break;
+            }
+            error = this.executeCommand(2, COMMAND_MAP.rmoveto);
+            break;
+          case 22: // hmoveto
+            if (this.flexing) {
+              // Add the dy for flex.
+              this.stack.push(0);
+              break;
+            }
+            error = this.executeCommand(1, COMMAND_MAP.hmoveto);
+            break;
+          case 30: // vhcurveto
+            error = this.executeCommand(4, COMMAND_MAP.vhcurveto);
+            break;
+          case 31: // hvcurveto
+            error = this.executeCommand(4, COMMAND_MAP.hvcurveto);
+            break;
+          case (12 << 8) + 0: // dotsection
+            // dotsection is a Type1 command to specify some hinting feature
+            // for dots that do not take a parameter and it can safely be
+            // ignored for Type2.
+            this.stack = [];
+            break;
+          case (12 << 8) + 1: // vstem3
+            if (!HINTING_ENABLED) {
+              this.stack = [];
+              break;
+            }
+            // [vh]stem3 are Type1 only and Type2 supports [vh]stem with
+            // multiple parameters, so instead of returning [vh]stem3 take a
+            // shortcut and return [vhstem] instead.
+            error = this.executeCommand(2, COMMAND_MAP.vstem);
+            break;
+          case (12 << 8) + 2: // hstem3
+            if (!HINTING_ENABLED) {
+              this.stack = [];
+              break;
+            }
+            // See vstem3.
+            error = this.executeCommand(2, COMMAND_MAP.hstem);
+            break;
+          case (12 << 8) + 6: // seac
+            // seac is like type 2's special endchar but it doesn't use the
+            // first argument asb, so remove it.
+            if (seacAnalysisEnabled) {
+              const asb = this.stack.at(-5);
+              this.seac = this.stack.splice(-4, 4);
+              this.seac[0] += this.lsb - asb;
+              error = this.executeCommand(0, COMMAND_MAP.endchar);
+            } else {
+              error = this.executeCommand(4, COMMAND_MAP.endchar);
+            }
+            break;
+          case (12 << 8) + 7: // sbw
+            if (this.stack.length < 4) {
+              error = true;
+              break;
+            }
+            // To convert to type2 we have to move the width value to the
+            // first part of the charstring and then use rmoveto with
+            // (dx, dy). The height argument will not be used for vmtx and
+            // vhea tables reconstruction -- ignoring it.
+            this.stack.pop(); // wy
+            wx = this.stack.pop();
+            const sby = this.stack.pop();
+            sbx = this.stack.pop();
+            this.lsb = sbx;
+            this.width = wx;
+            this.stack.push(wx, sbx, sby);
+            error = this.executeCommand(3, COMMAND_MAP.rmoveto);
+            break;
+          case (12 << 8) + 12: // div
+            if (this.stack.length < 2) {
+              error = true;
+              break;
+            }
+            const num2 = this.stack.pop();
+            const num1 = this.stack.pop();
+            this.stack.push(num1 / num2);
+            break;
+          case (12 << 8) + 16: // callothersubr
+            if (this.stack.length < 2) {
+              error = true;
+              break;
+            }
+            subrNumber = this.stack.pop();
+            const numArgs = this.stack.pop();
+            if (subrNumber === 0 && numArgs === 3) {
+              const flexArgs = this.stack.splice(-17, 17);
+              this.stack.push(
+                flexArgs[2] + flexArgs[0], // bcp1x + rpx
+                flexArgs[3] + flexArgs[1], // bcp1y + rpy
+                flexArgs[4], // bcp2x
+                flexArgs[5], // bcp2y
+                flexArgs[6], // p2x
+                flexArgs[7], // p2y
+                flexArgs[8], // bcp3x
+                flexArgs[9], // bcp3y
+                flexArgs[10], // bcp4x
+                flexArgs[11], // bcp4y
+                flexArgs[12], // p3x
+                flexArgs[13], // p3y
+                flexArgs[14] // flexDepth
+                // 15 = finalx unused by flex
+                // 16 = finaly unused by flex
+              );
+              error = this.executeCommand(13, COMMAND_MAP.flex, true);
+              this.flexing = false;
+              this.stack.push(flexArgs[15], flexArgs[16]);
+            } else if (subrNumber === 1 && numArgs === 0) {
+              this.flexing = true;
+            }
+            break;
+          case (12 << 8) + 17: // pop
+            // Ignore this since it is only used with othersubr.
+            break;
+          case (12 << 8) + 33: // setcurrentpoint
+            // Ignore for now.
+            this.stack = [];
+            break;
+          default:
+            warn('Unknown type 1 charstring command of "' + value + '"');
+            break;
+        }
+        if (error) {
+          break;
+        }
+        continue;
+      } else if (value <= 246) {
+        value -= 139;
+      } else if (value <= 250) {
+        value = (value - 247) * 256 + encoded[++i] + 108;
+      } else if (value <= 254) {
+        value = -((value - 251) * 256) - encoded[++i] - 108;
+      } else {
+        value =
+          ((encoded[++i] & 0xff) << 24) |
+          ((encoded[++i] & 0xff) << 16) |
+          ((encoded[++i] & 0xff) << 8) |
+          ((encoded[++i] & 0xff) << 0);
+      }
+      this.stack.push(value);
+    }
+    return error;
+  }
+
+  executeCommand(howManyArgs, command, keepStack) {
+    const stackLength = this.stack.length;
+    if (howManyArgs > stackLength) {
+      return true;
+    }
+    const start = stackLength - howManyArgs;
+    for (let i = start; i < stackLength; i++) {
+      let value = this.stack[i];
+      if (Number.isInteger(value)) {
+        this.output.push(28, (value >> 8) & 0xff, value & 0xff);
+      } else {
+        // fixed point
+        value = (65536 * value) | 0;
+        this.output.push(
+          255,
+          (value >> 24) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        );
+      }
+    }
+    this.output.push(...command);
+    if (keepStack) {
+      this.stack.splice(start, howManyArgs);
+    } else {
+      this.stack.length = 0;
+    }
+    return false;
+  }
+}
+
+/**
+ * Decrypt a Sequence of Ciphertext Bytes to Produce the Original Sequence
+ * of Plaintext Bytes. The function takes a key as a parameter which can be
+ * for decrypting the eexec block or for decoding charStrings.
+ */
+const EEXEC_ENCRYPT_KEY = 55665;
+const CHAR_STRS_ENCRYPT_KEY = 4330;
+
+function isHexDigit(code) {
+  return (
+    (code >= 48 && code <= 57) || // '0'-'9'
+    (code >= 65 && code <= 70) || // 'A'-'F'
+    (code >= 97 && code <= 102) // 'a'-'f'
+  );
+}
+
+function decrypt(data, key, discardNumber) {
+  if (discardNumber >= data.length) {
+    return new Uint8Array(0);
+  }
+  const c1 = 52845,
+    c2 = 22719;
+  let r = key | 0,
+    i,
+    j;
+  for (i = 0; i < discardNumber; i++) {
+    r = ((data[i] + r) * c1 + c2) & ((1 << 16) - 1);
+  }
+  const count = data.length - discardNumber;
+  const decrypted = new Uint8Array(count);
+  for (i = discardNumber, j = 0; j < count; i++, j++) {
+    const value = data[i];
+    decrypted[j] = value ^ (r >> 8);
+    r = ((value + r) * c1 + c2) & ((1 << 16) - 1);
+  }
+  return decrypted;
+}
+
+function decryptAscii(data, key, discardNumber) {
+  const c1 = 52845,
+    c2 = 22719;
+  let r = key | 0;
+  const count = data.length,
+    maybeLength = count >>> 1;
+  const decrypted = new Uint8Array(maybeLength);
+  let i, j;
+  for (i = 0, j = 0; i < count; i++) {
+    const digit1 = data[i];
+    if (!isHexDigit(digit1)) {
+      continue;
+    }
+    i++;
+    let digit2;
+    while (i < count && !isHexDigit((digit2 = data[i]))) {
+      i++;
+    }
+    if (i < count) {
+      const value = parseInt(String.fromCharCode(digit1, digit2), 16);
+      decrypted[j++] = value ^ (r >> 8);
+      r = ((value + r) * c1 + c2) & ((1 << 16) - 1);
+    }
+  }
+  return decrypted.slice(discardNumber, j);
+}
+
+function isSpecial(c) {
+  return (
+    c === /* '/' = */ 0x2f ||
+    c === /* '[' = */ 0x5b ||
+    c === /* ']' = */ 0x5d ||
+    c === /* '{' = */ 0x7b ||
+    c === /* '}' = */ 0x7d ||
+    c === /* '(' = */ 0x28 ||
+    c === /* ')' = */ 0x29
+  );
+}
+
+/**
+ * Type1Parser encapsulate the needed code for parsing a Type1 font program.
+ * Some of its logic depends on the Type2 charstrings structure.
+ * NOTE: This doesn't really parse the font since that would require evaluation
+ *       of PostScript, but it is possible in most cases to extract what we need
+ *       without a full parse.
+ */
+class Type1Parser {
+  constructor(stream, encrypted, seacAnalysisEnabled) {
+    if (encrypted) {
+      const data = stream.getBytes();
+      const isBinary = !(
+        (isHexDigit(data[0]) || isWhiteSpace(data[0])) &&
+        isHexDigit(data[1]) &&
+        isHexDigit(data[2]) &&
+        isHexDigit(data[3]) &&
+        isHexDigit(data[4]) &&
+        isHexDigit(data[5]) &&
+        isHexDigit(data[6]) &&
+        isHexDigit(data[7])
+      );
+      stream = new Stream(
+        isBinary
+          ? decrypt(data, EEXEC_ENCRYPT_KEY, 4)
+          : decryptAscii(data, EEXEC_ENCRYPT_KEY, 4)
+      );
+    }
+    this.seacAnalysisEnabled = !!seacAnalysisEnabled;
+
+    this.stream = stream;
+    this.nextChar();
+  }
+
+  readNumberArray() {
+    this.getToken(); // read '[' or '{' (arrays can start with either)
+    const array = [];
+    while (true) {
+      const token = this.getToken();
+      if (token === null || token === "]" || token === "}") {
+        break;
+      }
+      array.push(parseFloat(token || 0));
+    }
+    return array;
+  }
+
+  readNumber() {
+    const token = this.getToken();
+    return parseFloat(token || 0);
+  }
+
+  readInt() {
+    // Use '| 0' to prevent setting a double into length such as the double
+    // does not flow into the loop variable.
+    const token = this.getToken();
+    return parseInt(token || 0, 10) | 0;
+  }
+
+  readBoolean() {
+    const token = this.getToken();
+    // Use 1 and 0 since that's what type2 charstrings use.
+    return token === "true" ? 1 : 0;
+  }
+
+  nextChar() {
+    return (this.currentChar = this.stream.getByte());
+  }
+
+  prevChar() {
+    this.stream.skip(-2);
+    return (this.currentChar = this.stream.getByte());
+  }
+
+  getToken() {
+    // Eat whitespace and comments.
+    let comment = false;
+    let ch = this.currentChar;
+    while (true) {
+      if (ch === -1) {
+        return null;
+      }
+
+      if (comment) {
+        if (ch === 0x0a || ch === 0x0d) {
+          comment = false;
+        }
+      } else if (ch === /* '%' = */ 0x25) {
+        comment = true;
+      } else if (!isWhiteSpace(ch)) {
+        break;
+      }
+      ch = this.nextChar();
+    }
+    if (isSpecial(ch)) {
+      this.nextChar();
+      return String.fromCharCode(ch);
+    }
+    let token = "";
+    do {
+      token += String.fromCharCode(ch);
+      ch = this.nextChar();
+    } while (ch >= 0 && !isWhiteSpace(ch) && !isSpecial(ch));
+    return token;
+  }
+
+  readCharStrings(bytes, lenIV) {
+    if (lenIV === -1) {
+      // This isn't in the spec, but Adobe's tx program handles -1
+      // as plain text.
+      return bytes;
+    }
+    return decrypt(bytes, CHAR_STRS_ENCRYPT_KEY, lenIV);
+  }
+
+  /*
+   * Returns an object containing a Subrs array and a CharStrings
+   * array extracted from and eexec encrypted block of data
+   */
+  extractFontProgram(properties) {
+    const stream = this.stream;
+
+    const subrs = [],
+      charstrings = [];
+    const privateData = Object.create(null);
+    privateData.lenIV = 4;
+    const program = {
+      subrs: [],
+      charstrings: [],
+      properties: {
+        privateData,
+      },
+    };
+    let token, length, data, lenIV;
+    while ((token = this.getToken()) !== null) {
+      if (token !== "/") {
+        continue;
+      }
+      token = this.getToken();
+      switch (token) {
+        case "CharStrings":
+          // The number immediately following CharStrings must be greater or
+          // equal to the number of CharStrings.
+          this.getToken();
+          this.getToken(); // read in 'dict'
+          this.getToken(); // read in 'dup'
+          this.getToken(); // read in 'begin'
+          while (true) {
+            token = this.getToken();
+            if (token === null || token === "end") {
+              break;
+            }
+
+            if (token !== "/") {
+              continue;
+            }
+            const glyph = this.getToken();
+            length = this.readInt();
+            this.getToken(); // read in 'RD' or '-|'
+            data = length > 0 ? stream.getBytes(length) : new Uint8Array(0);
+            lenIV = program.properties.privateData.lenIV;
+            const encoded = this.readCharStrings(data, lenIV);
+            this.nextChar();
+            token = this.getToken(); // read in 'ND' or '|-'
+            if (token === "noaccess") {
+              this.getToken(); // read in 'def'
+            } else if (token === "/") {
+              // The expected 'ND' or '|-' token is missing, avoid swallowing
+              // the start of the next glyph (fixes issue14462_reduced.pdf).
+              this.prevChar();
+            }
+            charstrings.push({
+              glyph,
+              encoded,
+            });
+          }
+          break;
+        case "Subrs":
+          this.readInt(); // num
+          this.getToken(); // read in 'array'
+          while (this.getToken() === "dup") {
+            const index = this.readInt();
+            length = this.readInt();
+            this.getToken(); // read in 'RD' or '-|'
+            data = length > 0 ? stream.getBytes(length) : new Uint8Array(0);
+            lenIV = program.properties.privateData.lenIV;
+            const encoded = this.readCharStrings(data, lenIV);
+            this.nextChar();
+            token = this.getToken(); // read in 'NP' or '|'
+            if (token === "noaccess") {
+              this.getToken(); // read in 'put'
+            }
+            subrs[index] = encoded;
+          }
+          break;
+        case "BlueValues":
+        case "OtherBlues":
+        case "FamilyBlues":
+        case "FamilyOtherBlues":
+          const blueArray = this.readNumberArray();
+          // *Blue* values may contain invalid data: disables reading of
+          // those values when hinting is disabled.
+          if (
+            blueArray.length > 0 &&
+            blueArray.length % 2 === 0 &&
+            HINTING_ENABLED
+          ) {
+            program.properties.privateData[token] = blueArray;
+          }
+          break;
+        case "StemSnapH":
+        case "StemSnapV":
+          program.properties.privateData[token] = this.readNumberArray();
+          break;
+        case "StdHW":
+        case "StdVW":
+          program.properties.privateData[token] = this.readNumberArray()[0];
+          break;
+        case "BlueShift":
+        case "lenIV":
+        case "BlueFuzz":
+        case "BlueScale":
+        case "LanguageGroup":
+          program.properties.privateData[token] = this.readNumber();
+          break;
+        case "ExpansionFactor":
+          // Firefox doesn't render correctly a font with a null factor on
+          // Windows (see issue 15289), hence we just reset it to its default
+          // value (0.06).
+          program.properties.privateData[token] = this.readNumber() || 0.06;
+          break;
+        case "ForceBold":
+          program.properties.privateData[token] = this.readBoolean();
+          break;
+      }
+    }
+
+    for (const { encoded, glyph } of charstrings) {
+      const charString = new Type1CharString();
+      const error = charString.convert(
+        encoded,
+        subrs,
+        this.seacAnalysisEnabled
+      );
+      let output = charString.output;
+      if (error) {
+        // It seems when FreeType encounters an error while evaluating a glyph
+        // that it completely ignores the glyph so we'll mimic that behaviour
+        // here and put an endchar to make the validator happy.
+        output = [14];
+      }
+      const charStringObject = {
+        glyphName: glyph,
+        charstring: output,
+        width: charString.width,
+        lsb: charString.lsb,
+        seac: charString.seac,
+      };
+      if (glyph === ".notdef") {
+        // Make sure .notdef is at index zero (issue #11477).
+        program.charstrings.unshift(charStringObject);
+      } else {
+        program.charstrings.push(charStringObject);
+      }
+
+      // Attempt to replace missing widths, from the font dictionary /Widths
+      // entry, with ones from the font data (fixes issue11150_reduced.pdf).
+      if (properties.builtInEncoding) {
+        const index = properties.builtInEncoding.indexOf(glyph);
+        if (
+          index > -1 &&
+          properties.widths[index] === undefined &&
+          index >= properties.firstChar &&
+          index <= properties.lastChar
+        ) {
+          properties.widths[index] = charString.width;
+        }
+      }
+    }
+
+    return program;
+  }
+
+  extractFontHeader(properties) {
+    let token;
+    while ((token = this.getToken()) !== null) {
+      if (token !== "/") {
+        continue;
+      }
+      token = this.getToken();
+      switch (token) {
+        case "FontMatrix":
+          const matrix = this.readNumberArray();
+          properties.fontMatrix = matrix;
+          break;
+        case "Encoding":
+          const encodingArg = this.getToken();
+          let encoding;
+          if (!/^\d+$/.test(encodingArg)) {
+            // encoding name is specified
+            encoding = getEncoding(encodingArg);
+          } else {
+            encoding = [];
+            const size = parseInt(encodingArg, 10) | 0;
+            this.getToken(); // read in 'array'
+
+            for (let j = 0; j < size; j++) {
+              token = this.getToken();
+              // skipping till first dup or def (e.g. ignoring for statement)
+              while (token !== "dup" && token !== "def") {
+                token = this.getToken();
+                if (token === null) {
+                  return; // invalid header
+                }
+              }
+              if (token === "def") {
+                break; // read all array data
+              }
+              const index = this.readInt();
+              this.getToken(); // read in '/'
+              const glyph = this.getToken();
+              encoding[index] = glyph;
+              this.getToken(); // read the in 'put'
+            }
+          }
+          properties.builtInEncoding = encoding;
+          break;
+        case "FontBBox":
+          const fontBBox = this.readNumberArray();
+          // adjusting ascent/descent
+          properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
+          properties.descent = Math.min(fontBBox[1], fontBBox[3]);
+          properties.ascentScaled = true;
+          break;
+      }
+    }
+  }
+}
+
+export { Type1Parser };
diff --git a/src/plugins/pdfjs/shared/util.js b/src/plugins/pdfjs/shared/util.js
new file mode 100644
index 00000000..926abc29
--- /dev/null
+++ b/src/plugins/pdfjs/shared/util.js
@@ -0,0 +1,75 @@
+/* Copyright 2012 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* globals process */
+
+const VerbosityLevel = {
+  ERRORS: 0,
+  WARNINGS: 1,
+  INFOS: 5,
+};
+
+const verbosity = VerbosityLevel.WARNINGS;
+
+// Non-fatal warnings.
+function warn(msg) {
+  if (verbosity >= VerbosityLevel.WARNINGS) {
+    console.log(`Warning: ${msg}`);
+  }
+}
+
+function unreachable(msg) {
+  throw new Error(msg);
+}
+
+function shadow(obj, prop, value, nonSerializable = false) {
+  if (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) {
+    assert(
+      prop in obj,
+      `shadow: Property "${prop && prop.toString()}" not found in object.`
+    );
+  }
+  Object.defineProperty(obj, prop, {
+    value,
+    enumerable: !nonSerializable,
+    configurable: true,
+    writable: false,
+  });
+  return value;
+}
+
+function bytesToString(bytes) {
+  if (typeof bytes !== "object" || bytes && bytes.length === undefined) {
+    unreachable("Invalid argument for bytesToString");
+  }
+  const length = bytes.length;
+  const MAX_ARGUMENT_COUNT = 8192;
+  if (length < MAX_ARGUMENT_COUNT) {
+    return String.fromCharCode.apply(null, bytes);
+  }
+  const strBuf = [];
+  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
+    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
+    const chunk = bytes.subarray(i, chunkEnd);
+    strBuf.push(String.fromCharCode.apply(null, chunk));
+  }
+  return strBuf.join("");
+}
+
+export {
+  bytesToString,
+  shadow,
+  unreachable,
+  warn,
+};
diff --git a/src/tables/cff.js b/src/tables/cff.js
index e930055f..06b04a4d 100755
--- a/src/tables/cff.js
+++ b/src/tables/cff.js
@@ -1203,7 +1203,7 @@ function parseCFFFDSelect(data, start, nGlyphs, fdArrayCount, version) {
             first = next;
         }
         if (next !== nGlyphs) {
-            throw new Error('CFF Table CID Font FDSelect format 3 range has bad final (Sentinal) GID ' + next);
+            console.warn('CFF Table CID Font FDSelect format 3 range has bad final (Sentinal) GID ' + next);
         }
     } else {
         throw new Error('CFF Table CID Font FDSelect table has unsupported format ' + format);
@@ -1302,7 +1302,7 @@ function parseCFFTable(data, start, font, opt) {
     let charStringsIndex;
     if (opt.lowMemory) {
         charStringsIndex = parseCFFIndexLowMemory(data, start + topDict.charStrings, header.formatMajor);
-        font.nGlyphs = charStringsIndex.offsets.length - (header.formatMajor > 1 ? 1 : 0); // number of elements is count + 1
+        font.nGlyphs = charStringsIndex.offsets.length - 1; // number of elements is count + 1
     } else {
         charStringsIndex = parseCFFIndex(data, start + topDict.charStrings, null, header.formatMajor);
         font.nGlyphs = charStringsIndex.objects.length;
@@ -1651,5 +1651,5 @@ function makeCFFTable(glyphs, options) {
     return t;
 }
 
-export default { parse: parseCFFTable, make: makeCFFTable };
-export { applyPaintType };
+export default { parse: parseCFFTable, make: makeCFFTable, applyPaintType, parseCFFCharstring, calcCFFSubroutineBias };
+export { applyPaintType, parseCFFCharstring, calcCFFSubroutineBias };
diff --git a/src/tiny-inflate@1.0.3.esm.js b/src/tiny-inflate@1.0.3.esm.js
index 371165a1..357e1103 100644
--- a/src/tiny-inflate@1.0.3.esm.js
+++ b/src/tiny-inflate@1.0.3.esm.js
@@ -1,4 +1,6 @@
-/*
+/*!
+tiny-inflate
+https://github.com/foliojs/tiny-inflate
 MIT License
 
 Copyright (c) 2015-present Devon Govett
@@ -20,7 +22,6 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
 */
 var TINF_OK = 0;
 var TINF_DATA_ERROR = -3;
diff --git a/src/variationprocessor.js b/src/variationprocessor.js
index f823d3d8..e9d98b9a 100644
--- a/src/variationprocessor.js
+++ b/src/variationprocessor.js
@@ -2,7 +2,7 @@ import { getPath, transformPoints } from './tables/glyf.js';
 import { copyPoint, copyComponent } from './util.js';
 import Glyph from './glyph.js';
 
-/**
+/*!
  * Part of the code of this class was based on
  * https://github.com/foliojs/fontkit/blob/a5fe0a1834241dbc6eb02beea3b7414c118c5ac9/src/glyph/GlyphVariationProcessor.js
  * Copyright (c) 2014 Devon Govett
diff --git a/test/fonts/Vibur.pfa b/test/fonts/Vibur.pfa
new file mode 100644
index 00000000..592514d6
--- /dev/null
+++ b/test/fonts/Vibur.pfa
@@ -0,0 +1,1741 @@
+%!PS-AdobeFont-1.0: Vibur 1.004
+%%Title: Vibur
+%Version: 1.004
+%%EndComments
+
+10 dict begin
+/FontType 1 def
+/FontMatrix [0.000488281 0 0 0.000488281 0 0 ]readonly def
+/FontName /Vibur def
+/FontBBox {-1437 -792 2210 1960 }readonly def
+/PaintType 0 def
+/FontInfo 7 dict dup begin
+ /version (1.004) readonly def
+ /FullName (Vibur) readonly def
+ /FamilyName (Vibur) readonly def
+ /Weight (Book) readonly def
+ /FSType 0 def
+ /ItalicAngle 0 def
+ /isFixedPitch false def
+end readonly def
+/Encoding 256 array
+ 0 1 255 { 1 index exch /.notdef put} for
+dup 32/space put
+dup 33/exclam put
+dup 34/quotedbl put
+dup 35/numbersign put
+dup 36/dollar put
+dup 37/percent put
+dup 38/ampersand put
+dup 39/quotesingle put
+dup 40/parenleft put
+dup 41/parenright put
+dup 42/asterisk put
+dup 43/plus put
+dup 44/comma put
+dup 45/hyphen put
+dup 46/period put
+dup 47/slash put
+dup 48/zero put
+dup 49/one put
+dup 50/two put
+dup 51/three put
+dup 52/four put
+dup 53/five put
+dup 54/six put
+dup 55/seven put
+dup 56/eight put
+dup 57/nine put
+dup 58/colon put
+dup 59/semicolon put
+dup 60/less put
+dup 61/equal put
+dup 62/greater put
+dup 63/question put
+dup 64/at put
+dup 65/A put
+dup 66/B put
+dup 67/C put
+dup 68/D put
+dup 69/E put
+dup 70/F put
+dup 71/G put
+dup 72/H put
+dup 73/I put
+dup 74/J put
+dup 75/K put
+dup 76/L put
+dup 77/M put
+dup 78/N put
+dup 79/O put
+dup 80/P put
+dup 81/Q put
+dup 82/R put
+dup 83/S put
+dup 84/T put
+dup 85/U put
+dup 86/V put
+dup 87/W put
+dup 88/X put
+dup 89/Y put
+dup 90/Z put
+dup 91/bracketleft put
+dup 92/backslash put
+dup 93/bracketright put
+dup 94/asciicircum put
+dup 95/underscore put
+dup 96/grave put
+dup 97/a put
+dup 98/b put
+dup 99/c put
+dup 100/d put
+dup 101/e put
+dup 102/f put
+dup 103/g put
+dup 104/h put
+dup 105/i put
+dup 106/j put
+dup 107/k put
+dup 108/l put
+dup 109/m put
+dup 110/n put
+dup 111/o put
+dup 112/p put
+dup 113/q put
+dup 114/r put
+dup 115/s put
+dup 116/t put
+dup 117/u put
+dup 118/v put
+dup 119/w put
+dup 120/x put
+dup 121/y put
+dup 122/z put
+dup 123/braceleft put
+dup 124/bar put
+dup 125/braceright put
+dup 126/asciitilde put
+dup 160/nbspace put
+dup 161/exclamdown put
+dup 162/cent put
+dup 163/sterling put
+dup 164/currency put
+dup 165/yen put
+dup 166/brokenbar put
+dup 167/section put
+dup 168/dieresis put
+dup 169/copyright put
+dup 170/ordfeminine put
+dup 171/guillemotleft put
+dup 172/logicalnot put
+dup 174/registered put
+dup 175/macron put
+dup 176/degree put
+dup 177/plusminus put
+dup 178/twosuperior put
+dup 179/threesuperior put
+dup 180/acute put
+dup 181/mu put
+dup 182/paragraph put
+dup 183/middot put
+dup 184/cedilla put
+dup 185/onesuperior put
+dup 186/ordmasculine put
+dup 187/guillemotright put
+dup 188/onequarter put
+dup 189/onehalf put
+dup 190/threequarters put
+dup 191/questiondown put
+dup 192/Agrave put
+dup 193/Aacute put
+dup 194/Acircumflex put
+dup 195/Atilde put
+dup 196/Adieresis put
+dup 197/Aring put
+dup 198/AE put
+dup 199/Ccedilla put
+dup 200/Egrave put
+dup 201/Eacute put
+dup 202/Ecircumflex put
+dup 203/Edieresis put
+dup 204/Igrave put
+dup 205/Iacute put
+dup 206/Icircumflex put
+dup 207/Idieresis put
+dup 208/Eth put
+dup 209/Ntilde put
+dup 210/Ograve put
+dup 211/Oacute put
+dup 212/Ocircumflex put
+dup 213/Otilde put
+dup 214/Odieresis put
+dup 215/multiply put
+dup 216/Oslash put
+dup 217/Ugrave put
+dup 218/Uacute put
+dup 219/Ucircumflex put
+dup 220/Udieresis put
+dup 221/Yacute put
+dup 222/Thorn put
+dup 223/germandbls put
+dup 224/agrave put
+dup 225/aacute put
+dup 226/acircumflex put
+dup 227/atilde put
+dup 228/adieresis put
+dup 229/aring put
+dup 230/ae put
+dup 231/ccedilla put
+dup 232/egrave put
+dup 233/eacute put
+dup 234/ecircumflex put
+dup 235/edieresis put
+dup 236/igrave put
+dup 237/iacute put
+dup 238/icircumflex put
+dup 239/idieresis put
+dup 240/eth put
+dup 241/ntilde put
+dup 242/ograve put
+dup 243/oacute put
+dup 244/ocircumflex put
+dup 245/otilde put
+dup 246/odieresis put
+dup 247/divide put
+dup 248/oslash put
+dup 249/ugrave put
+dup 250/uacute put
+dup 251/ucircumflex put
+dup 252/udieresis put
+dup 253/yacute put
+dup 254/thorn put
+dup 255/ydieresis put
+readonly def
+currentdict end
+currentfile eexec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+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000000000000
+cleartomark
diff --git a/test/fonts/Vibur.pfb b/test/fonts/Vibur.pfb
new file mode 100644
index 00000000..61009aa0
Binary files /dev/null and b/test/fonts/Vibur.pfb differ
diff --git a/test/fonts/Vibur.ps b/test/fonts/Vibur.ps
new file mode 100644
index 00000000..371f323c
Binary files /dev/null and b/test/fonts/Vibur.ps differ
diff --git a/test/plugins.js b/test/plugins.js
new file mode 100644
index 00000000..d9eebb94
--- /dev/null
+++ b/test/plugins.js
@@ -0,0 +1,40 @@
+import assert from 'assert';
+import { unhex } from './testutil.js';
+import opentype, { parse } from '../src/opentype.js';
+import cff1filePlugin from '../src/plugins/opentypejs.plugin.cff1file.js';
+import type1Plugin from '../src/plugins/opentypejs.plugin.type1.js';
+import { cff1data } from './tables/cff.js';
+import { readFileSync } from 'fs';
+const loadSync = (url, opt) => parse(readFileSync(url), opt);
+
+describe('plugins.js', function() {
+    describe(' opentypejs.plugin.cff1file.js', function() {
+        it('parses a standalone CFF1 file', function() {
+            assert.throws(() => {
+                parse(unhex(cff1data).buffer);
+            }, 'Font doesn\'t contain TrueType, CFF or CFF2 outlines');
+            
+            opentype.plugins.push(cff1filePlugin);
+            const font = parse(unhex(cff1data).buffer);
+
+            assert.equal(font.tables.cff.topDict.familyName, 'fn');
+            assert.deepEqual(font.glyphs.glyphs[1].name, 'bumps');
+        });
+    });
+
+    describe('opentypejs.plugin.type1.js', function() {
+        const extensions = ['ps','pfa','pfb'];
+        for(const ext of extensions) {
+            it(`parses a .${ext} file`, function() {
+                opentype.plugins.push(type1Plugin);
+                const font = loadSync(`./test/fonts/Vibur.${ext}`);
+                assert.equal(font.names.windows.fullName.en, 'Vibur');
+                assert.equal(Object.keys(font._hmtxTableData).length, 249);
+                assert.deepEqual(font.tables.cff.topDict.fontBBox, [-1437, -792, 2210, 1960]);
+                assert.deepEqual(font.tables.head, {xMin: -792, xMax: 1960, yMin: -792, yMax: 2210});
+                assert.deepEqual(font.tables.hhea, {descender: -792, ascender: 2210});
+                opentype.plugins.length = 0;
+            });
+        }
+    });
+});
\ No newline at end of file
diff --git a/test/tables/cff.js b/test/tables/cff.js
index 642b2231..314cdf9e 100644
--- a/test/tables/cff.js
+++ b/test/tables/cff.js
@@ -8,16 +8,17 @@ import { parse } from '../../src/opentype.js';
 import { readFileSync } from 'fs';
 const loadSync = (url, opt) => parse(readFileSync(url), opt);
 
+export const cff1data =
+    '01 00 04 01 00 01 01 01 03 70 73 00 01 01 01 32 ' +
+    'F8 1B 00 F8 1C 02 F8 1C 03 F8 1D 04 1D 00 00 00 ' +
+    '55 0F 1D 00 00 00 58 11 8B 1D 00 00 00 80 12 1E ' +
+    '0A 12 5F 1E 0F 1E 0F 1E 0A 12 5F 1E 0F 1E 0F 0C ' +
+    '07 00 04 01 01 02 04 06 0B 30 66 6E 77 6E 62 75 ' +
+    '6D 70 73 00 00 00 01 8A 00 02 01 01 03 23 9B 0E ' +
+    '9B 8B 8B 15 8C 8D 8B 8B 8C 89 08 89 8B 15 8C 8D ' +
+    '8B 8B 8C 89 08 89 8B 15 8C 8D 8B 8B 8C 89 08 0E';
+
 describe('tables/cff.js', function () {
-    const data =
-        '01 00 04 01 00 01 01 01 03 70 73 00 01 01 01 32 ' +
-        'F8 1B 00 F8 1C 02 F8 1C 03 F8 1D 04 1D 00 00 00 ' +
-        '55 0F 1D 00 00 00 58 11 8B 1D 00 00 00 80 12 1E ' +
-        '0A 12 5F 1E 0F 1E 0F 1E 0A 12 5F 1E 0F 1E 0F 0C ' +
-        '07 00 04 01 01 02 04 06 0B 30 66 6E 77 6E 62 75 ' +
-        '6D 70 73 00 00 00 01 8A 00 02 01 01 03 23 9B 0E ' +
-        '9B 8B 8B 15 8C 8D 8B 8B 8C 89 08 89 8B 15 8C 8D ' +
-        '8B 8B 8C 89 08 89 8B 15 8C 8D 8B 8B 8C 89 08 0E';
 
     it('can make a cff tag table', function () {
         const options = {
@@ -41,7 +42,7 @@ describe('tables/cff.js', function () {
         const glyphSetFont = { unitsPerEm: 8 };
         const glyphs = new glyphset.GlyphSet(glyphSetFont, [nodefGlyph, bumpsGlyph]);
 
-        assert.deepEqual(data, hex(cff.make(glyphs, options).encode()));
+        assert.deepEqual(cff1data, hex(cff.make(glyphs, options).encode()));
     });
 
     /**
@@ -49,7 +50,7 @@ describe('tables/cff.js', function () {
      */
     it('can fall back to CIDs instead of strings when parsing the charset', function () {
         const font = loadSync('./test/fonts/FiraSansOT-Medium.otf', { lowMemory: true });
-        assert.equal((new Set(font.cffEncoding.charset)).size, 1509);
+        assert.equal((new Set(font.cffEncoding.charset)).size, 1151);
         assert.equal(font.cffEncoding.charset.includes(undefined), false);
     });