decocms 4.113.3 → 4.113.4

package/dist/server/node_modules/@shuding/opentype.js/src/tables/cff.js

@@ -0,0 +1,1156 @@
+// The `CFF` table contains the glyph outlines in PostScript format.
+// https://www.microsoft.com/typography/OTSPEC/cff.htm
+// http://download.microsoft.com/download/8/0/1/801a191c-029d-4af3-9642-555f6fe514ee/cff.pdf
+// http://download.microsoft.com/download/8/0/1/801a191c-029d-4af3-9642-555f6fe514ee/type2.pdf
+
+import {
+    CffEncoding,
+    cffStandardEncoding,
+    cffExpertEncoding,
+    cffStandardStrings,
+} from '../encoding';
+import glyphset from '../glyphset';
+import parse from '../parse';
+import Path from '../path';
+
+// Subroutines are encoded using the negative half of the number space.
+// See type 2 chapter 4.7 "Subroutine operators".
+function calcCFFSubroutineBias(subrs) {
+    let bias;
+    if (subrs.length < 1240) {
+        bias = 107;
+    } else if (subrs.length < 33900) {
+        bias = 1131;
+    } else {
+        bias = 32768;
+    }
+
+    return bias;
+}
+
+// Parse a `CFF` INDEX array.
+// An index array consists of a list of offsets, then a list of objects at those offsets.
+function parseCFFIndex(data, start, conversionFn) {
+    const offsets = [];
+    const objects = [];
+    const count = parse.getCard16(data, start);
+    let objectOffset;
+    let endOffset;
+    if (count !== 0) {
+        const offsetSize = parse.getByte(data, start + 2);
+        objectOffset = start + (count + 1) * offsetSize + 2;
+        let pos = start + 3;
+        for (let i = 0; i < count + 1; i += 1) {
+            offsets.push(parse.getOffset(data, pos, offsetSize));
+            pos += offsetSize;
+        }
+
+        // The total size of the index array is 4 header bytes + the value of the last offset.
+        endOffset = objectOffset + offsets[count];
+    } else {
+        endOffset = start + 2;
+    }
+
+    for (let i = 0; i < offsets.length - 1; i += 1) {
+        let value = parse.getBytes(
+            data,
+            objectOffset + offsets[i],
+            objectOffset + offsets[i + 1]
+        );
+        if (conversionFn) {
+            value = conversionFn(value);
+        }
+
+        objects.push(value);
+    }
+
+    return { objects: objects, startOffset: start, endOffset: endOffset };
+}
+
+function parseCFFIndexLowMemory(data, start) {
+    const offsets = [];
+    const count = parse.getCard16(data, start);
+    let objectOffset;
+    let endOffset;
+    if (count !== 0) {
+        const offsetSize = parse.getByte(data, start + 2);
+        objectOffset = start + (count + 1) * offsetSize + 2;
+        let pos = start + 3;
+        for (let i = 0; i < count + 1; i += 1) {
+            offsets.push(parse.getOffset(data, pos, offsetSize));
+            pos += offsetSize;
+        }
+
+        // The total size of the index array is 4 header bytes + the value of the last offset.
+        endOffset = objectOffset + offsets[count];
+    } else {
+        endOffset = start + 2;
+    }
+
+    return { offsets: offsets, startOffset: start, endOffset: endOffset };
+}
+function getCffIndexObject(i, offsets, data, start, conversionFn) {
+    const count = parse.getCard16(data, start);
+    let objectOffset = 0;
+    if (count !== 0) {
+        const offsetSize = parse.getByte(data, start + 2);
+        objectOffset = start + (count + 1) * offsetSize + 2;
+    }
+
+    let value = parse.getBytes(
+        data,
+        objectOffset + offsets[i],
+        objectOffset + offsets[i + 1]
+    );
+    if (conversionFn) {
+        value = conversionFn(value);
+    }
+    return value;
+}
+
+// Parse a `CFF` DICT real value.
+function parseFloatOperand(parser) {
+    let s = '';
+    const eof = 15;
+    const lookup = [
+        '0',
+        '1',
+        '2',
+        '3',
+        '4',
+        '5',
+        '6',
+        '7',
+        '8',
+        '9',
+        '.',
+        'E',
+        'E-',
+        null,
+        '-',
+    ];
+    while (true) {
+        const b = parser.parseByte();
+        const n1 = b >> 4;
+        const n2 = b & 15;
+
+        if (n1 === eof) {
+            break;
+        }
+
+        s += lookup[n1];
+
+        if (n2 === eof) {
+            break;
+        }
+
+        s += lookup[n2];
+    }
+
+    return parseFloat(s);
+}
+
+// Parse a `CFF` DICT operand.
+function parseOperand(parser, b0) {
+    let b1;
+    let b2;
+    let b3;
+    let b4;
+    if (b0 === 28) {
+        b1 = parser.parseByte();
+        b2 = parser.parseByte();
+        return (b1 << 8) | b2;
+    }
+
+    if (b0 === 29) {
+        b1 = parser.parseByte();
+        b2 = parser.parseByte();
+        b3 = parser.parseByte();
+        b4 = parser.parseByte();
+        return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
+    }
+
+    if (b0 === 30) {
+        return parseFloatOperand(parser);
+    }
+
+    if (b0 >= 32 && b0 <= 246) {
+        return b0 - 139;
+    }
+
+    if (b0 >= 247 && b0 <= 250) {
+        b1 = parser.parseByte();
+        return (b0 - 247) * 256 + b1 + 108;
+    }
+
+    if (b0 >= 251 && b0 <= 254) {
+        b1 = parser.parseByte();
+        return -(b0 - 251) * 256 - b1 - 108;
+    }
+
+    throw new Error('Invalid b0 ' + b0);
+}
+
+// Convert the entries returned by `parseDict` to a proper dictionary.
+// If a value is a list of one, it is unpacked.
+function entriesToObject(entries) {
+    const o = {};
+    for (let i = 0; i < entries.length; i += 1) {
+        const key = entries[i][0];
+        const values = entries[i][1];
+        let value;
+        if (values.length === 1) {
+            value = values[0];
+        } else {
+            value = values;
+        }
+
+        if (o.hasOwnProperty(key) && !isNaN(o[key])) {
+            throw new Error('Object ' + o + ' already has key ' + key);
+        }
+
+        o[key] = value;
+    }
+
+    return o;
+}
+
+// Parse a `CFF` DICT object.
+// A dictionary contains key-value pairs in a compact tokenized format.
+function parseCFFDict(data, start, size) {
+    start = start !== undefined ? start : 0;
+    const parser = new parse.Parser(data, start);
+    const entries = [];
+    let operands = [];
+    size = size !== undefined ? size : data.length;
+
+    while (parser.relativeOffset < size) {
+        let op = parser.parseByte();
+
+        // The first byte for each dict item distinguishes between operator (key) and operand (value).
+        // Values <= 21 are operators.
+        if (op <= 21) {
+            // Two-byte operators have an initial escape byte of 12.
+            if (op === 12) {
+                op = 1200 + parser.parseByte();
+            }
+
+            entries.push([op, operands]);
+            operands = [];
+        } else {
+            // Since the operands (values) come before the operators (keys), we store all operands in a list
+            // until we encounter an operator.
+            operands.push(parseOperand(parser, op));
+        }
+    }
+
+    return entriesToObject(entries);
+}
+
+// Given a String Index (SID), return the value of the string.
+// Strings below index 392 are standard CFF strings and are not encoded in the font.
+function getCFFString(strings, index) {
+    if (index <= 390) {
+        index = cffStandardStrings[index];
+    } else {
+        index = strings[index - 391];
+    }
+
+    return index;
+}
+
+// Interpret a dictionary and return a new dictionary with readable keys and values for missing entries.
+// This function takes `meta` which is a list of objects containing `operand`, `name` and `default`.
+function interpretDict(dict, meta, strings) {
+    const newDict = {};
+    let value;
+
+    // Because we also want to include missing values, we start out from the meta list
+    // and lookup values in the dict.
+    for (let i = 0; i < meta.length; i += 1) {
+        const m = meta[i];
+
+        if (Array.isArray(m.type)) {
+            const values = [];
+            values.length = m.type.length;
+            for (let j = 0; j < m.type.length; j++) {
+                value = dict[m.op] !== undefined ? dict[m.op][j] : undefined;
+                if (value === undefined) {
+                    value =
+                        m.value !== undefined && m.value[j] !== undefined
+                            ? m.value[j]
+                            : null;
+                }
+                if (m.type[j] === 'SID') {
+                    value = getCFFString(strings, value);
+                }
+                values[j] = value;
+            }
+            newDict[m.name] = values;
+        } else {
+            value = dict[m.op];
+            if (value === undefined) {
+                value = m.value !== undefined ? m.value : null;
+            }
+
+            if (m.type === 'SID') {
+                value = getCFFString(strings, value);
+            }
+            newDict[m.name] = value;
+        }
+    }
+
+    return newDict;
+}
+
+// Parse the CFF header.
+function parseCFFHeader(data, start) {
+    const header = {};
+    header.formatMajor = parse.getCard8(data, start);
+    header.formatMinor = parse.getCard8(data, start + 1);
+    header.size = parse.getCard8(data, start + 2);
+    header.offsetSize = parse.getCard8(data, start + 3);
+    header.startOffset = start;
+    header.endOffset = start + 4;
+    return header;
+}
+
+const TOP_DICT_META = [
+    { name: 'version', op: 0, type: 'SID' },
+    { name: 'notice', op: 1, type: 'SID' },
+    { name: 'copyright', op: 1200, type: 'SID' },
+    { name: 'fullName', op: 2, type: 'SID' },
+    { name: 'familyName', op: 3, type: 'SID' },
+    { name: 'weight', op: 4, type: 'SID' },
+    { name: 'isFixedPitch', op: 1201, type: 'number', value: 0 },
+    { name: 'italicAngle', op: 1202, type: 'number', value: 0 },
+    { name: 'underlinePosition', op: 1203, type: 'number', value: -100 },
+    { name: 'underlineThickness', op: 1204, type: 'number', value: 50 },
+    { name: 'paintType', op: 1205, type: 'number', value: 0 },
+    { name: 'charstringType', op: 1206, type: 'number', value: 2 },
+    {
+        name: 'fontMatrix',
+        op: 1207,
+        type: ['real', 'real', 'real', 'real', 'real', 'real'],
+        value: [0.001, 0, 0, 0.001, 0, 0],
+    },
+    { name: 'uniqueId', op: 13, type: 'number' },
+    {
+        name: 'fontBBox',
+        op: 5,
+        type: ['number', 'number', 'number', 'number'],
+        value: [0, 0, 0, 0],
+    },
+    { name: 'strokeWidth', op: 1208, type: 'number', value: 0 },
+    { name: 'xuid', op: 14, type: [], value: null },
+    { name: 'charset', op: 15, type: 'offset', value: 0 },
+    { name: 'encoding', op: 16, type: 'offset', value: 0 },
+    { name: 'charStrings', op: 17, type: 'offset', value: 0 },
+    { name: 'private', op: 18, type: ['number', 'offset'], value: [0, 0] },
+    { name: 'ros', op: 1230, type: ['SID', 'SID', 'number'] },
+    { name: 'cidFontVersion', op: 1231, type: 'number', value: 0 },
+    { name: 'cidFontRevision', op: 1232, type: 'number', value: 0 },
+    { name: 'cidFontType', op: 1233, type: 'number', value: 0 },
+    { name: 'cidCount', op: 1234, type: 'number', value: 8720 },
+    { name: 'uidBase', op: 1235, type: 'number' },
+    { name: 'fdArray', op: 1236, type: 'offset' },
+    { name: 'fdSelect', op: 1237, type: 'offset' },
+    { name: 'fontName', op: 1238, type: 'SID' },
+];
+
+const PRIVATE_DICT_META = [
+    { name: 'subrs', op: 19, type: 'offset', value: 0 },
+    { name: 'defaultWidthX', op: 20, type: 'number', value: 0 },
+    { name: 'nominalWidthX', op: 21, type: 'number', value: 0 },
+];
+
+// Parse the CFF top dictionary. A CFF table can contain multiple fonts, each with their own top dictionary.
+// The top dictionary contains the essential metadata for the font, together with the private dictionary.
+function parseCFFTopDict(data, strings) {
+    const dict = parseCFFDict(data, 0, data.byteLength);
+    return interpretDict(dict, TOP_DICT_META, strings);
+}
+
+// Parse the CFF private dictionary. We don't fully parse out all the values, only the ones we need.
+function parseCFFPrivateDict(data, start, size, strings) {
+    const dict = parseCFFDict(data, start, size);
+    return interpretDict(dict, PRIVATE_DICT_META, strings);
+}
+
+// Returns a list of "Top DICT"s found using an INDEX list.
+// Used to read both the usual high-level Top DICTs and also the FDArray
+// discovered inside CID-keyed fonts.  When a Top DICT has a reference to
+// a Private DICT that is read and saved into the Top DICT.
+//
+// In addition to the expected/optional values as outlined in TOP_DICT_META
+// the following values might be saved into the Top DICT.
+//
+//    _subrs []        array of local CFF subroutines from Private DICT
+//    _subrsBias       bias value computed from number of subroutines
+//                      (see calcCFFSubroutineBias() and parseCFFCharstring())
+//    _defaultWidthX   default widths for CFF characters
+//    _nominalWidthX   bias added to width embedded within glyph description
+//
+//    _privateDict     saved copy of parsed Private DICT from Top DICT
+function gatherCFFTopDicts(data, start, cffIndex, strings) {
+    const topDictArray = [];
+    for (let iTopDict = 0; iTopDict < cffIndex.length; iTopDict += 1) {
+        const topDictData = new DataView(
+            new Uint8Array(cffIndex[iTopDict]).buffer
+        );
+        const topDict = parseCFFTopDict(topDictData, strings);
+        topDict._subrs = [];
+        topDict._subrsBias = 0;
+        topDict._defaultWidthX = 0;
+        topDict._nominalWidthX = 0;
+        const privateSize = topDict.private[0];
+        const privateOffset = topDict.private[1];
+        if (privateSize !== 0 && privateOffset !== 0) {
+            const privateDict = parseCFFPrivateDict(
+                data,
+                privateOffset + start,
+                privateSize,
+                strings
+            );
+            topDict._defaultWidthX = privateDict.defaultWidthX;
+            topDict._nominalWidthX = privateDict.nominalWidthX;
+            if (privateDict.subrs !== 0) {
+                const subrOffset = privateOffset + privateDict.subrs;
+                const subrIndex = parseCFFIndex(data, subrOffset + start);
+                topDict._subrs = subrIndex.objects;
+                topDict._subrsBias = calcCFFSubroutineBias(topDict._subrs);
+            }
+            topDict._privateDict = privateDict;
+        }
+        topDictArray.push(topDict);
+    }
+    return topDictArray;
+}
+
+// Parse the CFF charset table, which contains internal names for all the glyphs.
+// This function will return a list of glyph names.
+// See Adobe TN #5176 chapter 13, "Charsets".
+function parseCFFCharset(data, start, nGlyphs, strings) {
+    let sid;
+    let count;
+    const parser = new parse.Parser(data, start);
+
+    // The .notdef glyph is not included, so subtract 1.
+    nGlyphs -= 1;
+    const charset = ['.notdef'];
+
+    const format = parser.parseCard8();
+    if (format === 0) {
+        for (let i = 0; i < nGlyphs; i += 1) {
+            sid = parser.parseSID();
+            charset.push(getCFFString(strings, sid));
+        }
+    } else if (format === 1) {
+        while (charset.length <= nGlyphs) {
+            sid = parser.parseSID();
+            count = parser.parseCard8();
+            for (let i = 0; i <= count; i += 1) {
+                charset.push(getCFFString(strings, sid));
+                sid += 1;
+            }
+        }
+    } else if (format === 2) {
+        while (charset.length <= nGlyphs) {
+            sid = parser.parseSID();
+            count = parser.parseCard16();
+            for (let i = 0; i <= count; i += 1) {
+                charset.push(getCFFString(strings, sid));
+                sid += 1;
+            }
+        }
+    } else {
+        throw new Error('Unknown charset format ' + format);
+    }
+
+    return charset;
+}
+
+// Parse the CFF encoding data. Only one encoding can be specified per font.
+// See Adobe TN #5176 chapter 12, "Encodings".
+function parseCFFEncoding(data, start, charset) {
+    let code;
+    const enc = {};
+    const parser = new parse.Parser(data, start);
+    const format = parser.parseCard8();
+    if (format === 0) {
+        const nCodes = parser.parseCard8();
+        for (let i = 0; i < nCodes; i += 1) {
+            code = parser.parseCard8();
+            enc[code] = i;
+        }
+    } else if (format === 1) {
+        const nRanges = parser.parseCard8();
+        code = 1;
+        for (let i = 0; i < nRanges; i += 1) {
+            const first = parser.parseCard8();
+            const nLeft = parser.parseCard8();
+            for (let j = first; j <= first + nLeft; j += 1) {
+                enc[j] = code;
+                code += 1;
+            }
+        }
+    } else {
+        throw new Error('Unknown encoding format ' + format);
+    }
+
+    return new CffEncoding(enc, charset);
+}
+
+// Take in charstring code and return a Glyph object.
+// The encoding is described in the Type 2 Charstring Format
+// https://www.microsoft.com/typography/OTSPEC/charstr2.htm
+function parseCFFCharstring(font, glyph, code) {
+    let c1x;
+    let c1y;
+    let c2x;
+    let c2y;
+    const p = new Path();
+    const stack = [];
+    let nStems = 0;
+    let haveWidth = false;
+    let open = false;
+    let x = 0;
+    let y = 0;
+    let subrs;
+    let subrsBias;
+    let defaultWidthX;
+    let nominalWidthX;
+    if (font.isCIDFont) {
+        const fdIndex = font.tables.cff.topDict._fdSelect[glyph.index];
+        const fdDict = font.tables.cff.topDict._fdArray[fdIndex];
+        subrs = fdDict._subrs;
+        subrsBias = fdDict._subrsBias;
+        defaultWidthX = fdDict._defaultWidthX;
+        nominalWidthX = fdDict._nominalWidthX;
+    } else {
+        subrs = font.tables.cff.topDict._subrs;
+        subrsBias = font.tables.cff.topDict._subrsBias;
+        defaultWidthX = font.tables.cff.topDict._defaultWidthX;
+        nominalWidthX = font.tables.cff.topDict._nominalWidthX;
+    }
+    let width = defaultWidthX;
+
+    function newContour(x, y) {
+        if (open) {
+            p.closePath();
+        }
+
+        p.moveTo(x, y);
+        open = true;
+    }
+
+    function parseStems() {
+        let hasWidthArg;
+
+        // The number of stem operators on the stack is always even.
+        // If the value is uneven, that means a width is specified.
+        hasWidthArg = stack.length % 2 !== 0;
+        if (hasWidthArg && !haveWidth) {
+            width = stack.shift() + nominalWidthX;
+        }
+
+        nStems += stack.length >> 1;
+        stack.length = 0;
+        haveWidth = true;
+    }
+
+    function parse(code) {
+        let b1;
+        let b2;
+        let b3;
+        let b4;
+        let codeIndex;
+        let subrCode;
+        let jpx;
+        let jpy;
+        let c3x;
+        let c3y;
+        let c4x;
+        let c4y;
+
+        let i = 0;
+        while (i < code.length) {
+            let v = code[i];
+            i += 1;
+            switch (v) {
+                case 1: // hstem
+                    parseStems();
+                    break;
+                case 3: // vstem
+                    parseStems();
+                    break;
+                case 4: // vmoveto
+                    if (stack.length > 1 && !haveWidth) {
+                        width = stack.shift() + nominalWidthX;
+                        haveWidth = true;
+                    }
+
+                    y += stack.pop();
+                    newContour(x, y);
+                    break;
+                case 5: // rlineto
+                    while (stack.length > 0) {
+                        x += stack.shift();
+                        y += stack.shift();
+                        p.lineTo(x, y);
+                    }
+
+                    break;
+                case 6: // hlineto
+                    while (stack.length > 0) {
+                        x += stack.shift();
+                        p.lineTo(x, y);
+                        if (stack.length === 0) {
+                            break;
+                        }
+
+                        y += stack.shift();
+                        p.lineTo(x, y);
+                    }
+
+                    break;
+                case 7: // vlineto
+                    while (stack.length > 0) {
+                        y += stack.shift();
+                        p.lineTo(x, y);
+                        if (stack.length === 0) {
+                            break;
+                        }
+
+                        x += stack.shift();
+                        p.lineTo(x, y);
+                    }
+
+                    break;
+                case 8: // rrcurveto
+                    while (stack.length > 0) {
+                        c1x = x + stack.shift();
+                        c1y = y + stack.shift();
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        x = c2x + stack.shift();
+                        y = c2y + stack.shift();
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    }
+
+                    break;
+                case 10: // callsubr
+                    codeIndex = stack.pop() + subrsBias;
+                    subrCode = subrs[codeIndex];
+                    if (subrCode) {
+                        parse(subrCode);
+                    }
+
+                    break;
+                case 11: // return
+                    return;
+                case 12: // flex operators
+                    v = code[i];
+                    i += 1;
+                    switch (v) {
+                        case 35: // flex
+                            // |- dx1 dy1 dx2 dy2 dx3 dy3 dx4 dy4 dx5 dy5 dx6 dy6 fd flex (12 35) |-
+                            c1x = x + stack.shift(); // dx1
+                            c1y = y + stack.shift(); // dy1
+                            c2x = c1x + stack.shift(); // dx2
+                            c2y = c1y + stack.shift(); // dy2
+                            jpx = c2x + stack.shift(); // dx3
+                            jpy = c2y + stack.shift(); // dy3
+                            c3x = jpx + stack.shift(); // dx4
+                            c3y = jpy + stack.shift(); // dy4
+                            c4x = c3x + stack.shift(); // dx5
+                            c4y = c3y + stack.shift(); // dy5
+                            x = c4x + stack.shift(); // dx6
+                            y = c4y + stack.shift(); // dy6
+                            stack.shift(); // flex depth
+                            p.curveTo(c1x, c1y, c2x, c2y, jpx, jpy);
+                            p.curveTo(c3x, c3y, c4x, c4y, x, y);
+                            break;
+                        case 34: // hflex
+                            // |- dx1 dx2 dy2 dx3 dx4 dx5 dx6 hflex (12 34) |-
+                            c1x = x + stack.shift(); // dx1
+                            c1y = y; // dy1
+                            c2x = c1x + stack.shift(); // dx2
+                            c2y = c1y + stack.shift(); // dy2
+                            jpx = c2x + stack.shift(); // dx3
+                            jpy = c2y; // dy3
+                            c3x = jpx + stack.shift(); // dx4
+                            c3y = c2y; // dy4
+                            c4x = c3x + stack.shift(); // dx5
+                            c4y = y; // dy5
+                            x = c4x + stack.shift(); // dx6
+                            p.curveTo(c1x, c1y, c2x, c2y, jpx, jpy);
+                            p.curveTo(c3x, c3y, c4x, c4y, x, y);
+                            break;
+                        case 36: // hflex1
+                            // |- dx1 dy1 dx2 dy2 dx3 dx4 dx5 dy5 dx6 hflex1 (12 36) |-
+                            c1x = x + stack.shift(); // dx1
+                            c1y = y + stack.shift(); // dy1
+                            c2x = c1x + stack.shift(); // dx2
+                            c2y = c1y + stack.shift(); // dy2
+                            jpx = c2x + stack.shift(); // dx3
+                            jpy = c2y; // dy3
+                            c3x = jpx + stack.shift(); // dx4
+                            c3y = c2y; // dy4
+                            c4x = c3x + stack.shift(); // dx5
+                            c4y = c3y + stack.shift(); // dy5
+                            x = c4x + stack.shift(); // dx6
+                            p.curveTo(c1x, c1y, c2x, c2y, jpx, jpy);
+                            p.curveTo(c3x, c3y, c4x, c4y, x, y);
+                            break;
+                        case 37: // flex1
+                            // |- dx1 dy1 dx2 dy2 dx3 dy3 dx4 dy4 dx5 dy5 d6 flex1 (12 37) |-
+                            c1x = x + stack.shift(); // dx1
+                            c1y = y + stack.shift(); // dy1
+                            c2x = c1x + stack.shift(); // dx2
+                            c2y = c1y + stack.shift(); // dy2
+                            jpx = c2x + stack.shift(); // dx3
+                            jpy = c2y + stack.shift(); // dy3
+                            c3x = jpx + stack.shift(); // dx4
+                            c3y = jpy + stack.shift(); // dy4
+                            c4x = c3x + stack.shift(); // dx5
+                            c4y = c3y + stack.shift(); // dy5
+                            if (Math.abs(c4x - x) > Math.abs(c4y - y)) {
+                                x = c4x + stack.shift();
+                            } else {
+                                y = c4y + stack.shift();
+                            }
+
+                            p.curveTo(c1x, c1y, c2x, c2y, jpx, jpy);
+                            p.curveTo(c3x, c3y, c4x, c4y, x, y);
+                            break;
+                        default:
+                            console.log(
+                                'Glyph ' +
+                                    glyph.index +
+                                    ': unknown operator ' +
+                                    1200 +
+                                    v
+                            );
+                            stack.length = 0;
+                    }
+                    break;
+                case 14: // endchar
+                    if (stack.length > 0 && !haveWidth) {
+                        width = stack.shift() + nominalWidthX;
+                        haveWidth = true;
+                    }
+
+                    if (open) {
+                        p.closePath();
+                        open = false;
+                    }
+
+                    break;
+                case 18: // hstemhm
+                    parseStems();
+                    break;
+                case 19: // hintmask
+                case 20: // cntrmask
+                    parseStems();
+                    i += (nStems + 7) >> 3;
+                    break;
+                case 21: // rmoveto
+                    if (stack.length > 2 && !haveWidth) {
+                        width = stack.shift() + nominalWidthX;
+                        haveWidth = true;
+                    }
+
+                    y += stack.pop();
+                    x += stack.pop();
+                    newContour(x, y);
+                    break;
+                case 22: // hmoveto
+                    if (stack.length > 1 && !haveWidth) {
+                        width = stack.shift() + nominalWidthX;
+                        haveWidth = true;
+                    }
+
+                    x += stack.pop();
+                    newContour(x, y);
+                    break;
+                case 23: // vstemhm
+                    parseStems();
+                    break;
+                case 24: // rcurveline
+                    while (stack.length > 2) {
+                        c1x = x + stack.shift();
+                        c1y = y + stack.shift();
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        x = c2x + stack.shift();
+                        y = c2y + stack.shift();
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    }
+
+                    x += stack.shift();
+                    y += stack.shift();
+                    p.lineTo(x, y);
+                    break;
+                case 25: // rlinecurve
+                    while (stack.length > 6) {
+                        x += stack.shift();
+                        y += stack.shift();
+                        p.lineTo(x, y);
+                    }
+
+                    c1x = x + stack.shift();
+                    c1y = y + stack.shift();
+                    c2x = c1x + stack.shift();
+                    c2y = c1y + stack.shift();
+                    x = c2x + stack.shift();
+                    y = c2y + stack.shift();
+                    p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    break;
+                case 26: // vvcurveto
+                    if (stack.length % 2) {
+                        x += stack.shift();
+                    }
+
+                    while (stack.length > 0) {
+                        c1x = x;
+                        c1y = y + stack.shift();
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        x = c2x;
+                        y = c2y + stack.shift();
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    }
+
+                    break;
+                case 27: // hhcurveto
+                    if (stack.length % 2) {
+                        y += stack.shift();
+                    }
+
+                    while (stack.length > 0) {
+                        c1x = x + stack.shift();
+                        c1y = y;
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        x = c2x + stack.shift();
+                        y = c2y;
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    }
+
+                    break;
+                case 28: // shortint
+                    b1 = code[i];
+                    b2 = code[i + 1];
+                    stack.push(((b1 << 24) | (b2 << 16)) >> 16);
+                    i += 2;
+                    break;
+                case 29: // callgsubr
+                    codeIndex = stack.pop() + font.gsubrsBias;
+                    subrCode = font.gsubrs[codeIndex];
+                    if (subrCode) {
+                        parse(subrCode);
+                    }
+
+                    break;
+                case 30: // vhcurveto
+                    while (stack.length > 0) {
+                        c1x = x;
+                        c1y = y + stack.shift();
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        x = c2x + stack.shift();
+                        y = c2y + (stack.length === 1 ? stack.shift() : 0);
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                        if (stack.length === 0) {
+                            break;
+                        }
+
+                        c1x = x + stack.shift();
+                        c1y = y;
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        y = c2y + stack.shift();
+                        x = c2x + (stack.length === 1 ? stack.shift() : 0);
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    }
+
+                    break;
+                case 31: // hvcurveto
+                    while (stack.length > 0) {
+                        c1x = x + stack.shift();
+                        c1y = y;
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        y = c2y + stack.shift();
+                        x = c2x + (stack.length === 1 ? stack.shift() : 0);
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                        if (stack.length === 0) {
+                            break;
+                        }
+
+                        c1x = x;
+                        c1y = y + stack.shift();
+                        c2x = c1x + stack.shift();
+                        c2y = c1y + stack.shift();
+                        x = c2x + stack.shift();
+                        y = c2y + (stack.length === 1 ? stack.shift() : 0);
+                        p.curveTo(c1x, c1y, c2x, c2y, x, y);
+                    }
+
+                    break;
+                default:
+                    if (v < 32) {
+                        console.log(
+                            'Glyph ' + glyph.index + ': unknown operator ' + v
+                        );
+                    } else if (v < 247) {
+                        stack.push(v - 139);
+                    } else if (v < 251) {
+                        b1 = code[i];
+                        i += 1;
+                        stack.push((v - 247) * 256 + b1 + 108);
+                    } else if (v < 255) {
+                        b1 = code[i];
+                        i += 1;
+                        stack.push(-(v - 251) * 256 - b1 - 108);
+                    } else {
+                        b1 = code[i];
+                        b2 = code[i + 1];
+                        b3 = code[i + 2];
+                        b4 = code[i + 3];
+                        i += 4;
+                        stack.push(
+                            ((b1 << 24) | (b2 << 16) | (b3 << 8) | b4) / 65536
+                        );
+                    }
+            }
+        }
+    }
+
+    parse(code);
+
+    glyph.advanceWidth = width;
+    return p;
+}
+
+function parseCFFFDSelect(data, start, nGlyphs, fdArrayCount) {
+    const fdSelect = [];
+    let fdIndex;
+    const parser = new parse.Parser(data, start);
+    const format = parser.parseCard8();
+    if (format === 0) {
+        // Simple list of nGlyphs elements
+        for (let iGid = 0; iGid < nGlyphs; iGid++) {
+            fdIndex = parser.parseCard8();
+            if (fdIndex >= fdArrayCount) {
+                throw new Error(
+                    'CFF table CID Font FDSelect has bad FD index value ' +
+                        fdIndex +
+                        ' (FD count ' +
+                        fdArrayCount +
+                        ')'
+                );
+            }
+            fdSelect.push(fdIndex);
+        }
+    } else if (format === 3) {
+        // Ranges
+        const nRanges = parser.parseCard16();
+        let first = parser.parseCard16();
+        if (first !== 0) {
+            throw new Error(
+                'CFF Table CID Font FDSelect format 3 range has bad initial GID ' +
+                    first
+            );
+        }
+        let next;
+        for (let iRange = 0; iRange < nRanges; iRange++) {
+            fdIndex = parser.parseCard8();
+            next = parser.parseCard16();
+            if (fdIndex >= fdArrayCount) {
+                throw new Error(
+                    'CFF table CID Font FDSelect has bad FD index value ' +
+                        fdIndex +
+                        ' (FD count ' +
+                        fdArrayCount +
+                        ')'
+                );
+            }
+            if (next > nGlyphs) {
+                throw new Error(
+                    'CFF Table CID Font FDSelect format 3 range has bad GID ' +
+                        next
+                );
+            }
+            for (; first < next; first++) {
+                fdSelect.push(fdIndex);
+            }
+            first = next;
+        }
+        if (next !== nGlyphs) {
+            throw new Error(
+                'CFF Table CID Font FDSelect format 3 range has bad final GID ' +
+                    next
+            );
+        }
+    } else {
+        throw new Error(
+            'CFF Table CID Font FDSelect table has unsupported format ' + format
+        );
+    }
+    return fdSelect;
+}
+
+// Parse the `CFF` table, which contains the glyph outlines in PostScript format.
+function parseCFFTable(data, start, font, opt) {
+    font.tables.cff = {};
+    const header = parseCFFHeader(data, start);
+    const nameIndex = parseCFFIndex(
+        data,
+        header.endOffset,
+        parse.bytesToString
+    );
+    const topDictIndex = parseCFFIndex(data, nameIndex.endOffset);
+    const stringIndex = parseCFFIndex(
+        data,
+        topDictIndex.endOffset,
+        parse.bytesToString
+    );
+    const globalSubrIndex = parseCFFIndex(data, stringIndex.endOffset);
+    font.gsubrs = globalSubrIndex.objects;
+    font.gsubrsBias = calcCFFSubroutineBias(font.gsubrs);
+
+    const topDictArray = gatherCFFTopDicts(
+        data,
+        start,
+        topDictIndex.objects,
+        stringIndex.objects
+    );
+    if (topDictArray.length !== 1) {
+        throw new Error(
+            "CFF table has too many fonts in 'FontSet' - count of fonts NameIndex.length = " +
+                topDictArray.length
+        );
+    }
+
+    const topDict = topDictArray[0];
+    font.tables.cff.topDict = topDict;
+
+    if (topDict._privateDict) {
+        font.defaultWidthX = topDict._privateDict.defaultWidthX;
+        font.nominalWidthX = topDict._privateDict.nominalWidthX;
+    }
+
+    if (topDict.ros[0] !== undefined && topDict.ros[1] !== undefined) {
+        font.isCIDFont = true;
+    }
+
+    if (font.isCIDFont) {
+        let fdArrayOffset = topDict.fdArray;
+        let fdSelectOffset = topDict.fdSelect;
+        if (fdArrayOffset === 0 || fdSelectOffset === 0) {
+            throw new Error(
+                'Font is marked as a CID font, but FDArray and/or FDSelect information is missing'
+            );
+        }
+        fdArrayOffset += start;
+        const fdArrayIndex = parseCFFIndex(data, fdArrayOffset);
+        const fdArray = gatherCFFTopDicts(
+            data,
+            start,
+            fdArrayIndex.objects,
+            stringIndex.objects
+        );
+        topDict._fdArray = fdArray;
+        fdSelectOffset += start;
+        topDict._fdSelect = parseCFFFDSelect(
+            data,
+            fdSelectOffset,
+            font.numGlyphs,
+            fdArray.length
+        );
+    }
+
+    const privateDictOffset = start + topDict.private[1];
+    const privateDict = parseCFFPrivateDict(
+        data,
+        privateDictOffset,
+        topDict.private[0],
+        stringIndex.objects
+    );
+    font.defaultWidthX = privateDict.defaultWidthX;
+    font.nominalWidthX = privateDict.nominalWidthX;
+
+    if (privateDict.subrs !== 0) {
+        const subrOffset = privateDictOffset + privateDict.subrs;
+        const subrIndex = parseCFFIndex(data, subrOffset);
+        font.subrs = subrIndex.objects;
+        font.subrsBias = calcCFFSubroutineBias(font.subrs);
+    } else {
+        font.subrs = [];
+        font.subrsBias = 0;
+    }
+
+    // Offsets in the top dict are relative to the beginning of the CFF data, so add the CFF start offset.
+    let charStringsIndex;
+    if (opt.lowMemory) {
+        charStringsIndex = parseCFFIndexLowMemory(
+            data,
+            start + topDict.charStrings
+        );
+        font.nGlyphs = charStringsIndex.offsets.length;
+    } else {
+        charStringsIndex = parseCFFIndex(data, start + topDict.charStrings);
+        font.nGlyphs = charStringsIndex.objects.length;
+    }
+
+    const charset = parseCFFCharset(
+        data,
+        start + topDict.charset,
+        font.nGlyphs,
+        stringIndex.objects
+    );
+    if (topDict.encoding === 0) {
+        // Standard encoding
+        font.cffEncoding = new CffEncoding(cffStandardEncoding, charset);
+    } else if (topDict.encoding === 1) {
+        // Expert encoding
+        font.cffEncoding = new CffEncoding(cffExpertEncoding, charset);
+    } else {
+        font.cffEncoding = parseCFFEncoding(
+            data,
+            start + topDict.encoding,
+            charset
+        );
+    }
+
+    // Prefer the CMAP encoding to the CFF encoding.
+    font.encoding = font.encoding || font.cffEncoding;
+
+    font.glyphs = new glyphset.GlyphSet(font);
+    if (opt.lowMemory) {
+        font._push = function (i) {
+            const charString = getCffIndexObject(
+                i,
+                charStringsIndex.offsets,
+                data,
+                start + topDict.charStrings
+            );
+            font.glyphs.push(
+                i,
+                glyphset.cffGlyphLoader(font, i, parseCFFCharstring, charString)
+            );
+        };
+    } else {
+        for (let i = 0; i < font.nGlyphs; i += 1) {
+            const charString = charStringsIndex.objects[i];
+            font.glyphs.push(
+                i,
+                glyphset.cffGlyphLoader(font, i, parseCFFCharstring, charString)
+            );
+        }
+    }
+}
+
+export default { parse: parseCFFTable };