From 5636e7ea48feb81f55ef187d4da70899c67004d9 Mon Sep 17 00:00:00 2001
From: Balearica <admin@scribeocr.com>
Date: Wed, 10 Jul 2024 02:17:16 -0700
Subject: [PATCH 1/4] Added wip kern support

---
 docs/index.html     |  22 +-
 src/opentype.mjs    |   8 +-
 src/tables/gpos.mjs | 533 ++++++++++++++++++++++++++++++++++++++++++++
 src/tables/sfnt.mjs |  12 +
 4 files changed, 572 insertions(+), 3 deletions(-)

diff --git a/docs/index.html b/docs/index.html
index bc99139d..3ee60af1 100755
--- a/docs/index.html
+++ b/docs/index.html
@@ -77,6 +77,7 @@ <h1>Free Software</h1>
 
 <script type="module">
 import * as opentype from "/dist/opentype.mjs";
+globalThis.opentype = opentype;
 
 const form = document.forms.demo;
 form.oninput = renderText;
@@ -203,11 +204,30 @@ <h1>Free Software</h1>
     el.innerHTML = message;
 }
 
+globalThis.downloadFont = async (font) => {
+    const fontArrayBuffer = font.toArrayBuffer();
+    const blob = new Blob([fontArrayBuffer], { type: 'font/otf' });
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(blob);
+    link.download = 'font.otf';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+};
+
+globalThis.calcKern = (font, letter1, letter2) => (font.getKerningValue(font.charToGlyph(letter1), font.charToGlyph(letter2)));
+
+
+
 function onFontLoaded(font) {
     if (window.font) {
         window.font.onGlyphUpdated = null
     }
     window.font = font;
+
+    window.fontArrayBuffer = font.toArrayBuffer();
+    window.font2 = opentype.parse(window.fontArrayBuffer);
+
     options = Object.assign({}, window.font.defaultRenderOptions);
     window.fontOptions = options;
     
@@ -279,7 +299,7 @@ <h1>Free Software</h1>
             error = err;
         }     
 
-        onFontLoaded(opentype.parse(isWoff2 ? Module.decompress(data) : data, { lowMemory: true }));
+        onFontLoaded(opentype.parse(isWoff2 ? Module.decompress(data) : data, { lowMemory: false }));
         if ( !error ) showErrorMessage('');
     } catch (err) {
         showErrorMessage(err.toString());
diff --git a/src/opentype.mjs b/src/opentype.mjs
index 7a3101e4..2bb68a54 100644
--- a/src/opentype.mjs
+++ b/src/opentype.mjs
@@ -310,8 +310,12 @@ function parseBuffer(buffer, opt={}) {
                 metaTableEntry = tableEntry;
                 break;
             case 'gasp':
-                table = uncompressTable(data, tableEntry);
-                font.tables.gasp = gasp.parse(table.data, table.offset);
+                try {
+                    table = uncompressTable(data, tableEntry);
+                    font.tables.gasp = gasp.parse(table.data, table.offset);
+                } catch (e) {
+                    console.warn('Error parsing gasp table:', e);
+                }
                 break;
             case 'SVG ':
                 table = uncompressTable(data, tableEntry);
diff --git a/src/tables/gpos.mjs b/src/tables/gpos.mjs
index 23f09789..7a6495aa 100644
--- a/src/tables/gpos.mjs
+++ b/src/tables/gpos.mjs
@@ -114,7 +114,338 @@ function parseGposTable(data, start) {
 // NOT SUPPORTED
 const subtableMakers = new Array(10);
 
+// subtableMakers[2] = function makeLookup2(subtable) {
+
+//     if (subtable.posFormat === 1) {
+
+//         const pairPosTableData = [
+//             {name: 'posFormat', type: 'USHORT', value: 1},
+//             {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
+//             {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
+//             {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
+//             // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
+//         ];
+
+        
+//         // let offsetN = 10 + 2 * (subtable.pairSets.length);
+//         // for (let i = 0; i < subtable.pairSets.length; i++) {
+//         //     result.fields.push({ name: 'pairSetOffsets', type: 'USHORT', value: offsetN });
+//         //     offsetN = offsetN + 2 + 4 * (kerningGlyphs2[i].length);
+//         // }
+
+//         const pairSets = [];
+
+    
+//         // Add PairSet tables (one for each first letter in a kerning pair)
+//         for (let i = 0; i < subtable.pairSets.length; i++) {
+//             const pairRecords = [];
+
+
+
+//             // result.fields.push({ name: 'pairValueCount', type: 'USHORT', value: kerningGlyphs2[i].length });mmemm
+//             for (let j = 0; j < subtable.pairSets[i].length; j++) {
+//                 pairRecords.push({ name: 'secondGlyph', type: 'USHORT', value: subtable.pairSets[i][j][0] });
+//                 pairRecords.push({ name: 'valueRecord1', type: 'USHORT', value: subtable.pairSets[i][j][1] });
+
+//                 // result.fields.push({ name: 'secondGlyph', type: 'USHORT', value: kerningGlyphs2[i][j][0] });
+//                 // result.fields.push({ name: 'valueRecord1', type: 'USHORT', value: kerningGlyphs2[i][j][1] });
+//                 // console.log("Kerning: " + kerningGlyphs2[i][j][0] + " " + kerningGlyphs2[i][j][1])
+//             }
+//             pairSets.push({ name: 'pairSet', type: 'TABLE', value: new table.Table('pairSet', pairRecords) });
+//         }
+
+//         pairPosTableData.push({ name: 'pairSets', type: 'TABLE', value: new table.Table('pairSets', pairSets) });
+
+//         const pairPosTable = new table.Table('pairPosFormat1', pairPosTableData);
+    
+
+//         return pairPosTable;
+//         // return lookupTable;
+    
+//     } else {
+//         check.assert(false, 'lookup type 2 format 2 is not yet supported.');
+//     }
+
+// };
+
+
+subtableMakers[2] = function makeLookup2(subtable) {
+
+    if (subtable.posFormat === 1) {
+
+        // const posTable = new table.Table('pairPosFormat1', [
+        //     {name: 'posFormat', type: 'USHORT', value: 1},
+        //     {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
+        //     {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
+        //     {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
+        //     // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
+        // ].concat(table.tableList('pairSets', subtable.pairSets, function(pairSet) {
+        //     return new table.Table('pairSetTable', [
+        //     ].concat(table.tableList('pairValue', pairSet, function(pairValue) {
+        //         const xAdvance = pairValue.value1 ? pairValue.value1.xAdvance : undefined;
+        //         const yAdvance = pairValue.value2 ? pairValue.value2.yAdvance : undefined;
+        //         return new table.Table('pairValueTable',
+        //             [{name: 'secondGlyph', type: 'USHORT', value: pairValue.secondGlyph }, 
+        //                 {name: 'value1', type: 'USHORT', value: xAdvance }]
+        //         );
+        //     })));
+        // })));
+
+
+        const posTable = new table.Table('pairPosFormat1', [
+            {name: 'posFormat', type: 'USHORT', value: 1},
+            {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
+            {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
+            {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
+            // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
+        ].concat(table.tableList('pairSets', subtable.pairSets, function(pairSet) {
+
+            const pairSetTable = new table.Table('pairSetTable', []);
+            pairSetTable.fields.push({name: 'pairValueCount', type: 'USHORT', value: pairSet.length });
+            for (let i = 0; i < pairSet.length; i++) {
+                const xAdvance = pairSet[i].value1 ? pairSet[i].value1.xAdvance : undefined;
+                const yAdvance = pairSet[i].value2 ? pairSet[i].value2.yAdvance : undefined;
+                pairSetTable.fields.push({name: 'secondGlyph', type: 'USHORT', value: pairSet[i].secondGlyph });
+                pairSetTable.fields.push({name: 'value1', type: 'USHORT', value: xAdvance });
+                // pairSetTable.fields.push({name: 'value2', type: 'USHORT', value: yAdvance });
+            }
+            return pairSetTable;
+        })));
+
+
+
+        debugger;
+        return posTable;
+
+
+        const pairSetTable = new table.Table('pairSetTable', []);
+        
+
+        // Offset #3
+        // Start of LookupList Table
+        // { name: 'lookupCount', type: 'USHORT', value: 1 },
+        // { name: 'lookupOffset', type: 'USHORT', value: 4 },
+        // // Start of Lookup table
+        // { name: 'lookupType', type: 'USHORT', value: 2 },
+        // { name: 'lookupFlag', type: 'USHORT', value: 0 },
+        // { name: 'subTableCount', type: 'USHORT', value: 1 },
+        // { name: 'lookupOffset2', type: 'USHORT', value: 8 },
+
+        // // Start of lookup subtable (actual kerning info)
+        // { name: 'posFormat', type: 'USHORT', value: 1 },
+        // { name: 'coverageOffset', type: 'USHORT', value: 10 + 4 * firstGlyphs.length + 4 * nPairs },
+        // // X_ADVANCE only
+        // { name: 'valueFormat1', type: 'USHORT', value: 4 },
+        // // Omit (note: using other formats will impact offset calculations)
+        // { name: 'valueFormat2', type: 'USHORT', value: 0 },
+        // // pairSetCount: Number of PairSet tables
+        // { name: 'pairSetCount', type: 'USHORT', value: firstGlyphs.length },
+        // //   {name: 'pairSetOffsets', type: 'USHORT', value: 22},
+
+
+
+        // let offsetN = 10 + 2 * (subtable.pairSets.length);
+        // for (let i = 0; i < subtable.pairSets.length; i++) {
+        //     pairSetTable.fields.push({ name: 'pairSetOffsets', type: 'USHORT', value: offsetN });
+        //     offsetN = offsetN + 2 + 4 * (subtable.pairSets[i].length);
+        // }
+    
+        // // Add PairSet tables (one for each first letter in a kerning pair)
+        // for (let i = 0; i < subtable.pairSets.length; i++) {
+        //     pairSetTable.fields.push({ name: 'pairValueCount', type: 'USHORT', value: subtable.pairSets[i].length });
+        //     for (let j = 0; j < subtable.pairSets[i].length; j++) {
+        //         pairSetTable.fields.push({ name: 'secondGlyph', type: 'USHORT', value: subtable.pairSets[i][j].secondGlyph });
+        //         const xAdvance = subtable.pairSets[i][j].value1 ? subtable.pairSets[i][j].value1.xAdvance : undefined;
+        //         pairSetTable.fields.push({ name: 'valueRecord1', type: 'USHORT', value: xAdvance });
+        //         // console.log("Kerning: " + kerningGlyphs2[i][j][0] + " " + kerningGlyphs2[i][j][1])
+        //     }
+        // }
+    
+        // const posTable = new table.Table('pairPosFormat1', [
+        //     {name: 'posFormat', type: 'USHORT', value: 1},
+        //     {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
+        //     {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
+        //     {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
+        //     {name: 'pairSet', type: 'TABLE', value: pairSetTable},
+        //     {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
+        // ]);
+
+        
+        
+        // .concat(table.tableList('pairSets', subtable.pairSets, function(pairSet) {
+
+        //     const pairValues = [{name: 'pairValueCount', type: 'USHORT', value: pairSet.length }];
+        //     for (let i = 0; i < pairSet.length; i++) {
+        //         const xAdvance = pairSet[i].value1 ? pairSet[i].value1.xAdvance : undefined;
+        //         const yAdvance = pairSet[i].value2 ? pairSet[i].value2.yAdvance : undefined;
+        //         pairValues.push({name: 'secondGlyph', type: 'USHORT', value: pairSet[i].secondGlyph });
+        //         pairValues.push({name: 'xAdvance', type: 'USHORT', value: xAdvance });
+        //     }
+
+        //     return new table.Table('pairValues', pairValues);
+        // })));
+
+
+        // subtableMakers[3] = function makeLookup3(subtable) {
+        //     check.assert(subtable.substFormat === 1, 'Lookup type 3 substFormat must be 1.');
+        //     return new table.Table('substitutionTable', [
+        //         {name: 'substFormat', type: 'USHORT', value: 1},
+        //         {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
+        //     ].concat(table.tableList('altSet', subtable.alternateSets, function(alternateSet) {
+        //         return new table.Table('alternateSetTable', table.ushortList('alternate', alternateSet));
+        //     })));
+        // };
+        
+
+        debugger;
+
+        return posTable;
+
+
+
+
+        const pairPosTableData = [
+            {name: 'posFormat', type: 'USHORT', value: 1},
+            {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
+            {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
+            {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
+            // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
+        ];
+
+        
+
+
+        pairPosTableData.push(...table.tableList('pairSet', subtable.pairSets, function(pairSet) {
+            const pairSetTableData = [
+                // {name: 'pairValueCount', type: 'USHORT', value: pairSet.length },
+            ];
+
+            pairSetTableData.push(...table.tableList('pairValue', pairSet, function(pairValue) {
+                const pairValueTableData = [
+                    {name: 'secondGlyph', type: 'USHORT', value: pairValue.secondGlyph },
+                ];
+                const xAdvance = pairValue.value1 ? pairValue.value1.xAdvance : undefined;
+                const yAdvance = pairValue.value2 ? pairValue.value2.yAdvance : undefined;
+                pairValueTableData.push({name: 'value1', type: 'USHORT', value: xAdvance });
+                // pairValueTableData.push({name: 'value2', type: 'USHORT', value: yAdvance });
+                return new table.Table('pairValue', pairValueTableData);
+            }));
+
+            return new table.Table('pairSet', pairSetTableData);
+        }));
+    
+        // for (let i = 0; i < subtable.pairSets.length; i++) {
+    
+        //     const pairSetTableData = [
+        //         {name: 'pairValueCount', type: 'USHORT', value: subtable.pairSets[i].length },
+        //     ];
+    
+        //     for (let j = 0; j < subtable.pairSets[i].length; j++) {
+        //         pairSetTableData.push({ name: 'secondGlyph', type: 'USHORT', value: subtable.pairSets[i][j].secondGlyph });
+        //         // if (subtable.pairSets[i][j].value1) pairSetTableData.push({ name: 'value1', type: 'USHORT', value: subtable.pairSets[i][j].value1.xAdvance });
+        //         // if (subtable.pairSets[i][j].value2) pairSetTableData.push({ name: 'value2', type: 'USHORT', value: subtable.pairSets[i][j].value1.yAdvance });
+
+        //         const xAdvance = subtable.pairSets[i][j].value1 ? subtable.pairSets[i][j].value1.xAdvance : undefined;
+        //         // const yAdvance = subtable.pairSets[i][j].value2 ? subtable.pairSets[i][j].value2.yAdvance : undefined;
+
+        //         pairSetTableData.push({ name: 'value1', type: 'USHORT', value: xAdvance });
+        //         // pairSetTableData.push({ name: 'value2', type: 'USHORT', value: yAdvance });
+
+        //     }
+    
+        //     // posTableData.push({ name: 'pairSet', type: 'TABLE', value: new table.Table('pairSet', pairSetTableData) });
+        //     lookupTable.push({ name: 'pairSet', type: 'TABLE', value: new table.Table('pairSet', pairSetTableData) });
+
+        // }
+
+        // return posTable;
+    
+        return new table.Table('pairPosFormat1', pairPosTableData);
+        // return lookupTable;
+    
+    } else {
+        check.assert(false, 'lookup type 2 format 2 is not yet supported.');
+    }
+
+};
+
+
+/**
+ * Subsets the `GPOS` table to only include tables that have been implemented (pair kerning using type 2 format 1 subtables).
+ * Once write support for all `GPOS` subtables is implemented, this function should be removed.
+ * 
+ * @param {*} gpos 
+ * @returns 
+ */
+function subsetGposImplemented(gpos) {
+    // Filter lookups to only pair kerning tables; make deep copy to avoid editing original.
+    const lookups0 = gpos.lookups.filter((x) => x.lookupType === 2).map((x) => JSON.parse(JSON.stringify(x)));
+    if (lookups0.length === 0) return;
+    // Filter pair kerning tables to only type 2 format 1 subtables.
+    const lookups = lookups0.map((x) => {
+        x.subtables = x.subtables.filter((y) => y.posFormat === 1);
+        return x;
+    }).filter((x) => x.subtables.length > 0);
+    if (lookups.length === 0) return;
+
+    // const kernTableIndex = gpos.lookups.findIndex((x) => x.lookupType === 2);
+    // if (kernTableIndex === -1) return;
+    // const kernTableCopy = JSON.parse(JSON.stringify(gpos.lookups[kernTableIndex]));
+    // kernTableCopy.subtables = kernTableCopy.subtables.filter((x) => x.posFormat === 1);
+    // if (kernTableCopy.subtables.length === 0) return;
+    // const lookups = [kernTableCopy];
+
+    const featureIndices = [];
+    for(let i = 0; i < gpos.features.length; i++)
+        if (gpos.features[i].tag === 'kern')
+            featureIndices.push(i);
+
+    const features = gpos.features.filter((x) => x.tag === 'kern').map((x) => JSON.parse(JSON.stringify(x)));
+    
+    // TODO: This always points to the first lookup table, which may not be correct.
+    for (let i = 0; i < features.length; i++) {
+        features[i].feature.lookupListIndexes = [0];
+    }
+
+
+    // const featureIndex = gpos.features.findIndex((x) => x.tag === 'kern');
+    // const featureTableCopy = JSON.parse(JSON.stringify(gpos.features[featureIndex]));
+    // featureTableCopy.feature.lookupListIndexes = [0];
+    // const features = [featureTableCopy];
+
+    
+
+    // const scripts = JSON.parse(JSON.stringify(gpos.scripts.filter((x) => x.script.defaultLangSys.featureIndexes.includes(featureIndex))));
+
+    const scripts = [];
+
+    for (let i = 0; i < gpos.scripts.length; i++) {
+        const scriptI = JSON.parse(JSON.stringify(gpos.scripts[i]));
+        scriptI.script.defaultLangSys.featureIndexes = scriptI.script.defaultLangSys.featureIndexes.filter((x) => featureIndices.includes(x));
+        if (scriptI.script.defaultLangSys.featureIndexes.length === 0) continue;
+        for (let j = 0; j < scriptI.script.langSysRecords.length; j++) {
+            scriptI.script.langSysRecords[j].featureIndexes = scriptI.script.langSysRecords[j].langSys.featureIndexes.filter((x) => featureIndices.includes(x));
+        }
+        scripts.push(scriptI);
+
+
+        // scripts[i].script.defaultLangSys.featureIndexes = [0];
+        // for (let j = 0; j < scripts[i].script.langSysRecords.length; j++) {
+        //     scripts[i].script.langSysRecords[j].featureIndexes = [0];
+        // }
+    }
+
+    return {lookups, features, scripts};
+}
+
+
+
 function makeGposTable(gpos) {
+
+    gpos = subsetGposImplemented(gpos);
+
+    if (!gpos) return;
+
     return new table.Table('GPOS', [
         {name: 'version', type: 'ULONG', value: 0x10000},
         {name: 'scripts', type: 'TABLE', value: new table.ScriptList(gpos.scripts)},
@@ -123,4 +454,206 @@ function makeGposTable(gpos) {
     ]);
 }
 
+/**
+ * Converts from kerning pairs created from `kern` table to "type 2" lookup for `GPOS` table.
+ * @param {Object<string, number>} kerningPairs 
+ */
+function kernToGposType2(kerningPairs) {
+
+    // The main difference between the `kern` and `GPOS` format 1 subtable is that the `kern` table lists every kerning pair,
+    // while the `GPOS` format 1 subtable groups together kerning pairs that share the same first glyph.
+    const kerningArray = Object.entries(kerningPairs);
+    kerningArray.sort(function (a, b) {
+        const aLeftGlyph = parseInt(a[0].match(/\d+/)[0]);
+        const aRightGlyph = parseInt(a[0].match(/\d+$/)[0]);
+        const bLeftGlyph = parseInt(b[0].match(/\d+/)[0]);
+        const bRightGlyph = parseInt(b[0].match(/\d+$/)[0]);
+        if (aLeftGlyph < bLeftGlyph) {
+            return -1;
+        }
+        if (aLeftGlyph > bLeftGlyph) {
+            return 1;
+        }
+        if (aRightGlyph < bRightGlyph) {
+            return -1;
+        }
+        return 1;
+    });
+
+    const nPairs = kerningArray.length;
+
+    const coverage = [];
+    const pairSets = [];
+
+    for (let i = 0; i < nPairs; i++) {
+
+        let firstGlyph = parseInt(kerningArray[i][0].match(/\d+/)[0]);
+        let secondGlyph = parseInt(kerningArray[i][0].match(/\d+$/)[0]);
+
+        if (firstGlyph !== coverage[coverage.length - 1]) {
+            coverage.push(firstGlyph);
+            pairSets.push([]);
+        }
+
+        pairSets[coverage.length - 1].push([secondGlyph, kerningArray[i][1]]);
+    }
+
+    return {coverage, pairSets};
+}
+
+function makeGposTable3(gpos, kerningPairs) {
+
+    gpos = subsetGposImplemented(gpos);
+
+    if (!gpos) return;
+
+    // TODO: This fails with ranges.
+    const firstGlyphs = gpos.lookups[0].subtables[0].coverage.glyphs;
+    let nPairs = 0;
+    for (let i = 0; i < gpos.lookups[0].subtables[0].pairSets.length; i++) {
+        nPairs += gpos.lookups[0].subtables[0].pairSets[i].length;
+    }
+
+    const kerningGlyphs2 = [];
+    for (let i = 0; i < gpos.lookups[0].subtables[0].pairSets.length; i++) {
+        kerningGlyphs2[i] = [];
+        for (let j = 0; j < gpos.lookups[0].subtables[0].pairSets[i].length; j++) {
+            const secondGlyph = gpos.lookups[0].subtables[0].pairSets[i][j].secondGlyph;
+            const xAdvance = gpos.lookups[0].subtables[0].pairSets[i][j].value1.xAdvance;
+            kerningGlyphs2[i].push([secondGlyph, xAdvance]);
+        }
+    }
+
+    // var kerningArray = Object.entries(kerningPairs);
+    // kerningArray.sort(function (a, b) {
+    //     let aLeftGlyph = parseInt(a[0].match(/\d+/)[0]);
+    //     let aRightGlyph = parseInt(a[0].match(/\d+$/)[0]);
+    //     let bLeftGlyph = parseInt(b[0].match(/\d+/)[0]);
+    //     let bRightGlyph = parseInt(b[0].match(/\d+$/)[0]);
+    //     if (aLeftGlyph < bLeftGlyph) {
+    //         return -1;
+    //     }
+    //     if (aLeftGlyph > bLeftGlyph) {
+    //         return 1;
+    //     }
+    //     if (aRightGlyph < bRightGlyph) {
+    //         return -1;
+    //     }
+    //     return 1;
+    // });
+
+    // const nPairs = kerningArray.length;
+
+    // var firstGlyphs = [];
+    // var kerningGlyphs2 = [];
+
+    // for (let i = 0; i < nPairs; i++) {
+
+    //     let firstGlyph = parseInt(kerningArray[i][0].match(/\d+/)[0]);
+    //     let secondGlyph = parseInt(kerningArray[i][0].match(/\d+$/)[0]);
+
+    //     if (firstGlyph !== firstGlyphs[firstGlyphs.length - 1]) {
+    //         firstGlyphs.push(firstGlyph);
+    //         kerningGlyphs2[firstGlyphs.length - 1] = [];
+    //     }
+
+    //     kerningGlyphs2[firstGlyphs.length - 1].push([secondGlyph, kerningArray[i][1]]);
+    // }
+
+    var result = new table.Table('GPOS', [
+
+        // Start of GPOS Header
+        { name: 'majorVersion', type: 'USHORT', value: 1 },
+        { name: 'minorVersion', type: 'USHORT', value: 0 },
+        { name: 'scriptListOffset', type: 'USHORT', value: 10 },
+        { name: 'featureListOffset', type: 'USHORT', value: 48 },
+        { name: 'lookupListOffset', type: 'USHORT', value: 62 },
+
+        // Offset #1
+        // Start of ScriptList
+        { name: 'scriptCount', type: 'USHORT', value: 2 },
+        // Script record
+        { name: 'scriptTag', type: 'TAG', value: 'DFLT' },
+        { name: 'scriptOffset', type: 'USHORT', value: 14 },
+        { name: 'scriptTag2', type: 'TAG', value: 'latn' },
+        { name: 'scriptOffset2', type: 'USHORT', value: 26 },
+
+        // Start of Script Table #1 (Default)
+        { name: 'defaultLangSysOffset', type: 'USHORT', value: 4 },
+        { name: 'langSysCount', type: 'USHORT', value: 0 },
+        // Start of LangySys Table
+        { name: 'lookupOrderOffset', type: 'USHORT', value: 0 }, // Reserved, null
+        { name: 'requiredFeatureIndex', type: 'USHORT', value: 65535 },
+        { name: 'featureIndexCount', type: 'USHORT', value: 1 },
+        { name: 'featureIndex', type: 'USHORT', value: 0 },
+
+        // Start of Script Table #2 (Latin)
+        { name: 'defaultLangSysOffset2', type: 'USHORT', value: 4 },
+        { name: 'langSysCount2', type: 'USHORT', value: 0 },
+        // Start of LangySys Table
+        { name: 'lookupOrderOffset2', type: 'USHORT', value: 0 }, // Reserved, null
+        { name: 'requiredFeatureIndex2', type: 'USHORT', value: 65535 },
+        { name: 'featureIndexCount2', type: 'USHORT', value: 1 },
+        { name: 'featureIndex2', type: 'USHORT', value: 0 },
+
+        // Offset #2
+        // Start of FeatureList Table
+        { name: 'featureCount', type: 'USHORT', value: 1 },
+        { name: 'featureTag', type: 'TAG', value: 'kern' },
+        { name: 'featureOffset', type: 'USHORT', value: 8 },
+
+        // Start of Feature Table
+        { name: 'featureParamsOffset', type: 'USHORT', value: 0 },
+        { name: 'lookupIndexCount', type: 'USHORT', value: 1 },
+        { name: 'lookupListIndices', type: 'USHORT', value: 0 },
+
+        // Offset #3
+        // Start of LookupList Table
+        { name: 'lookupCount', type: 'USHORT', value: 1 },
+        { name: 'lookupOffset', type: 'USHORT', value: 4 },
+        // Start of Lookup table
+        { name: 'lookupType', type: 'USHORT', value: 2 },
+        { name: 'lookupFlag', type: 'USHORT', value: 0 },
+        { name: 'subTableCount', type: 'USHORT', value: 1 },
+        { name: 'lookupOffset2', type: 'USHORT', value: 8 },
+
+        // Start of lookup subtable (actual kerning info)
+        { name: 'posFormat', type: 'USHORT', value: 1 },
+        { name: 'coverageOffset', type: 'USHORT', value: 10 + 4 * firstGlyphs.length + 4 * nPairs },
+        // X_ADVANCE only
+        { name: 'valueFormat1', type: 'USHORT', value: 4 },
+        // Omit (note: using other formats will impact offset calculations)
+        { name: 'valueFormat2', type: 'USHORT', value: 0 },
+        // pairSetCount: Number of PairSet tables
+        { name: 'pairSetCount', type: 'USHORT', value: firstGlyphs.length },
+        //   {name: 'pairSetOffsets', type: 'USHORT', value: 22},
+
+    ]);
+
+    var offsetN = 10 + 2 * (firstGlyphs.length);
+    for (let i = 0; i < firstGlyphs.length; i++) {
+        result.fields.push({ name: 'pairSetOffsets', type: 'USHORT', value: offsetN });
+        offsetN = offsetN + 2 + 4 * (kerningGlyphs2[i].length);
+    }
+
+    // Add PairSet tables (one for each first letter in a kerning pair)
+    for (let i = 0; i < kerningGlyphs2.length; i++) {
+        result.fields.push({ name: 'pairValueCount', type: 'USHORT', value: kerningGlyphs2[i].length });
+        for (let j = 0; j < kerningGlyphs2[i].length; j++) {
+            result.fields.push({ name: 'secondGlyph', type: 'USHORT', value: kerningGlyphs2[i][j][0] });
+            result.fields.push({ name: 'valueRecord1', type: 'USHORT', value: kerningGlyphs2[i][j][1] });
+            // console.log("Kerning: " + kerningGlyphs2[i][j][0] + " " + kerningGlyphs2[i][j][1])
+        }
+    }
+
+    // Add Coverage tables (defines which first letters map to which PairSet table)
+    result.fields.push({ name: 'coverageFormat', type: 'USHORT', value: 1 }); // Format 1 indicates glyph pairs (format 2 uses classes of glyphs)
+    result.fields.push({ name: 'glyphCount', type: 'USHORT', value: firstGlyphs.length });
+    for (let i = 0; i < firstGlyphs.length; i++) {
+        result.fields.push({ name: 'UppercasePGlyphID', type: 'USHORT', value: firstGlyphs[i] });
+    }
+
+    return (result);
+}
+
 export default { parse: parseGposTable, make: makeGposTable };
diff --git a/src/tables/sfnt.mjs b/src/tables/sfnt.mjs
index 6e526f64..ad780008 100644
--- a/src/tables/sfnt.mjs
+++ b/src/tables/sfnt.mjs
@@ -17,6 +17,7 @@ import maxp from './maxp.mjs';
 import _name from './name.mjs';
 import os2 from './os2.mjs';
 import post from './post.mjs';
+import gpos from './gpos.mjs';
 import gsub from './gsub.mjs';
 import meta from './meta.mjs';
 import colr from './colr.mjs';
@@ -357,6 +358,7 @@ function fontToSfntTable(font) {
 
     // Optional tables
     const optionalTables = {
+        gpos,
         gsub,
         cpal,
         colr,
@@ -369,9 +371,19 @@ function fontToSfntTable(font) {
         svg,
     };
 
+    const kerningPairs = {};
+
+    const indexFirst = font.charToGlyphIndex('T');
+    const indexSecond = font.charToGlyphIndex('r');
+
+    kerningPairs[`${indexFirst},${indexSecond}`] = -50;
+
+
+
     const optionalTableArgs = {
         avar: [font.tables.fvar],
         fvar: [font.names],
+        gpos: [kerningPairs],
     };
 
     for (let tableName in optionalTables) {

From 9e66a68eea9d48abb61ee81da65468af6941b394 Mon Sep 17 00:00:00 2001
From: Balearica <admin@scribeocr.com>
Date: Fri, 12 Jul 2024 03:02:01 -0700
Subject: [PATCH 2/4] Finished first pass of kerning write support

---
 src/opentype.mjs          |   8 +-
 src/tables/gpos.mjs       | 546 ++++++++------------------------------
 src/tables/sfnt.mjs       |  14 +-
 test/tables/gpos.spec.mjs | 139 +++++++++-
 4 files changed, 256 insertions(+), 451 deletions(-)

diff --git a/src/opentype.mjs b/src/opentype.mjs
index 2bb68a54..7a3101e4 100644
--- a/src/opentype.mjs
+++ b/src/opentype.mjs
@@ -310,12 +310,8 @@ function parseBuffer(buffer, opt={}) {
                 metaTableEntry = tableEntry;
                 break;
             case 'gasp':
-                try {
-                    table = uncompressTable(data, tableEntry);
-                    font.tables.gasp = gasp.parse(table.data, table.offset);
-                } catch (e) {
-                    console.warn('Error parsing gasp table:', e);
-                }
+                table = uncompressTable(data, tableEntry);
+                font.tables.gasp = gasp.parse(table.data, table.offset);
                 break;
             case 'SVG ':
                 table = uncompressTable(data, tableEntry);
diff --git a/src/tables/gpos.mjs b/src/tables/gpos.mjs
index 7a6495aa..eac31aff 100644
--- a/src/tables/gpos.mjs
+++ b/src/tables/gpos.mjs
@@ -114,335 +114,128 @@ function parseGposTable(data, start) {
 // NOT SUPPORTED
 const subtableMakers = new Array(10);
 
-// subtableMakers[2] = function makeLookup2(subtable) {
-
-//     if (subtable.posFormat === 1) {
-
-//         const pairPosTableData = [
-//             {name: 'posFormat', type: 'USHORT', value: 1},
-//             {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
-//             {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
-//             {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
-//             // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
-//         ];
-
-        
-//         // let offsetN = 10 + 2 * (subtable.pairSets.length);
-//         // for (let i = 0; i < subtable.pairSets.length; i++) {
-//         //     result.fields.push({ name: 'pairSetOffsets', type: 'USHORT', value: offsetN });
-//         //     offsetN = offsetN + 2 + 4 * (kerningGlyphs2[i].length);
-//         // }
-
-//         const pairSets = [];
-
-    
-//         // Add PairSet tables (one for each first letter in a kerning pair)
-//         for (let i = 0; i < subtable.pairSets.length; i++) {
-//             const pairRecords = [];
-
-
-
-//             // result.fields.push({ name: 'pairValueCount', type: 'USHORT', value: kerningGlyphs2[i].length });mmemm
-//             for (let j = 0; j < subtable.pairSets[i].length; j++) {
-//                 pairRecords.push({ name: 'secondGlyph', type: 'USHORT', value: subtable.pairSets[i][j][0] });
-//                 pairRecords.push({ name: 'valueRecord1', type: 'USHORT', value: subtable.pairSets[i][j][1] });
-
-//                 // result.fields.push({ name: 'secondGlyph', type: 'USHORT', value: kerningGlyphs2[i][j][0] });
-//                 // result.fields.push({ name: 'valueRecord1', type: 'USHORT', value: kerningGlyphs2[i][j][1] });
-//                 // console.log("Kerning: " + kerningGlyphs2[i][j][0] + " " + kerningGlyphs2[i][j][1])
-//             }
-//             pairSets.push({ name: 'pairSet', type: 'TABLE', value: new table.Table('pairSet', pairRecords) });
-//         }
-
-//         pairPosTableData.push({ name: 'pairSets', type: 'TABLE', value: new table.Table('pairSets', pairSets) });
-
-//         const pairPosTable = new table.Table('pairPosFormat1', pairPosTableData);
-    
-
-//         return pairPosTable;
-//         // return lookupTable;
-    
-//     } else {
-//         check.assert(false, 'lookup type 2 format 2 is not yet supported.');
-//     }
-
-// };
+function addValueRecordFields(table, valueRecord, valueFormat) {
+    if (!valueRecord) return;
+    const components = ['xPlacement', 'yPlacement', 'xAdvance', 'yAdvance', 'xPlacementDevice', 'yPlacementDevice', 'xAdvanceDevice', 'yAdvanceDevice'];
 
+    for (let i = 0; i < components.length; i++) {
+        if (valueFormat & (1 << i)) {
+            table.fields.push({ name: components[i], type: 'SHORT', value: valueRecord[components[i]] || 0 });
+        }
+    }
+}
 
 subtableMakers[2] = function makeLookup2(subtable) {
 
     if (subtable.posFormat === 1) {
-
-        // const posTable = new table.Table('pairPosFormat1', [
-        //     {name: 'posFormat', type: 'USHORT', value: 1},
-        //     {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
-        //     {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
-        //     {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
-        //     // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
-        // ].concat(table.tableList('pairSets', subtable.pairSets, function(pairSet) {
-        //     return new table.Table('pairSetTable', [
-        //     ].concat(table.tableList('pairValue', pairSet, function(pairValue) {
-        //         const xAdvance = pairValue.value1 ? pairValue.value1.xAdvance : undefined;
-        //         const yAdvance = pairValue.value2 ? pairValue.value2.yAdvance : undefined;
-        //         return new table.Table('pairValueTable',
-        //             [{name: 'secondGlyph', type: 'USHORT', value: pairValue.secondGlyph }, 
-        //                 {name: 'value1', type: 'USHORT', value: xAdvance }]
-        //         );
-        //     })));
-        // })));
-
-
         const posTable = new table.Table('pairPosFormat1', [
             {name: 'posFormat', type: 'USHORT', value: 1},
             {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
             {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
             {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
-            // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
         ].concat(table.tableList('pairSets', subtable.pairSets, function(pairSet) {
-
             const pairSetTable = new table.Table('pairSetTable', []);
             pairSetTable.fields.push({name: 'pairValueCount', type: 'USHORT', value: pairSet.length });
             for (let i = 0; i < pairSet.length; i++) {
-                const xAdvance = pairSet[i].value1 ? pairSet[i].value1.xAdvance : undefined;
-                const yAdvance = pairSet[i].value2 ? pairSet[i].value2.yAdvance : undefined;
-                pairSetTable.fields.push({name: 'secondGlyph', type: 'USHORT', value: pairSet[i].secondGlyph });
-                pairSetTable.fields.push({name: 'value1', type: 'USHORT', value: xAdvance });
-                // pairSetTable.fields.push({name: 'value2', type: 'USHORT', value: yAdvance });
+                const pair = pairSet[i];
+                pairSetTable.fields.push({name: 'secondGlyph', type: 'USHORT', value: pair.secondGlyph });
+                addValueRecordFields(pairSetTable, pair.value1, subtable.valueFormat1);
+                addValueRecordFields(pairSetTable, pair.value2, subtable.valueFormat2);
             }
             return pairSetTable;
         })));
-
-
-
-        debugger;
         return posTable;
-
-
-        const pairSetTable = new table.Table('pairSetTable', []);
-        
-
-        // Offset #3
-        // Start of LookupList Table
-        // { name: 'lookupCount', type: 'USHORT', value: 1 },
-        // { name: 'lookupOffset', type: 'USHORT', value: 4 },
-        // // Start of Lookup table
-        // { name: 'lookupType', type: 'USHORT', value: 2 },
-        // { name: 'lookupFlag', type: 'USHORT', value: 0 },
-        // { name: 'subTableCount', type: 'USHORT', value: 1 },
-        // { name: 'lookupOffset2', type: 'USHORT', value: 8 },
-
-        // // Start of lookup subtable (actual kerning info)
-        // { name: 'posFormat', type: 'USHORT', value: 1 },
-        // { name: 'coverageOffset', type: 'USHORT', value: 10 + 4 * firstGlyphs.length + 4 * nPairs },
-        // // X_ADVANCE only
-        // { name: 'valueFormat1', type: 'USHORT', value: 4 },
-        // // Omit (note: using other formats will impact offset calculations)
-        // { name: 'valueFormat2', type: 'USHORT', value: 0 },
-        // // pairSetCount: Number of PairSet tables
-        // { name: 'pairSetCount', type: 'USHORT', value: firstGlyphs.length },
-        // //   {name: 'pairSetOffsets', type: 'USHORT', value: 22},
-
-
-
-        // let offsetN = 10 + 2 * (subtable.pairSets.length);
-        // for (let i = 0; i < subtable.pairSets.length; i++) {
-        //     pairSetTable.fields.push({ name: 'pairSetOffsets', type: 'USHORT', value: offsetN });
-        //     offsetN = offsetN + 2 + 4 * (subtable.pairSets[i].length);
-        // }
-    
-        // // Add PairSet tables (one for each first letter in a kerning pair)
-        // for (let i = 0; i < subtable.pairSets.length; i++) {
-        //     pairSetTable.fields.push({ name: 'pairValueCount', type: 'USHORT', value: subtable.pairSets[i].length });
-        //     for (let j = 0; j < subtable.pairSets[i].length; j++) {
-        //         pairSetTable.fields.push({ name: 'secondGlyph', type: 'USHORT', value: subtable.pairSets[i][j].secondGlyph });
-        //         const xAdvance = subtable.pairSets[i][j].value1 ? subtable.pairSets[i][j].value1.xAdvance : undefined;
-        //         pairSetTable.fields.push({ name: 'valueRecord1', type: 'USHORT', value: xAdvance });
-        //         // console.log("Kerning: " + kerningGlyphs2[i][j][0] + " " + kerningGlyphs2[i][j][1])
-        //     }
-        // }
-    
-        // const posTable = new table.Table('pairPosFormat1', [
-        //     {name: 'posFormat', type: 'USHORT', value: 1},
-        //     {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
-        //     {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
-        //     {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
-        //     {name: 'pairSet', type: 'TABLE', value: pairSetTable},
-        //     {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
-        // ]);
-
-        
-        
-        // .concat(table.tableList('pairSets', subtable.pairSets, function(pairSet) {
-
-        //     const pairValues = [{name: 'pairValueCount', type: 'USHORT', value: pairSet.length }];
-        //     for (let i = 0; i < pairSet.length; i++) {
-        //         const xAdvance = pairSet[i].value1 ? pairSet[i].value1.xAdvance : undefined;
-        //         const yAdvance = pairSet[i].value2 ? pairSet[i].value2.yAdvance : undefined;
-        //         pairValues.push({name: 'secondGlyph', type: 'USHORT', value: pairSet[i].secondGlyph });
-        //         pairValues.push({name: 'xAdvance', type: 'USHORT', value: xAdvance });
-        //     }
-
-        //     return new table.Table('pairValues', pairValues);
-        // })));
-
-
-        // subtableMakers[3] = function makeLookup3(subtable) {
-        //     check.assert(subtable.substFormat === 1, 'Lookup type 3 substFormat must be 1.');
-        //     return new table.Table('substitutionTable', [
-        //         {name: 'substFormat', type: 'USHORT', value: 1},
-        //         {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)}
-        //     ].concat(table.tableList('altSet', subtable.alternateSets, function(alternateSet) {
-        //         return new table.Table('alternateSetTable', table.ushortList('alternate', alternateSet));
-        //     })));
-        // };
-        
-
-        debugger;
+    } else if (subtable.posFormat === 2) {
+        const posTable = new table.Table('pairPosFormat2', [
+            { name: 'posFormat', type: 'USHORT', value: 2 },
+            { name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage) },
+            { name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
+            { name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
+            { name: 'classDef1', type: 'TABLE', value: new table.ClassDef(subtable.classDef1) },
+            { name: 'classDef2', type: 'TABLE', value: new table.ClassDef(subtable.classDef2) },
+            { name: 'class1Count', type: 'USHORT', value: subtable.classRecords.length },
+            { name: 'class2Count', type: 'USHORT', value: subtable.classRecords[0].length }
+        ]);
+
+        for (let i = 0; i < subtable.classRecords.length; i++) {
+            const class1Record = subtable.classRecords[i];
+            for (let j = 0; j < class1Record.length; j++) {
+                const class2Record = class1Record[j];
+                addValueRecordFields(posTable, class2Record.value1, subtable.valueFormat1);
+                addValueRecordFields(posTable, class2Record.value2, subtable.valueFormat2);
+            }
+        }
 
         return posTable;
-
-
-
-
-        const pairPosTableData = [
-            {name: 'posFormat', type: 'USHORT', value: 1},
-            {name: 'coverage', type: 'TABLE', value: new table.Coverage(subtable.coverage)},
-            {name: 'valueFormat1', type: 'USHORT', value: subtable.valueFormat1 },
-            {name: 'valueFormat2', type: 'USHORT', value: subtable.valueFormat2 },
-            // {name: 'pairSetCount', type: 'USHORT', value: subtable.pairSets.length },
-        ];
-
-        
-
-
-        pairPosTableData.push(...table.tableList('pairSet', subtable.pairSets, function(pairSet) {
-            const pairSetTableData = [
-                // {name: 'pairValueCount', type: 'USHORT', value: pairSet.length },
-            ];
-
-            pairSetTableData.push(...table.tableList('pairValue', pairSet, function(pairValue) {
-                const pairValueTableData = [
-                    {name: 'secondGlyph', type: 'USHORT', value: pairValue.secondGlyph },
-                ];
-                const xAdvance = pairValue.value1 ? pairValue.value1.xAdvance : undefined;
-                const yAdvance = pairValue.value2 ? pairValue.value2.yAdvance : undefined;
-                pairValueTableData.push({name: 'value1', type: 'USHORT', value: xAdvance });
-                // pairValueTableData.push({name: 'value2', type: 'USHORT', value: yAdvance });
-                return new table.Table('pairValue', pairValueTableData);
-            }));
-
-            return new table.Table('pairSet', pairSetTableData);
-        }));
-    
-        // for (let i = 0; i < subtable.pairSets.length; i++) {
-    
-        //     const pairSetTableData = [
-        //         {name: 'pairValueCount', type: 'USHORT', value: subtable.pairSets[i].length },
-        //     ];
-    
-        //     for (let j = 0; j < subtable.pairSets[i].length; j++) {
-        //         pairSetTableData.push({ name: 'secondGlyph', type: 'USHORT', value: subtable.pairSets[i][j].secondGlyph });
-        //         // if (subtable.pairSets[i][j].value1) pairSetTableData.push({ name: 'value1', type: 'USHORT', value: subtable.pairSets[i][j].value1.xAdvance });
-        //         // if (subtable.pairSets[i][j].value2) pairSetTableData.push({ name: 'value2', type: 'USHORT', value: subtable.pairSets[i][j].value1.yAdvance });
-
-        //         const xAdvance = subtable.pairSets[i][j].value1 ? subtable.pairSets[i][j].value1.xAdvance : undefined;
-        //         // const yAdvance = subtable.pairSets[i][j].value2 ? subtable.pairSets[i][j].value2.yAdvance : undefined;
-
-        //         pairSetTableData.push({ name: 'value1', type: 'USHORT', value: xAdvance });
-        //         // pairSetTableData.push({ name: 'value2', type: 'USHORT', value: yAdvance });
-
-        //     }
-    
-        //     // posTableData.push({ name: 'pairSet', type: 'TABLE', value: new table.Table('pairSet', pairSetTableData) });
-        //     lookupTable.push({ name: 'pairSet', type: 'TABLE', value: new table.Table('pairSet', pairSetTableData) });
-
-        // }
-
-        // return posTable;
-    
-        return new table.Table('pairPosFormat1', pairPosTableData);
-        // return lookupTable;
-    
     } else {
-        check.assert(false, 'lookup type 2 format 2 is not yet supported.');
+        throw new Error('Lookup type 2 format must be 1 or 2.');
     }
-
 };
 
 
 /**
- * Subsets the `GPOS` table to only include tables that have been implemented (pair kerning using type 2 format 1 subtables).
+ * Subsets the `GPOS` table to only include tables that have been implemented (type 2/kerning).
  * Once write support for all `GPOS` subtables is implemented, this function should be removed.
  * 
  * @param {*} gpos 
  * @returns 
  */
-function subsetGposImplemented(gpos) {
+export function subsetGposImplemented(gpos) {
     // Filter lookups to only pair kerning tables; make deep copy to avoid editing original.
-    const lookups0 = gpos.lookups.filter((x) => x.lookupType === 2).map((x) => JSON.parse(JSON.stringify(x)));
-    if (lookups0.length === 0) return;
-    // Filter pair kerning tables to only type 2 format 1 subtables.
-    const lookups = lookups0.map((x) => {
-        x.subtables = x.subtables.filter((y) => y.posFormat === 1);
-        return x;
-    }).filter((x) => x.subtables.length > 0);
-    if (lookups.length === 0) return;
 
-    // const kernTableIndex = gpos.lookups.findIndex((x) => x.lookupType === 2);
-    // if (kernTableIndex === -1) return;
-    // const kernTableCopy = JSON.parse(JSON.stringify(gpos.lookups[kernTableIndex]));
-    // kernTableCopy.subtables = kernTableCopy.subtables.filter((x) => x.posFormat === 1);
-    // if (kernTableCopy.subtables.length === 0) return;
-    // const lookups = [kernTableCopy];
-
-    const featureIndices = [];
-    for(let i = 0; i < gpos.features.length; i++)
-        if (gpos.features[i].tag === 'kern')
-            featureIndices.push(i);
-
-    const features = gpos.features.filter((x) => x.tag === 'kern').map((x) => JSON.parse(JSON.stringify(x)));
-    
-    // TODO: This always points to the first lookup table, which may not be correct.
-    for (let i = 0; i < features.length; i++) {
-        features[i].feature.lookupListIndexes = [0];
+    const lookups = [];
+    const lookupsIndices = [];
+    for(let i = 0; i < gpos.lookups.length; i++) {
+        if (gpos.lookups[i].lookupType === 2) {
+            lookupsIndices.push(i);
+            lookups.push(JSON.parse(JSON.stringify(gpos.lookups[i])));
+            // lookups.push(structuredClone(gpos.lookups[i]));
+        }   
     }
 
+    if (lookups.length === 0) return;
 
-    // const featureIndex = gpos.features.findIndex((x) => x.tag === 'kern');
-    // const featureTableCopy = JSON.parse(JSON.stringify(gpos.features[featureIndex]));
-    // featureTableCopy.feature.lookupListIndexes = [0];
-    // const features = [featureTableCopy];
-
-    
+    const features = [];
+    const featuresIndices = [];
+    for(let i = 0; i < gpos.features.length; i++) {
+        if (gpos.features[i].tag === 'kern') {
+            featuresIndices.push(i);
+            features.push(JSON.parse(JSON.stringify(gpos.features[i])));
+        }
+    }
 
-    // const scripts = JSON.parse(JSON.stringify(gpos.scripts.filter((x) => x.script.defaultLangSys.featureIndexes.includes(featureIndex))));
+    // Filter features to only include those that reference the pair kerning tables; update lookupListIndexes to match new indices.
+    for (let i = 0; i < features.length; i++) {
+        features[i].feature.lookupListIndexes = features[i].feature.lookupListIndexes.filter((x) => lookupsIndices.includes(x)).map((x) => lookupsIndices.indexOf(x));
+    }
 
     const scripts = [];
 
+    // Filter scripts to only include those that reference the features; update featureIndexes to match new indices.
     for (let i = 0; i < gpos.scripts.length; i++) {
         const scriptI = JSON.parse(JSON.stringify(gpos.scripts[i]));
-        scriptI.script.defaultLangSys.featureIndexes = scriptI.script.defaultLangSys.featureIndexes.filter((x) => featureIndices.includes(x));
+        scriptI.script.defaultLangSys.featureIndexes = scriptI.script.defaultLangSys.featureIndexes.filter((x) => featuresIndices.includes(x)).map((x) => featuresIndices.indexOf(x));
         if (scriptI.script.defaultLangSys.featureIndexes.length === 0) continue;
         for (let j = 0; j < scriptI.script.langSysRecords.length; j++) {
-            scriptI.script.langSysRecords[j].featureIndexes = scriptI.script.langSysRecords[j].langSys.featureIndexes.filter((x) => featureIndices.includes(x));
+            scriptI.script.langSysRecords[j].featureIndexes = scriptI.script.langSysRecords[j].langSys.featureIndexes.filter((x) => featuresIndices.includes(x)).map((x) => featuresIndices.indexOf(x));
         }
         scripts.push(scriptI);
-
-
-        // scripts[i].script.defaultLangSys.featureIndexes = [0];
-        // for (let j = 0; j < scripts[i].script.langSysRecords.length; j++) {
-        //     scripts[i].script.langSysRecords[j].featureIndexes = [0];
-        // }
     }
 
-    return {lookups, features, scripts};
+    return {version: gpos.version, lookups, features, scripts};
 }
 
 
 
-function makeGposTable(gpos) {
+function makeGposTable(gpos, kerningPairs) {
 
-    gpos = subsetGposImplemented(gpos);
+    if (gpos) {
+        gpos = subsetGposImplemented(gpos);
+    } else if (kerningPairs && Object.keys(kerningPairs).length > 0) {
+        gpos = kernToGpos(kerningPairs);
+    } else {
+        return;
+    }
 
     if (!gpos) return;
 
@@ -458,7 +251,7 @@ function makeGposTable(gpos) {
  * Converts from kerning pairs created from `kern` table to "type 2" lookup for `GPOS` table.
  * @param {Object<string, number>} kerningPairs 
  */
-function kernToGposType2(kerningPairs) {
+function kernToGpos(kerningPairs) {
 
     // The main difference between the `kern` and `GPOS` format 1 subtable is that the `kern` table lists every kerning pair,
     // while the `GPOS` format 1 subtable groups together kerning pairs that share the same first glyph.
@@ -482,7 +275,10 @@ function kernToGposType2(kerningPairs) {
 
     const nPairs = kerningArray.length;
 
-    const coverage = [];
+    const coverage = {
+        format: 1,
+        glyphs: []
+    };
     const pairSets = [];
 
     for (let i = 0; i < nPairs; i++) {
@@ -490,170 +286,56 @@ function kernToGposType2(kerningPairs) {
         let firstGlyph = parseInt(kerningArray[i][0].match(/\d+/)[0]);
         let secondGlyph = parseInt(kerningArray[i][0].match(/\d+$/)[0]);
 
-        if (firstGlyph !== coverage[coverage.length - 1]) {
-            coverage.push(firstGlyph);
+        if (firstGlyph !== coverage.glyphs[coverage.glyphs.length - 1]) {
+            coverage.glyphs.push(firstGlyph);
             pairSets.push([]);
         }
 
-        pairSets[coverage.length - 1].push([secondGlyph, kerningArray[i][1]]);
+        pairSets[coverage.glyphs.length - 1].push({
+            secondGlyph,
+            value1: { xAdvance: kerningArray[i][1]}, 
+            value2: undefined
+        });
     }
 
-    return {coverage, pairSets};
-}
-
-function makeGposTable3(gpos, kerningPairs) {
-
-    gpos = subsetGposImplemented(gpos);
-
-    if (!gpos) return;
-
-    // TODO: This fails with ranges.
-    const firstGlyphs = gpos.lookups[0].subtables[0].coverage.glyphs;
-    let nPairs = 0;
-    for (let i = 0; i < gpos.lookups[0].subtables[0].pairSets.length; i++) {
-        nPairs += gpos.lookups[0].subtables[0].pairSets[i].length;
-    }
-
-    const kerningGlyphs2 = [];
-    for (let i = 0; i < gpos.lookups[0].subtables[0].pairSets.length; i++) {
-        kerningGlyphs2[i] = [];
-        for (let j = 0; j < gpos.lookups[0].subtables[0].pairSets[i].length; j++) {
-            const secondGlyph = gpos.lookups[0].subtables[0].pairSets[i][j].secondGlyph;
-            const xAdvance = gpos.lookups[0].subtables[0].pairSets[i][j].value1.xAdvance;
-            kerningGlyphs2[i].push([secondGlyph, xAdvance]);
+    const scripts = [
+        {
+            tag: 'DFLT',
+            script: {
+                defaultLangSys: {
+                    featureIndexes: [0]
+                },
+                langSysRecords: []
+            }
         }
-    }
-
-    // var kerningArray = Object.entries(kerningPairs);
-    // kerningArray.sort(function (a, b) {
-    //     let aLeftGlyph = parseInt(a[0].match(/\d+/)[0]);
-    //     let aRightGlyph = parseInt(a[0].match(/\d+$/)[0]);
-    //     let bLeftGlyph = parseInt(b[0].match(/\d+/)[0]);
-    //     let bRightGlyph = parseInt(b[0].match(/\d+$/)[0]);
-    //     if (aLeftGlyph < bLeftGlyph) {
-    //         return -1;
-    //     }
-    //     if (aLeftGlyph > bLeftGlyph) {
-    //         return 1;
-    //     }
-    //     if (aRightGlyph < bRightGlyph) {
-    //         return -1;
-    //     }
-    //     return 1;
-    // });
-
-    // const nPairs = kerningArray.length;
-
-    // var firstGlyphs = [];
-    // var kerningGlyphs2 = [];
-
-    // for (let i = 0; i < nPairs; i++) {
-
-    //     let firstGlyph = parseInt(kerningArray[i][0].match(/\d+/)[0]);
-    //     let secondGlyph = parseInt(kerningArray[i][0].match(/\d+$/)[0]);
-
-    //     if (firstGlyph !== firstGlyphs[firstGlyphs.length - 1]) {
-    //         firstGlyphs.push(firstGlyph);
-    //         kerningGlyphs2[firstGlyphs.length - 1] = [];
-    //     }
-
-    //     kerningGlyphs2[firstGlyphs.length - 1].push([secondGlyph, kerningArray[i][1]]);
-    // }
-
-    var result = new table.Table('GPOS', [
-
-        // Start of GPOS Header
-        { name: 'majorVersion', type: 'USHORT', value: 1 },
-        { name: 'minorVersion', type: 'USHORT', value: 0 },
-        { name: 'scriptListOffset', type: 'USHORT', value: 10 },
-        { name: 'featureListOffset', type: 'USHORT', value: 48 },
-        { name: 'lookupListOffset', type: 'USHORT', value: 62 },
-
-        // Offset #1
-        // Start of ScriptList
-        { name: 'scriptCount', type: 'USHORT', value: 2 },
-        // Script record
-        { name: 'scriptTag', type: 'TAG', value: 'DFLT' },
-        { name: 'scriptOffset', type: 'USHORT', value: 14 },
-        { name: 'scriptTag2', type: 'TAG', value: 'latn' },
-        { name: 'scriptOffset2', type: 'USHORT', value: 26 },
-
-        // Start of Script Table #1 (Default)
-        { name: 'defaultLangSysOffset', type: 'USHORT', value: 4 },
-        { name: 'langSysCount', type: 'USHORT', value: 0 },
-        // Start of LangySys Table
-        { name: 'lookupOrderOffset', type: 'USHORT', value: 0 }, // Reserved, null
-        { name: 'requiredFeatureIndex', type: 'USHORT', value: 65535 },
-        { name: 'featureIndexCount', type: 'USHORT', value: 1 },
-        { name: 'featureIndex', type: 'USHORT', value: 0 },
-
-        // Start of Script Table #2 (Latin)
-        { name: 'defaultLangSysOffset2', type: 'USHORT', value: 4 },
-        { name: 'langSysCount2', type: 'USHORT', value: 0 },
-        // Start of LangySys Table
-        { name: 'lookupOrderOffset2', type: 'USHORT', value: 0 }, // Reserved, null
-        { name: 'requiredFeatureIndex2', type: 'USHORT', value: 65535 },
-        { name: 'featureIndexCount2', type: 'USHORT', value: 1 },
-        { name: 'featureIndex2', type: 'USHORT', value: 0 },
-
-        // Offset #2
-        // Start of FeatureList Table
-        { name: 'featureCount', type: 'USHORT', value: 1 },
-        { name: 'featureTag', type: 'TAG', value: 'kern' },
-        { name: 'featureOffset', type: 'USHORT', value: 8 },
-
-        // Start of Feature Table
-        { name: 'featureParamsOffset', type: 'USHORT', value: 0 },
-        { name: 'lookupIndexCount', type: 'USHORT', value: 1 },
-        { name: 'lookupListIndices', type: 'USHORT', value: 0 },
-
-        // Offset #3
-        // Start of LookupList Table
-        { name: 'lookupCount', type: 'USHORT', value: 1 },
-        { name: 'lookupOffset', type: 'USHORT', value: 4 },
-        // Start of Lookup table
-        { name: 'lookupType', type: 'USHORT', value: 2 },
-        { name: 'lookupFlag', type: 'USHORT', value: 0 },
-        { name: 'subTableCount', type: 'USHORT', value: 1 },
-        { name: 'lookupOffset2', type: 'USHORT', value: 8 },
-
-        // Start of lookup subtable (actual kerning info)
-        { name: 'posFormat', type: 'USHORT', value: 1 },
-        { name: 'coverageOffset', type: 'USHORT', value: 10 + 4 * firstGlyphs.length + 4 * nPairs },
-        // X_ADVANCE only
-        { name: 'valueFormat1', type: 'USHORT', value: 4 },
-        // Omit (note: using other formats will impact offset calculations)
-        { name: 'valueFormat2', type: 'USHORT', value: 0 },
-        // pairSetCount: Number of PairSet tables
-        { name: 'pairSetCount', type: 'USHORT', value: firstGlyphs.length },
-        //   {name: 'pairSetOffsets', type: 'USHORT', value: 22},
+    ];
 
-    ]);
-
-    var offsetN = 10 + 2 * (firstGlyphs.length);
-    for (let i = 0; i < firstGlyphs.length; i++) {
-        result.fields.push({ name: 'pairSetOffsets', type: 'USHORT', value: offsetN });
-        offsetN = offsetN + 2 + 4 * (kerningGlyphs2[i].length);
-    }
-
-    // Add PairSet tables (one for each first letter in a kerning pair)
-    for (let i = 0; i < kerningGlyphs2.length; i++) {
-        result.fields.push({ name: 'pairValueCount', type: 'USHORT', value: kerningGlyphs2[i].length });
-        for (let j = 0; j < kerningGlyphs2[i].length; j++) {
-            result.fields.push({ name: 'secondGlyph', type: 'USHORT', value: kerningGlyphs2[i][j][0] });
-            result.fields.push({ name: 'valueRecord1', type: 'USHORT', value: kerningGlyphs2[i][j][1] });
-            // console.log("Kerning: " + kerningGlyphs2[i][j][0] + " " + kerningGlyphs2[i][j][1])
+    const features = [
+        {
+            tag: 'kern',
+            feature: {
+                lookupListIndexes: [0]
+            }
         }
-    }
+    ];
+
+    const lookups = [
+        {
+            lookupType: 2,
+            subtables: [
+                {
+                    posFormat: 1,
+                    coverage: coverage,
+                    valueFormat1: 0x0004,
+                    valueFormat2: 0x0000,
+                    pairSets: pairSets
+                }
+            ]
+        }
+    ];
 
-    // Add Coverage tables (defines which first letters map to which PairSet table)
-    result.fields.push({ name: 'coverageFormat', type: 'USHORT', value: 1 }); // Format 1 indicates glyph pairs (format 2 uses classes of glyphs)
-    result.fields.push({ name: 'glyphCount', type: 'USHORT', value: firstGlyphs.length });
-    for (let i = 0; i < firstGlyphs.length; i++) {
-        result.fields.push({ name: 'UppercasePGlyphID', type: 'USHORT', value: firstGlyphs[i] });
-    }
+    return {version: 1, scripts, features, lookups};
 
-    return (result);
 }
 
 export default { parse: parseGposTable, make: makeGposTable };
diff --git a/src/tables/sfnt.mjs b/src/tables/sfnt.mjs
index ad780008..60cd5000 100644
--- a/src/tables/sfnt.mjs
+++ b/src/tables/sfnt.mjs
@@ -371,24 +371,16 @@ function fontToSfntTable(font) {
         svg,
     };
 
-    const kerningPairs = {};
-
-    const indexFirst = font.charToGlyphIndex('T');
-    const indexSecond = font.charToGlyphIndex('r');
-
-    kerningPairs[`${indexFirst},${indexSecond}`] = -50;
-
-
-
     const optionalTableArgs = {
         avar: [font.tables.fvar],
         fvar: [font.names],
-        gpos: [kerningPairs],
+        gpos: [font.kerningPairs],
     };
 
     for (let tableName in optionalTables) {
         const table = font.tables[tableName];
-        if (table) {
+        // The GPOS table can also be made using `kerningPairs` from the `kern` table as input.
+        if (table || tableName === 'gpos') {
             const tableData = optionalTables[tableName].make.call(font, table, ...(optionalTableArgs[tableName] || []));
             if (tableData) {
                 tables.push(tableData);
diff --git a/test/tables/gpos.spec.mjs b/test/tables/gpos.spec.mjs
index 0fedf140..ffad3143 100644
--- a/test/tables/gpos.spec.mjs
+++ b/test/tables/gpos.spec.mjs
@@ -1,6 +1,9 @@
 import assert from 'assert';
-import { unhex } from '../testutil.mjs';
-import gpos from '../../src/tables/gpos.mjs';
+import { unhex, unhexArray } from '../testutil.mjs';
+import gpos, { subsetGposImplemented } from '../../src/tables/gpos.mjs';
+import { parse } from '../../src/opentype.mjs';
+import { readFileSync } from 'fs';
+const loadSync = (url, opt) => parse(readFileSync(url), opt);
 
 // Helper that builds a minimal GPOS table to test a lookup subtable.
 function parseLookup(lookupType, subTableData) {
@@ -13,6 +16,19 @@ function parseLookup(lookupType, subTableData) {
     return gpos.parse(data).lookups[0].subtables[0];
 }
 
+function makeLookup(lookupType, data) {
+    return gpos.make({
+        version: 1,
+        scripts: [],
+        features: [],
+        lookups: [{
+            lookupType: lookupType,
+            lookupFlag: 0,
+            subtables: [data]
+        }]
+    }).encode().slice(0x1a);                             // sub table start offset: 0x1a
+}
+
 describe('tables/gpos.mjs', function() {
     //// Header ///////////////////////////////////////////////////////////////
     it('can parse a GPOS header', function() {
@@ -138,4 +154,123 @@ describe('tables/gpos.mjs', function() {
             ]
         });
     });
+    
+    //// Lookup type 2: Pair Position Adjustment //////////////////////////////////
+    it('can write lookup2 for pair positioning', function() {
+        // The substance of the test is taken from the example on the Microsoft website linked below,
+        // however the order (and subsequently offsets) are edited to match the output of the function.
+        // https://learn.microsoft.com/en-us/typography/opentype/spec/gpos#example-4-pairposformat1-subtable
+        const expectedData = unhexArray(
+            '0001' + // PosFormat
+            '000E' + // Coverage offset (edited)
+            '0004 0001 0002' + // ValueFormat1 + ValueFormat2 + PairSetCount
+            '0016 001E' + // PairSet offsets (edited)
+            '0001 0002 002D 0031' + // Coverage table
+            '0001 0059 FFE2 FFEC' + // PairSet 1
+            '0001 0059 FFD8 FFE7' // PairSet 2
+        );
+        assert.deepEqual(makeLookup(2, {
+            posFormat: 1,
+            valueFormat1: 4,
+            valueFormat2: 1,
+            coverage: {
+                format: 1,
+                glyphs: [0x2d, 0x31] // Glyph IDs for "P" and "T"
+            },
+            pairSets: [
+                [
+                    {
+                        secondGlyph: 0x59, // Glyph ID for lowercase "o"
+                        value1: { xAdvance: -30 }, // Adjustments for the pair "Po"
+                        value2: { xPlacement: -20 }
+                    }
+                ],
+                [
+                    {
+                        secondGlyph: 0x59, // Glyph ID for lowercase "o"
+                        value1: { xAdvance: -40 }, // Adjustments for the pair "To"
+                        value2: { xPlacement: -25 }
+                    }
+                ]
+            ],
+        }), expectedData);
+    });
+
+    //// Lookup type 2: Pair Position Adjustment with Classes ///////////////////////
+    it('can write lookup2 for class-based pair positioning', function() {
+        // https://learn.microsoft.com/en-us/typography/opentype/spec/gpos#example-5-pairposformat2-subtable
+        const expectedData = unhexArray('0002 0018 0004 0000 0022 0032 0002 0002   0000 0000   0000 FFCE   0001 0003 0046 0047 0049   0002 0002 0046 0047 0001 0049 0049 0001   0002 0001 006A 006B 0001');
+        assert.deepEqual(makeLookup(2, {
+            posFormat: 2,
+            valueFormat1: 4,
+            valueFormat2: 0,
+            coverage: {
+                format: 1,
+                glyphs: [0x46, 0x47, 0x49] // Glyph IDs for "v", "w", "y"
+            },
+            classDef1: {
+                format: 2,
+                ranges: [
+                    { start: 0x46, end: 0x47, classId: 1 },
+                    { start: 0x49, end: 0x49, classId: 1 }
+                ]
+            },
+            classDef2: {
+                format: 2,
+                ranges: [
+                    { start: 0x6A, end: 0x6B, classId: 1 } // Glyph IDs for "period" and "comma"
+                ]
+            },
+            classRecords: [
+                [
+                    {
+                        value1: { xAdvance: 0 },
+                        value2: { xAdvance: 0 },
+                    },
+                    {
+                        value1: { xAdvance: 0 },
+                        value2: { xAdvance: 0 },
+                    }
+                ],
+                [
+                    {
+                        value1: { xAdvance: 0 },
+                        value2: { xAdvance: 0 },
+                    },
+                    {
+                        value1: { xAdvance: -50 },
+                        value2: { xAdvance: 0	},
+                    }
+                ]
+            ]
+        }), expectedData);
+    });
+
+    it('can write tables that are read as identical to the original', function() {
+        // This font is used because it includes both "format 1" and "format 2" subtables.
+        const font = loadSync('./test/fonts/Roboto-Black.ttf');
+        // Gasp table is currently broken, this line can be removed once that bug is fixed.
+        // See: https://github.com/opentypejs/opentype.js/pull/739
+        font.tables.gasp = undefined;
+
+        // Not all GPOS features are supported yet, so we need to subset the table.
+        const gpos = subsetGposImplemented(font.tables.gpos);
+        const gpos2 = subsetGposImplemented(parse(font.toArrayBuffer()).tables.gpos);
+        assert.deepStrictEqual(gpos, gpos2);
+    });
+
+    it('can convert from `kern` table to GPOS table, when GPOS does not exist', function() {
+        // This font contains both a `kern` and a `GPOS` table.
+        const font = loadSync('./test/fonts/Vibur.woff');
+        let font2 = loadSync('./test/fonts/Vibur.woff');
+        font2.tables.gpos = undefined;
+        font2 = parse(font2.toArrayBuffer());
+
+        const kern1 = font.getKerningValue(font.charToGlyph('T'), font.charToGlyph('i'));
+        const kern2 = font2.getKerningValue(font2.charToGlyph('T'), font2.charToGlyph('i'));
+
+        assert.notStrictEqual(kern1, 0);
+        assert.strictEqual(kern1, kern2);
+    });
+
 });

From 59d6777f2b05c0a65213cecd129db8f22c8fa3f5 Mon Sep 17 00:00:00 2001
From: Balearica <admin@scribeocr.com>
Date: Fri, 12 Jul 2024 03:04:03 -0700
Subject: [PATCH 3/4] Restored docs site

---
 docs/index.html | 24 ++----------------------
 1 file changed, 2 insertions(+), 22 deletions(-)

diff --git a/docs/index.html b/docs/index.html
index 3ee60af1..20b6a0fc 100755
--- a/docs/index.html
+++ b/docs/index.html
@@ -77,7 +77,6 @@ <h1>Free Software</h1>
 
 <script type="module">
 import * as opentype from "/dist/opentype.mjs";
-globalThis.opentype = opentype;
 
 const form = document.forms.demo;
 form.oninput = renderText;
@@ -204,30 +203,11 @@ <h1>Free Software</h1>
     el.innerHTML = message;
 }
 
-globalThis.downloadFont = async (font) => {
-    const fontArrayBuffer = font.toArrayBuffer();
-    const blob = new Blob([fontArrayBuffer], { type: 'font/otf' });
-    const link = document.createElement('a');
-    link.href = URL.createObjectURL(blob);
-    link.download = 'font.otf';
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-};
-
-globalThis.calcKern = (font, letter1, letter2) => (font.getKerningValue(font.charToGlyph(letter1), font.charToGlyph(letter2)));
-
-
-
 function onFontLoaded(font) {
     if (window.font) {
         window.font.onGlyphUpdated = null
     }
     window.font = font;
-
-    window.fontArrayBuffer = font.toArrayBuffer();
-    window.font2 = opentype.parse(window.fontArrayBuffer);
-
     options = Object.assign({}, window.font.defaultRenderOptions);
     window.fontOptions = options;
     
@@ -299,7 +279,7 @@ <h1>Free Software</h1>
             error = err;
         }     
 
-        onFontLoaded(opentype.parse(isWoff2 ? Module.decompress(data) : data, { lowMemory: false }));
+        onFontLoaded(opentype.parse(isWoff2 ? Module.decompress(data) : data, { lowMemory: true }));
         if ( !error ) showErrorMessage('');
     } catch (err) {
         showErrorMessage(err.toString());
@@ -321,4 +301,4 @@ <h1>Free Software</h1>
     const fontFileName = 'fonts/FiraSansMedium.woff';
     display(await fetch(fontFileName), fontFileName);
 }
-</script>
+</script>
\ No newline at end of file

From 88cfaa50d2594a957f78a4fecf17c5ea651f85b0 Mon Sep 17 00:00:00 2001
From: Balearica <admin@scribeocr.com>
Date: Fri, 12 Jul 2024 03:05:58 -0700
Subject: [PATCH 4/4] Restored docs site

---
 docs/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/index.html b/docs/index.html
index 20b6a0fc..bc99139d 100755
--- a/docs/index.html
+++ b/docs/index.html
@@ -301,4 +301,4 @@ <h1>Free Software</h1>
     const fontFileName = 'fonts/FiraSansMedium.woff';
     display(await fetch(fontFileName), fontFileName);
 }
-</script>
\ No newline at end of file
+</script>