@flighthq/font-formats 0.3.1-next.209.43ef1bc

package/dist/cffIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cffIndex.js","sourceRoot":"","sources":["../src/cffIndex.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,EAAE;AACF,uGAAuG;AACvG,iGAAiG;AACjG,yGAAyG;AACzG,EAAE;AACF,6EAA6E;AAC7E,EAAE;AACF,qGAAqG;AACrG,yGAAyG;AAEzG,yGAAyG;AACzG,wGAAwG;AACxG,iEAAiE;AACjE,MAAM,UAAU,YAAY,CAAC,KAA2B,EAAE,MAAc;IACtE,IAAI,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAC/C,MAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC5E,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAErC,qGAAqG;IACrG,qFAAqF;IACrF,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAE/D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC1C,IAAI,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAE5C,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,CAAC;IAC7B,MAAM,MAAM,GAAG,SAAS,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC;IACrD,IAAI,MAAM,IAAI,KAAK,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAE5C,MAAM,UAAU,GAAG,CAAC,KAAa,EAAU,EAAE;QAC3C,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,CAAC;YAC1C,KAAK,GAAG,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC;QAC1E,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,OAAO,GAAoB,EAAE,CAAC;IACpC,IAAI,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAC7B,uGAAuG;IACvG,IAAI,QAAQ,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEhC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QACnC,oGAAoG;QACpG,gGAAgG;QAChG,IAAI,IAAI,GAAG,QAAQ,IAAI,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC,UAAU;YAAE,OAAO,IAAI,CAAC;QACrE,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC,CAAC;QAC/D,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,EAAE,OAAO,EAAE,CAAC;AACnD,CAAC"}

package/dist/cffTable.d.ts

@@ -0,0 +1,3 @@
+import type { CffTable, SfntTableDirectory } from '@flighthq/types/contract';
+export declare function readCffTable(bytes: Readonly<Uint8Array>, directory: Readonly<SfntTableDirectory>): CffTable | null;
+//# sourceMappingURL=cffTable.d.ts.map

package/dist/cffTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cffTable.d.ts","sourceRoot":"","sources":["../src/cffTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,QAAQ,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAoG5F,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,QAAQ,GAAG,IAAI,CAmDlH"}

package/dist/cffTable.js

@@ -0,0 +1,134 @@
+import { CFF_OPERATOR_CHARSTRINGS, CFF_OPERATOR_FD_ARRAY, CFF_OPERATOR_FD_SELECT, CFF_OPERATOR_PRIVATE, CFF_OPERATOR_SUBRS, readCffDict, } from './cffDict';
+import { readCffFdSelect } from './cffFdSelect';
+import { readCffIndex } from './cffIndex';
+// Assembles the parts of a `CFF ` table an outline reader needs: the charstrings, and the two subroutine
+// pools they call into.
+//
+// The walk is fixed by the format — header, then name / top DICT / string / global subroutine INDEXes in
+// that order — and everything after is reached by offsets read from the top DICT. Offsets in the top DICT
+// are from the start of the TABLE; the local subroutine offset is from the start of the PRIVATE DICT.
+// Mixing those two bases is the mistake that yields a real-but-wrong subroutine pool, which draws
+// plausible garbage instead of failing.
+// Local subroutines are optional: a font whose glyphs call none simply omits the operator, and an empty
+// pool is the correct answer rather than a failure. Returned as an empty array so a caller never has to
+// distinguish "absent" from "present but empty" — the biasing arithmetic treats them identically.
+function readCffLocalSubrs(bytes, top, tableOffset, tableEnd) {
+    const privateEntry = top.get(CFF_OPERATOR_PRIVATE);
+    if (privateEntry === undefined || privateEntry.length < 2)
+        return [];
+    const [privateSize, privateOffset] = privateEntry;
+    const privateAt = tableOffset + privateOffset;
+    if (privateAt < tableOffset || privateAt + privateSize > tableEnd)
+        return [];
+    const privateDict = readCffDict(bytes, privateAt, privateAt + privateSize);
+    const subrsOffset = privateDict?.get(CFF_OPERATOR_SUBRS)?.[0];
+    if (subrsOffset === undefined)
+        return [];
+    // Relative to the PRIVATE dict, not the table. This is the base that is easy to get wrong.
+    const subrs = readCffIndex(bytes, privateAt + subrsOffset);
+    return subrs === null ? [] : subrs.entries;
+}
+// One local-subroutine pool per glyph, resolved through FDSelect into the FDArray. Returns the null
+// sentinel when either structure is unreadable, because a partial answer here binds some glyphs to the
+// wrong pool — which draws something rather than failing, and is the reason CID fonts were refused until
+// this landed.
+function readCffCidSubrs(bytes, top, tableOffset, tableEnd, glyphCount) {
+    const fdArrayOffset = top.get(CFF_OPERATOR_FD_ARRAY)?.[0];
+    const fdSelectOffset = top.get(CFF_OPERATOR_FD_SELECT)?.[0];
+    if (fdArrayOffset === undefined || fdSelectOffset === undefined)
+        return null;
+    const fdArray = readCffIndex(bytes, tableOffset + fdArrayOffset);
+    if (fdArray === null || fdArray.entries.length === 0)
+        return null;
+    // Each FDArray entry is a font DICT whose private DICT is read exactly as the non-CID top DICT's is —
+    // same operator, same table-relative base — so the two paths cannot drift apart in how they resolve it.
+    const pools = [];
+    for (const entry of fdArray.entries) {
+        const fontDict = readCffDict(bytes, entry.start, entry.end);
+        if (fontDict === null)
+            return null;
+        pools.push(readCffLocalSubrs(bytes, fontDict, tableOffset, tableEnd));
+    }
+    const select = readCffFdSelect(bytes, tableOffset + fdSelectOffset, glyphCount);
+    if (select === null)
+        return null;
+    const byGlyph = [];
+    for (let glyph = 0; glyph < glyphCount; glyph += 1) {
+        const pool = pools[select[glyph]];
+        // An FDSelect naming an FD the FDArray does not have is malformed. Defaulting to pool 0 would be the
+        // wrong-pool outcome wearing a reasonable-looking fallback.
+        if (pool === undefined)
+            return null;
+        byGlyph.push(pool);
+    }
+    return byGlyph;
+}
+// Returns the null sentinel for anything this package cannot read, INCLUDING a CID-keyed font. That is a
+// deliberate refusal rather than a gap: a CID font reaches its charstrings through an FDSelect/FDArray
+// indirection this package does not implement, so each glyph has its own private DICT and its own local
+// subroutines, and the single-private-DICT read below is not reading what it assumes it is.
+//
+// WHAT THE REFUSAL IS **NOT** JUSTIFIED BY, since the first version of this comment claimed it: it is not
+// established that such a font would fail silently. Measured instead of predicted — with no local
+// subroutine pool, a charstring that calls one returns false, which is a VISIBLE failure rather than
+// plausible garbage. Whether a given CID font lands there depends on whether its top DICT happens to
+// carry a private entry at all, and that is not something this reader can know in advance.
+// ⇒ SO THE REASON TO REFUSE IS THAT THE OUTCOME IS UNPREDICTABLE PER FONT, NOT THAT IT IS KNOWN TO BE
+// SILENT. That is the narrower claim and the one the evidence supports.
+export function readCffTable(bytes, directory) {
+    const table = directory.tables.get('CFF ');
+    if (table === undefined || table.length < 4)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    // The header states its own size, so a future revision with extra header fields still parses.
+    const headerSize = view.getUint8(table.offset + 2);
+    const tableEnd = table.offset + table.length;
+    const names = readCffIndex(bytes, table.offset + headerSize);
+    if (names === null)
+        return null;
+    const topDicts = readCffIndex(bytes, names.endOffset);
+    if (topDicts === null || topDicts.entries.length === 0)
+        return null;
+    const strings = readCffIndex(bytes, topDicts.endOffset);
+    if (strings === null)
+        return null;
+    const globals = readCffIndex(bytes, strings.endOffset);
+    if (globals === null)
+        return null;
+    const top = readCffDict(bytes, topDicts.entries[0].start, topDicts.entries[0].end);
+    if (top === null)
+        return null;
+    const charstringsOffset = top.get(CFF_OPERATOR_CHARSTRINGS)?.[0];
+    if (charstringsOffset === undefined)
+        return null;
+    const charstringsAt = table.offset + charstringsOffset;
+    if (charstringsAt < table.offset || charstringsAt >= tableEnd)
+        return null;
+    const charstrings = readCffIndex(bytes, charstringsAt);
+    if (charstrings === null)
+        return null;
+    // A CID-keyed font is several fonts in one table: an FDArray of font DICTs, each with its own private
+    // DICT and therefore ITS OWN local subroutine pool, plus an FDSelect saying which glyph uses which.
+    // Detected by the operators rather than by `ROS` alone, since the pools are what actually matter here.
+    const isCid = top.has(CFF_OPERATOR_FD_ARRAY) && top.has(CFF_OPERATOR_FD_SELECT);
+    if (isCid) {
+        const perGlyph = readCffCidSubrs(bytes, top, table.offset, tableEnd, charstrings.entries.length);
+        // Refused rather than fallen back to the single-pool read. A fallback here is the precise failure
+        // this branch exists to prevent: it would bind every glyph to one pool and draw plausible geometry.
+        if (perGlyph === null)
+            return null;
+        return {
+            charstrings: charstrings.entries,
+            globalSubrs: globals.entries,
+            localSubrs: [],
+            localSubrsByGlyph: perGlyph,
+        };
+    }
+    return {
+        charstrings: charstrings.entries,
+        globalSubrs: globals.entries,
+        localSubrs: readCffLocalSubrs(bytes, top, table.offset, tableEnd),
+        localSubrsByGlyph: null,
+    };
+}
+//# sourceMappingURL=cffTable.js.map

package/dist/cffTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cffTable.js","sourceRoot":"","sources":["../src/cffTable.ts"],"names":[],"mappings":"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"}

package/dist/contract.d.ts

@@ -0,0 +1,15 @@
+export * from './index';
+export { cffSubroutineBias, runCffCharstring } from './cffCharstring';
+export { CFF_OPERATOR_CHARSTRINGS, CFF_OPERATOR_FD_ARRAY, CFF_OPERATOR_FD_SELECT, CFF_OPERATOR_PRIVATE, CFF_OPERATOR_ROS, CFF_OPERATOR_SUBRS, readCffDict, } from './cffDict';
+export { readCffFdSelect } from './cffFdSelect';
+export { readCffIndex } from './cffIndex';
+export { readCffTable } from './cffTable';
+export { findOpenTypeUnicodeSubtable, rankOpenTypeUnicodeEncoding, readOpenTypeCodepointMap } from './openTypeCmap';
+export { readOpenTypeGlyphOutline, readOpenTypeGlyphRanges } from './openTypeGlyf';
+export { readOpenTypeAdvances, readOpenTypeGlyphCount, readOpenTypeLocaFormat, readOpenTypeMetrics, } from './openTypeMetrics';
+export { readSfntTableDirectory, readSfntTag } from './sfntTableDirectory';
+export { readWoffChecksumMismatches, readWoffFont, WOFF_COMPRESSION } from './woffFont';
+export { assembleSfntFont, computeSfntTableChecksum, packSfntTag } from './sfntAssembly';
+export { readWoff2Font, readWoff2TableDirectory, WOFF2_COMPRESSION } from './woff2Font';
+export { readWoff2GlyfStreams, readWoff2Short } from './woff2GlyfTransform';
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AACpH,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACnF,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/contract.js

@@ -0,0 +1,15 @@
+export * from './index';
+export { cffSubroutineBias, runCffCharstring } from './cffCharstring';
+export { CFF_OPERATOR_CHARSTRINGS, CFF_OPERATOR_FD_ARRAY, CFF_OPERATOR_FD_SELECT, CFF_OPERATOR_PRIVATE, CFF_OPERATOR_ROS, CFF_OPERATOR_SUBRS, readCffDict, } from './cffDict';
+export { readCffFdSelect } from './cffFdSelect';
+export { readCffIndex } from './cffIndex';
+export { readCffTable } from './cffTable';
+export { findOpenTypeUnicodeSubtable, rankOpenTypeUnicodeEncoding, readOpenTypeCodepointMap } from './openTypeCmap';
+export { readOpenTypeGlyphOutline, readOpenTypeGlyphRanges } from './openTypeGlyf';
+export { readOpenTypeAdvances, readOpenTypeGlyphCount, readOpenTypeLocaFormat, readOpenTypeMetrics, } from './openTypeMetrics';
+export { readSfntTableDirectory, readSfntTag } from './sfntTableDirectory';
+export { readWoffChecksumMismatches, readWoffFont, WOFF_COMPRESSION } from './woffFont';
+export { assembleSfntFont, computeSfntTableChecksum, packSfntTag } from './sfntAssembly';
+export { readWoff2Font, readWoff2TableDirectory, WOFF2_COMPRESSION } from './woff2Font';
+export { readWoff2GlyfStreams, readWoff2Short } from './woff2GlyfTransform';
+//# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AACpH,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACnF,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createGlyphOutlineSourceFromOpenTypeFont, explainOpenTypeFont } from './openTypeGlyphOutlineSource';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wCAAwC,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createGlyphOutlineSourceFromOpenTypeFont, explainOpenTypeFont } from './openTypeGlyphOutlineSource';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wCAAwC,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/openTypeCmap.d.ts

@@ -0,0 +1,5 @@
+import type { SfntTableDirectory } from '@flighthq/types/contract';
+export declare function findOpenTypeUnicodeSubtable(view: Readonly<DataView>, cmapOffset: number, cmapLength: number, byteLength: number): number;
+export declare function rankOpenTypeUnicodeEncoding(platform: number, encoding: number): number;
+export declare function readOpenTypeCodepointMap(bytes: Readonly<Uint8Array>, directory: Readonly<SfntTableDirectory>): Map<number, number> | null;
+//# sourceMappingURL=openTypeCmap.d.ts.map

package/dist/openTypeCmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openTypeCmap.d.ts","sourceRoot":"","sources":["../src/openTypeCmap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAyBnE,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,EACxB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAqBR;AAoBD,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMtF;AAKD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC3B,SAAS,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACtC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAY5B"}

package/dist/openTypeCmap.js

@@ -0,0 +1,161 @@
+// The codepoint → glyph-index map. `cmap` is a table of sub-tables, each tagged with a platform and
+// encoding, because a font may carry several mappings for different systems. Only the Unicode ones are
+// read here: the format's job is to say which glyph draws a codepoint, and the legacy platform-specific
+// encodings answer a different question that nothing in this SDK asks.
+//
+// Two sub-table formats are read, and between them they cover every modern font:
+//   format 4  — segmented ranges over the Basic Multilingual Plane. Effectively universal.
+//   format 12 — flat 32-bit groups, which is how anything above U+FFFF is reached at all.
+// A font carrying neither maps nothing, and every codepoint lookup returns -1 rather than guessing.
+// Picks the best Unicode sub-table the font offers, preferring one that can express codepoints above
+// the BMP. Returns -1 when the font declares no Unicode mapping this reader can read.
+//
+// Platform 3 encoding 10 and platform 0 encoding 4/6 are the full-repertoire mappings; platform 3
+// encoding 1 and platform 0 encodings 0-3 are BMP-only. Preferring the former matters for emoji and for
+// CJK extensions, which is exactly the material a BMP-only map silently drops.
+//
+// ★ READABILITY IS PART OF THE CHOICE, NOT A TEST APPLIED AFTERWARDS. Ranking on encoding alone picks
+// the widest-repertoire sub-table even when it is stored in a format this reader does not implement,
+// and the font is then refused whole while a readable sub-table sits beside it. That is not
+// hypothetical: a real font in this shape carries a readable format 4 at rank 1 and a format 0 at
+// rank 2, and ranking alone rejected the entire font. A narrower map that works beats a wider one that
+// cannot be read.
+export function findOpenTypeUnicodeSubtable(view, cmapOffset, cmapLength, byteLength) {
+    const recordCount = view.getUint16(cmapOffset + 2);
+    let best = -1;
+    let bestRank = -1;
+    for (let index = 0; index < recordCount; index += 1) {
+        const record = cmapOffset + 4 + index * 8;
+        if (record + 8 > cmapOffset + cmapLength || record + 8 > byteLength)
+            break;
+        const platform = view.getUint16(record);
+        const encoding = view.getUint16(record + 2);
+        const offset = cmapOffset + view.getUint32(record + 4);
+        if (offset + 4 > byteLength)
+            continue;
+        const rank = rankOpenTypeUnicodeEncoding(platform, encoding);
+        if (rank <= bestRank)
+            continue;
+        if (!isOpenTypeCmapFormatReadable(view.getUint16(offset)))
+            continue;
+        best = offset;
+        bestRank = rank;
+    }
+    return best;
+}
+// Whether `readOpenTypeCodepointMap` can turn this sub-table format into a map. Kept beside the chooser
+// because the two must agree: a format the chooser accepts and the reader then declines produces the
+// refusal this function exists to prevent.
+//
+// ★ FORMAT 6 IS ABSENT DELIBERATELY, AND ADDING IT WOULD BE UNREACHABLE CODE. A format 6 sub-table is
+// a trimmed 16-bit range, and in practice it is written at platform 1 encoding 0 — the legacy Macintosh
+// encoding, which `rankOpenTypeUnicodeEncoding` scores -1 as *not a Unicode mapping*. So the chooser
+// never offers one to this predicate, whatever it answers: the exclusion happens a layer earlier, for a
+// reason that has nothing to do with the format. Measured across a corpus of real system fonts rather
+// than assumed — every format 6 found sat at platform 1 encoding 0, and none would have been selected
+// over a readable rival. Implementing it would close nothing and add a branch no font reaches.
+// Format 14 is likewise absent on purpose: it carries variation-selector sequences, not a codepoint
+// map, so it answers a different question and is correctly scored out of the ranking too.
+function isOpenTypeCmapFormatReadable(format) {
+    return format === 4 || format === 12;
+}
+// 2 = full Unicode repertoire, 1 = BMP only, -1 = not a Unicode mapping.
+export function rankOpenTypeUnicodeEncoding(platform, encoding) {
+    if (platform === 3 && encoding === 10)
+        return 2;
+    if (platform === 0 && (encoding === 4 || encoding === 6))
+        return 2;
+    if (platform === 3 && encoding === 1)
+        return 1;
+    if (platform === 0 && encoding <= 3)
+        return 1;
+    return -1;
+}
+// Builds the map eagerly into a plain Map. A font's cmap is thousands of entries at most, and the
+// alternative — binary searching the encoded segments per lookup — trades a one-off parse for a cost on
+// every glyph, in a lookup that sits inside text layout.
+export function readOpenTypeCodepointMap(bytes, directory) {
+    const cmap = directory.tables.get('cmap');
+    if (cmap === undefined || cmap.length < 4)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const subtableOffset = findOpenTypeUnicodeSubtable(view, cmap.offset, cmap.length, bytes.byteLength);
+    if (subtableOffset === -1)
+        return null;
+    const format = view.getUint16(subtableOffset);
+    if (format === 4)
+        return readOpenTypeCmapFormat4(view, subtableOffset, bytes.byteLength);
+    if (format === 12)
+        return readOpenTypeCmapFormat12(view, subtableOffset, bytes.byteLength);
+    return null;
+}
+// Format 4: parallel arrays of segment ends, starts, deltas, and range offsets. A segment either adds a
+// constant delta to the codepoint or indexes into a glyph-id array that follows — the second form is
+// what lets a font map a scattered range without a segment per character.
+function readOpenTypeCmapFormat4(view, offset, byteLength) {
+    const map = new Map();
+    const segmentCount = view.getUint16(offset + 6) / 2;
+    const endsAt = offset + 14;
+    const startsAt = endsAt + segmentCount * 2 + 2;
+    const deltasAt = startsAt + segmentCount * 2;
+    const rangesAt = deltasAt + segmentCount * 2;
+    if (rangesAt + segmentCount * 2 > byteLength)
+        return map;
+    for (let segment = 0; segment < segmentCount; segment += 1) {
+        const end = view.getUint16(endsAt + segment * 2);
+        const start = view.getUint16(startsAt + segment * 2);
+        // The final segment is a required 0xFFFF terminator rather than real coverage.
+        if (start > end || start === 0xffff)
+            continue;
+        const delta = view.getInt16(deltasAt + segment * 2);
+        const rangeOffsetAt = rangesAt + segment * 2;
+        const rangeOffset = view.getUint16(rangeOffsetAt);
+        for (let codePoint = start; codePoint <= end; codePoint += 1) {
+            let glyph;
+            if (rangeOffset === 0) {
+                glyph = (codePoint + delta) & 0xffff;
+            }
+            else {
+                // The range offset is a byte distance from its OWN slot, which is why this is computed from
+                // `rangeOffsetAt` and not from the start of the table.
+                const glyphAt = rangeOffsetAt + rangeOffset + (codePoint - start) * 2;
+                if (glyphAt + 2 > byteLength)
+                    continue;
+                const raw = view.getUint16(glyphAt);
+                // A zero here means "no glyph" and must NOT have the delta applied, which would turn an absent
+                // glyph into a plausible wrong one.
+                if (raw === 0)
+                    continue;
+                glyph = (raw + delta) & 0xffff;
+            }
+            if (glyph !== 0)
+                map.set(codePoint, glyph);
+        }
+    }
+    return map;
+}
+// Format 12: flat groups of contiguous codepoints, each mapping to a contiguous run of glyph ids. The
+// only sub-table format that reaches past U+FFFF.
+function readOpenTypeCmapFormat12(view, offset, byteLength) {
+    const map = new Map();
+    if (offset + 16 > byteLength)
+        return map;
+    const groupCount = view.getUint32(offset + 12);
+    for (let group = 0; group < groupCount; group += 1) {
+        const record = offset + 16 + group * 12;
+        if (record + 12 > byteLength)
+            break;
+        const start = view.getUint32(record);
+        const end = view.getUint32(record + 4);
+        const startGlyph = view.getUint32(record + 8);
+        if (start > end)
+            continue;
+        for (let codePoint = start; codePoint <= end; codePoint += 1) {
+            const glyph = startGlyph + (codePoint - start);
+            if (glyph !== 0)
+                map.set(codePoint, glyph);
+        }
+    }
+    return map;
+}
+//# sourceMappingURL=openTypeCmap.js.map

package/dist/openTypeCmap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openTypeCmap.js","sourceRoot":"","sources":["../src/openTypeCmap.ts"],"names":[],"mappings":"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"}

package/dist/openTypeGlyf.d.ts

@@ -0,0 +1,4 @@
+import type { Path, SfntTableDirectory } from '@flighthq/types/contract';
+export declare function readOpenTypeGlyphOutline(out: Path, bytes: Readonly<Uint8Array>, directory: Readonly<SfntTableDirectory>, ranges: Readonly<Uint32Array>, glyphIndex: number): boolean;
+export declare function readOpenTypeGlyphRanges(bytes: Readonly<Uint8Array>, directory: Readonly<SfntTableDirectory>, glyphCount: number, locaFormat: number): Uint32Array | null;
+//# sourceMappingURL=openTypeGlyf.d.ts.map

package/dist/openTypeGlyf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openTypeGlyf.d.ts","sourceRoot":"","sources":["../src/openTypeGlyf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AA6BzE,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,IAAI,EACT,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC3B,SAAS,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACvC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC7B,UAAU,EAAE,MAAM,GACjB,OAAO,CAmDT;AAKD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC3B,SAAS,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACvC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,GAAG,IAAI,CAgBpB"}

package/dist/openTypeGlyf.js

@@ -0,0 +1,229 @@
+import { PathCommand } from '@flighthq/types/contract';
+// TrueType outlines: `loca` gives each glyph's byte range inside `glyf`, and a glyph is a set of closed
+// contours of points, each point flagged on-curve or off-curve.
+//
+// THE ONE THING THAT MAKES THIS FORMAT DIFFERENT FROM EVERY OTHER PATH FORMAT: consecutive off-curve
+// points imply an on-curve point exactly halfway between them. The format omits those midpoints because
+// they are recoverable, so a reader that treats the point list literally produces contours that visibly
+// cut corners. They are reconstructed below.
+//
+// Coordinates are design units, y-up in the font's own convention. `Path` is y-down, so y is negated at
+// this seam — once, here — which is what makes the produced outlines match `GlyphOutlineMetrics`'
+// documented "ink above the baseline has negative y".
+const ON_CURVE = 0x01;
+const X_SHORT = 0x02;
+const Y_SHORT = 0x04;
+const REPEAT = 0x08;
+const X_SAME_OR_POSITIVE = 0x10;
+const Y_SAME_OR_POSITIVE = 0x20;
+// Replaces `out` with one glyph's contours. Returns false for a glyph whose data is unreadable; returns
+// true with an empty path for a glyph that legitimately has no outline.
+//
+// Composite glyphs — an accented letter assembled from a base and a mark — are NOT expanded. They are
+// reported as an empty outline rather than as a failure, because the glyph exists and its advance is
+// still correct; only its ink is missing. Expanding them needs component transforms and is a deliberate
+// follow-up rather than something to half-do inside the simple-glyph reader.
+export function readOpenTypeGlyphOutline(out, bytes, directory, ranges, glyphIndex) {
+    const glyf = directory.tables.get('glyf');
+    if (glyf === undefined || glyphIndex < 0 || glyphIndex + 1 >= ranges.length)
+        return false;
+    out.commands.length = 0;
+    out.data.length = 0;
+    // `out` is REPLACED, so every field it owns is written — including this one. Both outline
+    // flavors fill by the nonzero rule, and a caller reusing a scratch path would otherwise keep
+    // whatever winding the previous glyph left, which turns a counter into a solid blob.
+    out.winding = 'nonZero';
+    const start = glyf.offset + ranges[glyphIndex];
+    const end = glyf.offset + ranges[glyphIndex + 1];
+    // An empty range is a glyph with no ink. True, not false: the caller still needs its advance.
+    if (end <= start)
+        return true;
+    if (end > bytes.byteLength || start + 10 > bytes.byteLength)
+        return false;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const contourCount = view.getInt16(start);
+    // Negative means composite. Empty outline, advance preserved — see above.
+    if (contourCount <= 0)
+        return true;
+    const endPoints = new Uint16Array(contourCount);
+    let cursor = start + 10;
+    if (cursor + contourCount * 2 + 2 > bytes.byteLength)
+        return false;
+    for (let contour = 0; contour < contourCount; contour += 1) {
+        endPoints[contour] = view.getUint16(cursor);
+        cursor += 2;
+    }
+    const pointCount = endPoints[contourCount - 1] + 1;
+    // Skip the hinting program: this package produces unhinted design-unit outlines by charter.
+    cursor += 2 + view.getUint16(cursor);
+    const flags = readGlyfFlags(view, cursor, pointCount, bytes.byteLength);
+    if (flags === null)
+        return false;
+    cursor = flags.cursor;
+    const xs = readGlyfCoordinates(view, cursor, flags.flags, X_SHORT, X_SAME_OR_POSITIVE, bytes.byteLength);
+    if (xs === null)
+        return false;
+    const ys = readGlyfCoordinates(view, xs.cursor, flags.flags, Y_SHORT, Y_SAME_OR_POSITIVE, bytes.byteLength);
+    if (ys === null)
+        return false;
+    let first = 0;
+    for (let contour = 0; contour < contourCount; contour += 1) {
+        const last = endPoints[contour];
+        if (last >= pointCount)
+            return false;
+        appendGlyfContour(out, flags.flags, xs.values, ys.values, first, last);
+        first = last + 1;
+    }
+    return true;
+}
+// Byte ranges of every glyph, indexed by glyph id, with one extra trailing entry so glyph `n` spans
+// `[offsets[n], offsets[n + 1])`. An empty span is a real and common answer — a space has no outline —
+// and is preserved rather than dropped, because the glyph still exists and still advances.
+export function readOpenTypeGlyphRanges(bytes, directory, glyphCount, locaFormat) {
+    const loca = directory.tables.get('loca');
+    if (loca === undefined)
+        return null;
+    const entryCount = glyphCount + 1;
+    const entryBytes = locaFormat === 0 ? 2 : 4;
+    if (entryCount * entryBytes > loca.length)
+        return null;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const offsets = new Uint32Array(entryCount);
+    for (let index = 0; index < entryCount; index += 1) {
+        // The short form stores HALVED offsets, which is the whole reason the format flag exists.
+        offsets[index] =
+            locaFormat === 0 ? view.getUint16(loca.offset + index * 2) * 2 : view.getUint32(loca.offset + index * 4);
+    }
+    return offsets;
+}
+// One closed contour, with the implied on-curve midpoints reconstructed.
+//
+// The contour may begin on an off-curve point, in which case the true start is either the last point
+// (if that one is on-curve) or the midpoint between the two. Getting this wrong rotates the whole
+// contour by one point and is invisible on a circle while obvious on a letter.
+function appendGlyfContour(out, flags, xs, ys, first, last) {
+    const count = last - first + 1;
+    if (count <= 0)
+        return;
+    const onCurve = (index) => (flags[first + (((index % count) + count) % count)] & ON_CURVE) !== 0;
+    const pointX = (index) => xs[first + (((index % count) + count) % count)];
+    // y is negated here — the single place the font's y-up convention becomes `Path`'s y-down.
+    const pointY = (index) => -ys[first + (((index % count) + count) % count)];
+    let startX;
+    let startY;
+    let startIndex;
+    // How many points remain to be traversed after the start. When the start IS one of the contour's
+    // points, that point must not be walked again — traversing all `count` would emit a zero-length
+    // segment back onto the start that `CLOSE` already implies. Only the synthesized-midpoint start,
+    // which is not a point of the contour, leaves all `count` still to visit.
+    let stepCount;
+    if (onCurve(0)) {
+        startX = pointX(0);
+        startY = pointY(0);
+        startIndex = 1;
+        stepCount = count - 1;
+    }
+    else if (onCurve(count - 1)) {
+        startX = pointX(count - 1);
+        startY = pointY(count - 1);
+        startIndex = 0;
+        stepCount = count - 1;
+    }
+    else {
+        startX = (pointX(0) + pointX(count - 1)) / 2;
+        startY = (pointY(0) + pointY(count - 1)) / 2;
+        startIndex = 0;
+        stepCount = count;
+    }
+    out.commands.push(PathCommand.MOVE_TO);
+    out.data.push(startX, startY);
+    let controlX = 0;
+    let controlY = 0;
+    let hasControl = false;
+    for (let step = 0; step < stepCount; step += 1) {
+        const index = startIndex + step;
+        const x = pointX(index);
+        const y = pointY(index);
+        if (onCurve(index)) {
+            if (hasControl) {
+                out.commands.push(PathCommand.CURVE_TO);
+                out.data.push(controlX, controlY, x, y);
+                hasControl = false;
+            }
+            else {
+                out.commands.push(PathCommand.LINE_TO);
+                out.data.push(x, y);
+            }
+            continue;
+        }
+        // Two off-curve points in a row: the on-curve point between them was omitted because it is exactly
+        // their midpoint. Emit it, then carry this point as the next control.
+        if (hasControl) {
+            out.commands.push(PathCommand.CURVE_TO);
+            out.data.push(controlX, controlY, (controlX + x) / 2, (controlY + y) / 2);
+        }
+        controlX = x;
+        controlY = y;
+        hasControl = true;
+    }
+    // Close back onto the start, through a trailing control point when the contour ended off-curve.
+    if (hasControl) {
+        out.commands.push(PathCommand.CURVE_TO);
+        out.data.push(controlX, controlY, startX, startY);
+    }
+    out.commands.push(PathCommand.CLOSE);
+}
+// Flags are run-length encoded: a flag with REPEAT set is followed by a count of additional points
+// carrying the same flag. Reading them as one byte per point desynchronizes every coordinate after the
+// first repeat, which is why this is expanded before any coordinate is touched.
+function readGlyfFlags(view, start, pointCount, byteLength) {
+    const flags = new Uint8Array(pointCount);
+    let cursor = start;
+    for (let point = 0; point < pointCount;) {
+        if (cursor >= byteLength)
+            return null;
+        const flag = view.getUint8(cursor);
+        cursor += 1;
+        flags[point] = flag;
+        point += 1;
+        if ((flag & REPEAT) === 0)
+            continue;
+        if (cursor >= byteLength)
+            return null;
+        let repeats = view.getUint8(cursor);
+        cursor += 1;
+        while (repeats > 0 && point < pointCount) {
+            flags[point] = flag;
+            point += 1;
+            repeats -= 1;
+        }
+    }
+    return { cursor, flags };
+}
+// Coordinates are stored as DELTAS, in one of three widths chosen per point by two flag bits: one byte
+// with the sign carried by the second bit, two bytes signed, or omitted entirely to mean "unchanged
+// from the previous point". Accumulated into absolute values here.
+function readGlyfCoordinates(view, start, flags, shortBit, sameOrPositiveBit, byteLength) {
+    const values = new Int32Array(flags.length);
+    let cursor = start;
+    let value = 0;
+    for (let point = 0; point < flags.length; point += 1) {
+        const flag = flags[point];
+        if ((flag & shortBit) !== 0) {
+            if (cursor >= byteLength)
+                return null;
+            const magnitude = view.getUint8(cursor);
+            cursor += 1;
+            value += (flag & sameOrPositiveBit) !== 0 ? magnitude : -magnitude;
+        }
+        else if ((flag & sameOrPositiveBit) === 0) {
+            if (cursor + 2 > byteLength)
+                return null;
+            value += view.getInt16(cursor);
+            cursor += 2;
+        }
+        values[point] = value;
+    }
+    return { cursor, values };
+}
+//# sourceMappingURL=openTypeGlyf.js.map