decocms 4.113.3 → 4.114.0

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

@@ -0,0 +1,146 @@
+// The `GPOS` table contains kerning pairs, among other things.
+// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos
+
+import check from '../check';
+import { Parser } from '../parse';
+
+const subtableParsers = new Array(10); // subtableParsers[0] is unused
+
+// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-1-single-adjustment-positioning-subtable
+// this = Parser instance
+subtableParsers[1] = function parseLookup1() {
+    const start = this.offset + this.relativeOffset;
+    const posformat = this.parseUShort();
+    if (posformat === 1) {
+        return {
+            posFormat: 1,
+            coverage: this.parsePointer(Parser.coverage),
+            value: this.parseValueRecord(),
+        };
+    } else if (posformat === 2) {
+        return {
+            posFormat: 2,
+            coverage: this.parsePointer(Parser.coverage),
+            values: this.parseValueRecordList(),
+        };
+    }
+    check.assert(
+        false,
+        '0x' +
+            start.toString(16) +
+            ': GPOS lookup type 1 format must be 1 or 2.'
+    );
+};
+
+// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-2-pair-adjustment-positioning-subtable
+subtableParsers[2] = function parseLookup2() {
+    const start = this.offset + this.relativeOffset;
+    const posFormat = this.parseUShort();
+    check.assert(
+        posFormat === 1 || posFormat === 2,
+        '0x' +
+            start.toString(16) +
+            ': GPOS lookup type 2 format must be 1 or 2.'
+    );
+    const coverage = this.parsePointer(Parser.coverage);
+    const valueFormat1 = this.parseUShort();
+    const valueFormat2 = this.parseUShort();
+    if (posFormat === 1) {
+        // Adjustments for Glyph Pairs
+        return {
+            posFormat: posFormat,
+            coverage: coverage,
+            valueFormat1: valueFormat1,
+            valueFormat2: valueFormat2,
+            pairSets: this.parseList(
+                Parser.pointer(
+                    Parser.list(function () {
+                        return {
+                            // pairValueRecord
+                            secondGlyph: this.parseUShort(),
+                            value1: this.parseValueRecord(valueFormat1),
+                            value2: this.parseValueRecord(valueFormat2),
+                        };
+                    })
+                )
+            ),
+        };
+    } else if (posFormat === 2) {
+        const classDef1 = this.parsePointer(Parser.classDef);
+        const classDef2 = this.parsePointer(Parser.classDef);
+        const class1Count = this.parseUShort();
+        const class2Count = this.parseUShort();
+        return {
+            // Class Pair Adjustment
+            posFormat: posFormat,
+            coverage: coverage,
+            valueFormat1: valueFormat1,
+            valueFormat2: valueFormat2,
+            classDef1: classDef1,
+            classDef2: classDef2,
+            class1Count: class1Count,
+            class2Count: class2Count,
+            classRecords: this.parseList(
+                class1Count,
+                Parser.list(class2Count, function () {
+                    return {
+                        value1: this.parseValueRecord(valueFormat1),
+                        value2: this.parseValueRecord(valueFormat2),
+                    };
+                })
+            ),
+        };
+    }
+};
+
+subtableParsers[3] = function parseLookup3() {
+    return { error: 'GPOS Lookup 3 not supported' };
+};
+subtableParsers[4] = function parseLookup4() {
+    return { error: 'GPOS Lookup 4 not supported' };
+};
+subtableParsers[5] = function parseLookup5() {
+    return { error: 'GPOS Lookup 5 not supported' };
+};
+subtableParsers[6] = function parseLookup6() {
+    return { error: 'GPOS Lookup 6 not supported' };
+};
+subtableParsers[7] = function parseLookup7() {
+    return { error: 'GPOS Lookup 7 not supported' };
+};
+subtableParsers[8] = function parseLookup8() {
+    return { error: 'GPOS Lookup 8 not supported' };
+};
+subtableParsers[9] = function parseLookup9() {
+    return { error: 'GPOS Lookup 9 not supported' };
+};
+
+// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos
+function parseGposTable(data, start) {
+    start = start || 0;
+    const p = new Parser(data, start);
+    const tableVersion = p.parseVersion(1);
+    check.argument(
+        tableVersion === 1 || tableVersion === 1.1,
+        'Unsupported GPOS table version ' + tableVersion
+    );
+
+    if (tableVersion === 1) {
+        return {
+            version: tableVersion,
+            scripts: p.parseScriptList(),
+            features: p.parseFeatureList(),
+            lookups: p.parseLookupList(subtableParsers),
+        };
+    } else {
+        return {
+            version: tableVersion,
+            scripts: p.parseScriptList(),
+            features: p.parseFeatureList(),
+            lookups: p.parseLookupList(subtableParsers),
+            variations: p.parseFeatureVariationsList(),
+        };
+    }
+}
+
+export default { parse: parseGposTable };

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

@@ -0,0 +1,251 @@
+// The `GSUB` table contains ligatures, among other things.
+// https://www.microsoft.com/typography/OTSPEC/gsub.htm
+
+import check from '../check';
+import { Parser } from '../parse';
+
+const subtableParsers = new Array(9); // subtableParsers[0] is unused
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#SS
+subtableParsers[1] = function parseLookup1() {
+    const start = this.offset + this.relativeOffset;
+    const substFormat = this.parseUShort();
+    if (substFormat === 1) {
+        return {
+            substFormat: 1,
+            coverage: this.parsePointer(Parser.coverage),
+            deltaGlyphId: this.parseUShort(),
+        };
+    } else if (substFormat === 2) {
+        return {
+            substFormat: 2,
+            coverage: this.parsePointer(Parser.coverage),
+            substitute: this.parseOffset16List(),
+        };
+    }
+    check.assert(
+        false,
+        '0x' + start.toString(16) + ': lookup type 1 format must be 1 or 2.'
+    );
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#MS
+subtableParsers[2] = function parseLookup2() {
+    const substFormat = this.parseUShort();
+    check.argument(
+        substFormat === 1,
+        'GSUB Multiple Substitution Subtable identifier-format must be 1'
+    );
+    return {
+        substFormat: substFormat,
+        coverage: this.parsePointer(Parser.coverage),
+        sequences: this.parseListOfLists(),
+    };
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#AS
+subtableParsers[3] = function parseLookup3() {
+    const substFormat = this.parseUShort();
+    check.argument(
+        substFormat === 1,
+        'GSUB Alternate Substitution Subtable identifier-format must be 1'
+    );
+    return {
+        substFormat: substFormat,
+        coverage: this.parsePointer(Parser.coverage),
+        alternateSets: this.parseListOfLists(),
+    };
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#LS
+subtableParsers[4] = function parseLookup4() {
+    const substFormat = this.parseUShort();
+    check.argument(
+        substFormat === 1,
+        'GSUB ligature table identifier-format must be 1'
+    );
+    return {
+        substFormat: substFormat,
+        coverage: this.parsePointer(Parser.coverage),
+        ligatureSets: this.parseListOfLists(function () {
+            return {
+                ligGlyph: this.parseUShort(),
+                components: this.parseUShortList(this.parseUShort() - 1),
+            };
+        }),
+    };
+};
+
+const lookupRecordDesc = {
+    sequenceIndex: Parser.uShort,
+    lookupListIndex: Parser.uShort,
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#CSF
+subtableParsers[5] = function parseLookup5() {
+    const start = this.offset + this.relativeOffset;
+    const substFormat = this.parseUShort();
+
+    if (substFormat === 1) {
+        return {
+            substFormat: substFormat,
+            coverage: this.parsePointer(Parser.coverage),
+            ruleSets: this.parseListOfLists(function () {
+                const glyphCount = this.parseUShort();
+                const substCount = this.parseUShort();
+                return {
+                    input: this.parseUShortList(glyphCount - 1),
+                    lookupRecords: this.parseRecordList(
+                        substCount,
+                        lookupRecordDesc
+                    ),
+                };
+            }),
+        };
+    } else if (substFormat === 2) {
+        return {
+            substFormat: substFormat,
+            coverage: this.parsePointer(Parser.coverage),
+            classDef: this.parsePointer(Parser.classDef),
+            classSets: this.parseListOfLists(function () {
+                const glyphCount = this.parseUShort();
+                const substCount = this.parseUShort();
+                return {
+                    classes: this.parseUShortList(glyphCount - 1),
+                    lookupRecords: this.parseRecordList(
+                        substCount,
+                        lookupRecordDesc
+                    ),
+                };
+            }),
+        };
+    } else if (substFormat === 3) {
+        const glyphCount = this.parseUShort();
+        const substCount = this.parseUShort();
+        return {
+            substFormat: substFormat,
+            coverages: this.parseList(
+                glyphCount,
+                Parser.pointer(Parser.coverage)
+            ),
+            lookupRecords: this.parseRecordList(substCount, lookupRecordDesc),
+        };
+    }
+    check.assert(
+        false,
+        '0x' + start.toString(16) + ': lookup type 5 format must be 1, 2 or 3.'
+    );
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#CC
+subtableParsers[6] = function parseLookup6() {
+    const start = this.offset + this.relativeOffset;
+    const substFormat = this.parseUShort();
+    if (substFormat === 1) {
+        return {
+            substFormat: 1,
+            coverage: this.parsePointer(Parser.coverage),
+            chainRuleSets: this.parseListOfLists(function () {
+                return {
+                    backtrack: this.parseUShortList(),
+                    input: this.parseUShortList(this.parseShort() - 1),
+                    lookahead: this.parseUShortList(),
+                    lookupRecords: this.parseRecordList(lookupRecordDesc),
+                };
+            }),
+        };
+    } else if (substFormat === 2) {
+        return {
+            substFormat: 2,
+            coverage: this.parsePointer(Parser.coverage),
+            backtrackClassDef: this.parsePointer(Parser.classDef),
+            inputClassDef: this.parsePointer(Parser.classDef),
+            lookaheadClassDef: this.parsePointer(Parser.classDef),
+            chainClassSet: this.parseListOfLists(function () {
+                return {
+                    backtrack: this.parseUShortList(),
+                    input: this.parseUShortList(this.parseShort() - 1),
+                    lookahead: this.parseUShortList(),
+                    lookupRecords: this.parseRecordList(lookupRecordDesc),
+                };
+            }),
+        };
+    } else if (substFormat === 3) {
+        return {
+            substFormat: 3,
+            backtrackCoverage: this.parseList(Parser.pointer(Parser.coverage)),
+            inputCoverage: this.parseList(Parser.pointer(Parser.coverage)),
+            lookaheadCoverage: this.parseList(Parser.pointer(Parser.coverage)),
+            lookupRecords: this.parseRecordList(lookupRecordDesc),
+        };
+    }
+    check.assert(
+        false,
+        '0x' + start.toString(16) + ': lookup type 6 format must be 1, 2 or 3.'
+    );
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#ES
+subtableParsers[7] = function parseLookup7() {
+    // Extension Substitution subtable
+    const substFormat = this.parseUShort();
+    check.argument(
+        substFormat === 1,
+        'GSUB Extension Substitution subtable identifier-format must be 1'
+    );
+    const extensionLookupType = this.parseUShort();
+    const extensionParser = new Parser(
+        this.data,
+        this.offset + this.parseULong()
+    );
+    return {
+        substFormat: 1,
+        lookupType: extensionLookupType,
+        extension: subtableParsers[extensionLookupType].call(extensionParser),
+    };
+};
+
+// https://www.microsoft.com/typography/OTSPEC/GSUB.htm#RCCS
+subtableParsers[8] = function parseLookup8() {
+    const substFormat = this.parseUShort();
+    check.argument(
+        substFormat === 1,
+        'GSUB Reverse Chaining Contextual Single Substitution Subtable identifier-format must be 1'
+    );
+    return {
+        substFormat: substFormat,
+        coverage: this.parsePointer(Parser.coverage),
+        backtrackCoverage: this.parseList(Parser.pointer(Parser.coverage)),
+        lookaheadCoverage: this.parseList(Parser.pointer(Parser.coverage)),
+        substitutes: this.parseUShortList(),
+    };
+};
+
+// https://www.microsoft.com/typography/OTSPEC/gsub.htm
+function parseGsubTable(data, start) {
+    start = start || 0;
+    const p = new Parser(data, start);
+    const tableVersion = p.parseVersion(1);
+    check.argument(
+        tableVersion === 1 || tableVersion === 1.1,
+        'Unsupported GSUB table version.'
+    );
+    if (tableVersion === 1) {
+        return {
+            version: tableVersion,
+            scripts: p.parseScriptList(),
+            features: p.parseFeatureList(),
+            lookups: p.parseLookupList(subtableParsers),
+        };
+    } else {
+        return {
+            version: tableVersion,
+            scripts: p.parseScriptList(),
+            features: p.parseFeatureList(),
+            lookups: p.parseLookupList(subtableParsers),
+            variations: p.parseFeatureVariationsList(),
+        };
+    }
+}
+
+export default { parse: parseGsubTable };

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

@@ -0,0 +1,35 @@
+// The `head` table contains global information about the font.
+// https://www.microsoft.com/typography/OTSPEC/head.htm
+
+import check from '../check';
+import parse from '../parse';
+
+// Parse the header `head` table
+function parseHeadTable(data, start) {
+    const head = {};
+    const p = new parse.Parser(data, start);
+    head.version = p.parseVersion();
+    head.fontRevision = Math.round(p.parseFixed() * 1000) / 1000;
+    head.checkSumAdjustment = p.parseULong();
+    head.magicNumber = p.parseULong();
+    check.argument(
+        head.magicNumber === 0x5f0f3cf5,
+        'Font header has wrong magic number.'
+    );
+    head.flags = p.parseUShort();
+    head.unitsPerEm = p.parseUShort();
+    head.created = p.parseLongDateTime();
+    head.modified = p.parseLongDateTime();
+    head.xMin = p.parseShort();
+    head.yMin = p.parseShort();
+    head.xMax = p.parseShort();
+    head.yMax = p.parseShort();
+    head.macStyle = p.parseUShort();
+    head.lowestRecPPEM = p.parseUShort();
+    head.fontDirectionHint = p.parseShort();
+    head.indexToLocFormat = p.parseShort();
+    head.glyphDataFormat = p.parseShort();
+    return head;
+}
+
+export default { parse: parseHeadTable };

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

@@ -0,0 +1,27 @@
+// The `hhea` table contains information for horizontal layout.
+// https://www.microsoft.com/typography/OTSPEC/hhea.htm
+
+import parse from '../parse';
+
+// Parse the horizontal header `hhea` table
+function parseHheaTable(data, start) {
+    const hhea = {};
+    const p = new parse.Parser(data, start);
+    hhea.version = p.parseVersion();
+    hhea.ascender = p.parseShort();
+    hhea.descender = p.parseShort();
+    hhea.lineGap = p.parseShort();
+    hhea.advanceWidthMax = p.parseUShort();
+    hhea.minLeftSideBearing = p.parseShort();
+    hhea.minRightSideBearing = p.parseShort();
+    hhea.xMaxExtent = p.parseShort();
+    hhea.caretSlopeRise = p.parseShort();
+    hhea.caretSlopeRun = p.parseShort();
+    hhea.caretOffset = p.parseShort();
+    p.relativeOffset += 8;
+    hhea.metricDataFormat = p.parseShort();
+    hhea.numberOfHMetrics = p.parseUShort();
+    return hhea;
+}
+
+export default { parse: parseHheaTable };

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

@@ -0,0 +1,51 @@
+// The `hmtx` table contains the horizontal metrics for all glyphs.
+// https://www.microsoft.com/typography/OTSPEC/hmtx.htm
+
+import parse from '../parse';
+
+function parseHmtxTableAll(data, start, numMetrics, numGlyphs, glyphs) {
+    let advanceWidth;
+    let leftSideBearing;
+    const p = new parse.Parser(data, start);
+    for (let i = 0; i < numGlyphs; i += 1) {
+        // If the font is monospaced, only one entry is needed. This last entry applies to all subsequent glyphs.
+        if (i < numMetrics) {
+            advanceWidth = p.parseUShort();
+            leftSideBearing = p.parseShort();
+        }
+
+        const glyph = glyphs.get(i);
+        glyph.advanceWidth = advanceWidth;
+        glyph.leftSideBearing = leftSideBearing;
+    }
+}
+
+function parseHmtxTableOnLowMemory(font, data, start, numMetrics, numGlyphs) {
+    font._hmtxTableData = {};
+
+    let advanceWidth;
+    let leftSideBearing;
+    const p = new parse.Parser(data, start);
+    for (let i = 0; i < numGlyphs; i += 1) {
+        // If the font is monospaced, only one entry is needed. This last entry applies to all subsequent glyphs.
+        if (i < numMetrics) {
+            advanceWidth = p.parseUShort();
+            leftSideBearing = p.parseShort();
+        }
+
+        font._hmtxTableData[i] = {
+            advanceWidth: advanceWidth,
+            leftSideBearing: leftSideBearing,
+        };
+    }
+}
+
+// Parse the `hmtx` table, which contains the horizontal metrics for all glyphs.
+// This function augments the glyph array, adding the advanceWidth and leftSideBearing to each glyph.
+function parseHmtxTable(font, data, start, numMetrics, numGlyphs, glyphs, opt) {
+    if (opt.lowMemory)
+        parseHmtxTableOnLowMemory(font, data, start, numMetrics, numGlyphs);
+    else parseHmtxTableAll(data, start, numMetrics, numGlyphs, glyphs);
+}
+
+export default { parse: parseHmtxTable };

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

@@ -0,0 +1,69 @@
+// The `kern` table contains kerning pairs.
+// Note that some fonts use the GPOS OpenType layout table to specify kerning.
+// https://www.microsoft.com/typography/OTSPEC/kern.htm
+
+import check from '../check';
+import parse from '../parse';
+
+function parseWindowsKernTable(p) {
+    const pairs = {};
+    // Skip nTables.
+    p.skip('uShort');
+    const subtableVersion = p.parseUShort();
+    check.argument(subtableVersion === 0, 'Unsupported kern sub-table version.');
+    // Skip subtableLength, subtableCoverage
+    p.skip('uShort', 2);
+    const nPairs = p.parseUShort();
+    // Skip searchRange, entrySelector, rangeShift.
+    p.skip('uShort', 3);
+    for (let i = 0; i < nPairs; i += 1) {
+        const leftIndex = p.parseUShort();
+        const rightIndex = p.parseUShort();
+        const value = p.parseShort();
+        pairs[leftIndex + ',' + rightIndex] = value;
+    }
+    return pairs;
+}
+
+function parseMacKernTable(p) {
+    const pairs = {};
+    // The Mac kern table stores the version as a fixed (32 bits) but we only loaded the first 16 bits.
+    // Skip the rest.
+    p.skip('uShort');
+    const nTables = p.parseULong();
+    //check.argument(nTables === 1, 'Only 1 subtable is supported (got ' + nTables + ').');
+    if (nTables > 1) {
+        console.warn('Only the first kern subtable is supported.');
+    }
+    p.skip('uLong');
+    const coverage = p.parseUShort();
+    const subtableVersion = coverage & 0xFF;
+    p.skip('uShort');
+    if (subtableVersion === 0) {
+        const nPairs = p.parseUShort();
+        // Skip searchRange, entrySelector, rangeShift.
+        p.skip('uShort', 3);
+        for (let i = 0; i < nPairs; i += 1) {
+            const leftIndex = p.parseUShort();
+            const rightIndex = p.parseUShort();
+            const value = p.parseShort();
+            pairs[leftIndex + ',' + rightIndex] = value;
+        }
+    }
+    return pairs;
+}
+
+// Parse the `kern` table which contains kerning pairs.
+function parseKernTable(data, start) {
+    const p = new parse.Parser(data, start);
+    const tableVersion = p.parseUShort();
+    if (tableVersion === 0) {
+        return parseWindowsKernTable(p);
+    } else if (tableVersion === 1) {
+        return parseMacKernTable(p);
+    } else {
+        throw new Error('Unsupported kern table version (' + tableVersion + ').');
+    }
+}
+
+export default { parse: parseKernTable };

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

@@ -0,0 +1,31 @@
+// The `loca` table stores the offsets to the locations of the glyphs in the font.
+// https://www.microsoft.com/typography/OTSPEC/loca.htm
+
+import parse from '../parse';
+
+// Parse the `loca` table. This table stores the offsets to the locations of the glyphs in the font,
+// relative to the beginning of the glyphData table.
+// The number of glyphs stored in the `loca` table is specified in the `maxp` table (under numGlyphs)
+// The loca table has two versions: a short version where offsets are stored as uShorts, and a long
+// version where offsets are stored as uLongs. The `head` table specifies which version to use
+// (under indexToLocFormat).
+function parseLocaTable(data, start, numGlyphs, shortVersion) {
+    const p = new parse.Parser(data, start);
+    const parseFn = shortVersion ? p.parseUShort : p.parseULong;
+    // There is an extra entry after the last index element to compute the length of the last glyph.
+    // That's why we use numGlyphs + 1.
+    const glyphOffsets = [];
+    for (let i = 0; i < numGlyphs + 1; i += 1) {
+        let glyphOffset = parseFn.call(p);
+        if (shortVersion) {
+            // The short table version stores the actual offset divided by 2.
+            glyphOffset *= 2;
+        }
+
+        glyphOffsets.push(glyphOffset);
+    }
+
+    return glyphOffsets;
+}
+
+export default { parse: parseLocaTable };

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

@@ -0,0 +1,33 @@
+// The `ltag` table stores IETF BCP-47 language tags. It allows supporting
+// languages for which TrueType does not assign a numeric code.
+// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6ltag.html
+// http://www.w3.org/International/articles/language-tags/
+// http://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
+
+import check from '../check';
+import parse from '../parse';
+
+function parseLtagTable(data, start) {
+    const p = new parse.Parser(data, start);
+    const tableVersion = p.parseULong();
+    check.argument(tableVersion === 1, 'Unsupported ltag table version.');
+    // The 'ltag' specification does not define any flags; skip the field.
+    p.skip('uLong', 1);
+    const numTags = p.parseULong();
+
+    const tags = [];
+    for (let i = 0; i < numTags; i++) {
+        let tag = '';
+        const offset = start + p.parseUShort();
+        const length = p.parseUShort();
+        for (let j = offset; j < offset + length; ++j) {
+            tag += String.fromCharCode(data.getInt8(j));
+        }
+
+        tags.push(tag);
+    }
+
+    return tags;
+}
+
+export default { parse: parseLtagTable };

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

@@ -0,0 +1,32 @@
+// The `maxp` table establishes the memory requirements for the font.
+// We need it just to get the number of glyphs in the font.
+// https://www.microsoft.com/typography/OTSPEC/maxp.htm
+
+import parse from '../parse';
+
+// Parse the maximum profile `maxp` table.
+function parseMaxpTable(data, start) {
+    const maxp = {};
+    const p = new parse.Parser(data, start);
+    maxp.version = p.parseVersion();
+    maxp.numGlyphs = p.parseUShort();
+    if (maxp.version === 1.0) {
+        maxp.maxPoints = p.parseUShort();
+        maxp.maxContours = p.parseUShort();
+        maxp.maxCompositePoints = p.parseUShort();
+        maxp.maxCompositeContours = p.parseUShort();
+        maxp.maxZones = p.parseUShort();
+        maxp.maxTwilightPoints = p.parseUShort();
+        maxp.maxStorage = p.parseUShort();
+        maxp.maxFunctionDefs = p.parseUShort();
+        maxp.maxInstructionDefs = p.parseUShort();
+        maxp.maxStackElements = p.parseUShort();
+        maxp.maxSizeOfInstructions = p.parseUShort();
+        maxp.maxComponentElements = p.parseUShort();
+        maxp.maxComponentDepth = p.parseUShort();
+    }
+
+    return maxp;
+}
+
+export default { parse: parseMaxpTable };