imagescript 1.3.1 → 3.1.0

package/dist/render/font.js

@@ -0,0 +1,954 @@
+export class Font {
+    data;
+    view;
+    tables;
+    unitsPerEm;
+    indexToLocFormat;
+    ascender;
+    descender;
+    lineGap;
+    numberOfHMetrics;
+    numGlyphs;
+    outlines;
+    cff = null;
+    cmap;
+    outlineCache;
+    kerning;
+    constructor(data) {
+        this.data = data;
+        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        let offset = 0;
+        const signature = this.u32(0);
+        if (signature === 0x74746366)
+            offset = this.u32(12);
+        else if (signature === 0x774f4646 || signature === 0x774f4632)
+            throw new Error('Font: WOFF fonts are not supported');
+        const version = this.u32(offset);
+        if (version !== 0x00010000 && version !== 0x4f54544f && version !== 0x74727565)
+            throw new Error('Font: invalid font file');
+        this.tables = {};
+        const count = this.u16(offset + 4);
+        for (let i = 0; i < count; i++) {
+            const record = offset + 12 + i * 16;
+            const tag = String.fromCharCode(...data.subarray(record, record + 4));
+            this.tables[tag] = { offset: this.u32(record + 8), length: this.u32(record + 12) };
+        }
+        for (const tag of ['head', 'hhea', 'hmtx', 'maxp', 'cmap'])
+            if (!this.tables[tag])
+                throw new Error(`Font: missing ${tag} table`);
+        const head = this.tables.head.offset;
+        this.unitsPerEm = this.u16(head + 18);
+        this.indexToLocFormat = this.i16(head + 50);
+        const hhea = this.tables.hhea.offset;
+        this.ascender = this.i16(hhea + 4);
+        this.descender = this.i16(hhea + 6);
+        this.lineGap = this.i16(hhea + 8);
+        this.numberOfHMetrics = this.u16(hhea + 34);
+        this.numGlyphs = this.u16(this.tables.maxp.offset + 4);
+        if (this.tables.glyf && this.tables.loca)
+            this.outlines = 'glyf';
+        else if (this.tables['CFF ']) {
+            this.outlines = 'cff';
+            this.cff = parseCFF(this, this.tables['CFF '].offset);
+        }
+        else if (this.tables.CFF2)
+            throw new Error('Font: CFF2 outlines are not supported');
+        else
+            throw new Error('Font: no supported glyph outlines');
+        this.cmap = parseCmap(this, this.tables.cmap.offset);
+        this.outlineCache = new Map();
+        this.kerning = (this.tables.GPOS && parseGPOSKerning(this, this.tables.GPOS.offset)) || (this.tables.kern && parseKern(this, this.tables.kern.offset)) || null;
+    }
+    u8(o) { return this.data[o]; }
+    i8(o) { return this.view.getInt8(o); }
+    u16(o) { return this.view.getUint16(o); }
+    i16(o) { return this.view.getInt16(o); }
+    u32(o) { return this.view.getUint32(o); }
+    i32(o) { return this.view.getInt32(o); }
+    glyphIndex(codepoint) {
+        return this.cmap(codepoint) || 0;
+    }
+    advance(glyph) {
+        const hmtx = this.tables.hmtx.offset;
+        const index = Math.min(glyph, this.numberOfHMetrics - 1);
+        return this.u16(hmtx + index * 4);
+    }
+    leftSideBearing(glyph) {
+        const hmtx = this.tables.hmtx.offset;
+        if (glyph < this.numberOfHMetrics)
+            return this.i16(hmtx + glyph * 4 + 2);
+        return this.i16(hmtx + this.numberOfHMetrics * 4 + (glyph - this.numberOfHMetrics) * 2);
+    }
+    glyfPoints(glyph) {
+        if (this.outlines !== 'glyf' || glyph >= this.numGlyphs)
+            return null;
+        const loca = this.tables.loca.offset;
+        const start = this.indexToLocFormat ? this.u32(loca + glyph * 4) : this.u16(loca + glyph * 2) * 2;
+        const end = this.indexToLocFormat ? this.u32(loca + glyph * 4 + 4) : this.u16(loca + glyph * 2 + 2) * 2;
+        if (end <= start)
+            return null;
+        const offset = this.tables.glyf.offset + start;
+        const contourCount = this.i16(offset);
+        const xMin = this.i16(offset + 2);
+        if (contourCount < 0) {
+            const components = [];
+            let p = offset + 10, flags = 0;
+            do {
+                flags = this.u16(p);
+                const component = this.u16(p + 2);
+                p += 4;
+                let arg1, arg2;
+                if (flags & 1) {
+                    arg1 = flags & 2 ? this.i16(p) : this.u16(p);
+                    arg2 = flags & 2 ? this.i16(p + 2) : this.u16(p + 2);
+                    p += 4;
+                }
+                else {
+                    arg1 = flags & 2 ? this.i8(p) : this.u8(p);
+                    arg2 = flags & 2 ? this.i8(p + 1) : this.u8(p + 1);
+                    p += 2;
+                }
+                let matrix = [1, 0, 0, 1];
+                const f2dot14 = (o) => this.i16(o) / 16384;
+                if (flags & 8) {
+                    const s = f2dot14(p);
+                    matrix = [s, 0, 0, s];
+                    p += 2;
+                }
+                else if (flags & 0x40) {
+                    matrix = [f2dot14(p), 0, 0, f2dot14(p + 2)];
+                    p += 4;
+                }
+                else if (flags & 0x80) {
+                    matrix = [f2dot14(p), f2dot14(p + 2), f2dot14(p + 4), f2dot14(p + 6)];
+                    p += 8;
+                }
+                components.push({
+                    glyph: component,
+                    dx: flags & 2 ? arg1 : 0,
+                    dy: flags & 2 ? arg2 : 0,
+                    matrix,
+                    round: (flags & 4) !== 0,
+                    match: flags & 2 ? null : [arg1, arg2],
+                    useMetrics: (flags & 0x200) !== 0
+                });
+            } while (flags & 0x20);
+            const instructions = flags & 0x100 ? this.data.subarray(p + 2, p + 2 + this.u16(p)) : new Uint8Array(0);
+            return { xs: [], ys: [], on: [], ends: [], instructions, xMin, components };
+        }
+        const ends = [];
+        for (let i = 0; i < contourCount; i++)
+            ends.push(this.u16(offset + 10 + i * 2));
+        const pointCount = contourCount ? ends[contourCount - 1] + 1 : 0;
+        let p = offset + 10 + contourCount * 2;
+        const instructionLength = this.u16(p);
+        const instructions = this.data.subarray(p + 2, p + 2 + instructionLength);
+        p += 2 + instructionLength;
+        const flags = new Uint8Array(pointCount);
+        for (let i = 0; i < pointCount;) {
+            const flag = this.u8(p++);
+            flags[i++] = flag;
+            if (flag & 8)
+                for (let repeat = this.u8(p++); repeat > 0 && i < pointCount; repeat--)
+                    flags[i++] = flag;
+        }
+        const xs = [], ys = [];
+        for (const [coords, short, same] of [[xs, 2, 16], [ys, 4, 32]]) {
+            let value = 0;
+            for (let i = 0; i < pointCount; i++) {
+                const flag = flags[i];
+                if (flag & short) {
+                    const delta = this.u8(p++);
+                    value += flag & same ? delta : -delta;
+                }
+                else if (!(flag & same)) {
+                    value += this.i16(p);
+                    p += 2;
+                }
+                coords.push(value);
+            }
+        }
+        return { xs, ys, on: Array.from(flags, f => (f & 1) === 1), ends, instructions, xMin, components: null };
+    }
+    outline(glyph) {
+        if (glyph >= this.numGlyphs)
+            glyph = 0;
+        let path = this.outlineCache.get(glyph);
+        if (!path) {
+            path = this.outlines === 'glyf' ? this.glyfOutline(glyph, 0) : this.cffOutline(glyph);
+            this.outlineCache.set(glyph, path);
+        }
+        return path;
+    }
+    glyfOutline(glyph, depth) {
+        if (depth > 8)
+            return [];
+        const loca = this.tables.loca.offset;
+        const start = this.indexToLocFormat ? this.u32(loca + glyph * 4) : this.u16(loca + glyph * 2) * 2;
+        const end = this.indexToLocFormat ? this.u32(loca + glyph * 4 + 4) : this.u16(loca + glyph * 2 + 2) * 2;
+        if (end <= start)
+            return [];
+        const offset = this.tables.glyf.offset + start;
+        const contours = this.i16(offset);
+        return contours >= 0 ? this.simpleGlyph(offset, contours) : this.compositeGlyph(offset, depth);
+    }
+    simpleGlyph(offset, contourCount) {
+        const endPoints = [];
+        for (let i = 0; i < contourCount; i++)
+            endPoints.push(this.u16(offset + 10 + i * 2));
+        const pointCount = contourCount ? endPoints[contourCount - 1] + 1 : 0;
+        let p = offset + 10 + contourCount * 2;
+        p += 2 + this.u16(p);
+        const flags = new Uint8Array(pointCount);
+        for (let i = 0; i < pointCount;) {
+            const flag = this.u8(p++);
+            flags[i++] = flag;
+            if (flag & 8) {
+                for (let repeat = this.u8(p++); repeat > 0 && i < pointCount; repeat--)
+                    flags[i++] = flag;
+            }
+        }
+        const xs = new Int32Array(pointCount);
+        const ys = new Int32Array(pointCount);
+        for (const [coords, short, same] of [[xs, 2, 16], [ys, 4, 32]]) {
+            let value = 0;
+            for (let i = 0; i < pointCount; i++) {
+                const flag = flags[i];
+                if (flag & short) {
+                    const delta = this.u8(p++);
+                    value += flag & same ? delta : -delta;
+                }
+                else if (!(flag & same)) {
+                    value += this.i16(p);
+                    p += 2;
+                }
+                coords[i] = value;
+            }
+        }
+        const path = [];
+        let first = 0;
+        for (const last of endPoints) {
+            contourToPath(path, xs, ys, flags, first, last);
+            first = last + 1;
+        }
+        return path;
+    }
+    compositeGlyph(offset, depth) {
+        const path = [];
+        let p = offset + 10;
+        for (let more = true; more;) {
+            const flags = this.u16(p);
+            const glyph = this.u16(p + 2);
+            p += 4;
+            let dx, dy;
+            if (flags & 1) {
+                dx = flags & 2 ? this.i16(p) : this.u16(p);
+                dy = flags & 2 ? this.i16(p + 2) : this.u16(p + 2);
+                p += 4;
+            }
+            else {
+                dx = flags & 2 ? this.i8(p) : this.u8(p);
+                dy = flags & 2 ? this.i8(p + 1) : this.u8(p + 1);
+                p += 2;
+            }
+            if (!(flags & 2))
+                dx = dy = 0;
+            let a = 1, b = 0, c = 0, d = 1;
+            const f2dot14 = (o) => this.i16(o) / 16384;
+            if (flags & 8) {
+                a = d = f2dot14(p);
+                p += 2;
+            }
+            else if (flags & 0x40) {
+                a = f2dot14(p);
+                d = f2dot14(p + 2);
+                p += 4;
+            }
+            else if (flags & 0x80) {
+                a = f2dot14(p);
+                b = f2dot14(p + 2);
+                c = f2dot14(p + 4);
+                d = f2dot14(p + 6);
+                p += 8;
+            }
+            for (const command of this.glyfOutline(glyph, depth + 1)) {
+                const transformed = [command[0]];
+                for (let i = 1; i < command.length; i += 2) {
+                    const x = command[i], y = command[i + 1];
+                    transformed.push(a * x + c * y + dx, b * x + d * y + dy);
+                }
+                path.push(transformed);
+            }
+            more = !!(flags & 0x20);
+        }
+        return path;
+    }
+    cffOutline(glyph) {
+        return cffCharString(this.cff, glyph);
+    }
+}
+export function contourToPath(path, xs, ys, flags, first, last) {
+    if (last < first)
+        return;
+    const count = last - first + 1;
+    const on = (i) => flags[first + (i % count)] === true || (flags[first + (i % count)] & 1) === 1;
+    const x = (i) => xs[first + (i % count)];
+    const y = (i) => ys[first + (i % count)];
+    let start = -1;
+    for (let i = 0; i < count; i++)
+        if (on(i)) {
+            start = i;
+            break;
+        }
+    let sx, sy;
+    if (start === -1) {
+        sx = (x(0) + x(1)) / 2;
+        sy = (y(0) + y(1)) / 2;
+        start = 1;
+    }
+    else {
+        sx = x(start);
+        sy = y(start);
+        start++;
+    }
+    path.push(['M', sx, sy]);
+    let cx = 0, cy = 0, pending = false;
+    for (let n = 0; n < count; n++) {
+        const i = start + n;
+        const px = x(i), py = y(i);
+        if (on(i)) {
+            if (!pending)
+                path.push(['L', px, py]);
+            else {
+                path.push(['Q', cx, cy, px, py]);
+                pending = false;
+            }
+        }
+        else {
+            if (pending) {
+                const mx = (cx + px) / 2, my = (cy + py) / 2;
+                path.push(['Q', cx, cy, mx, my]);
+            }
+            cx = px;
+            cy = py;
+            pending = true;
+        }
+    }
+    if (pending)
+        path.push(['Q', cx, cy, sx, sy]);
+    path.push(['Z']);
+}
+function parseCmap(font, offset) {
+    const count = font.u16(offset + 2);
+    const subtables = [];
+    for (let i = 0; i < count; i++) {
+        const record = offset + 4 + i * 8;
+        const platform = font.u16(record);
+        const encoding = font.u16(record + 2);
+        const table = offset + font.u32(record + 4);
+        subtables.push({ platform, encoding, table, format: font.u16(table) });
+    }
+    const rank = ({ platform, encoding, format }) => {
+        if (![0, 4, 6, 12].includes(format))
+            return -1;
+        if (platform === 3 && encoding === 10)
+            return 6;
+        if (platform === 0 && (encoding === 4 || encoding === 6))
+            return 5;
+        if (platform === 3 && encoding === 1)
+            return 4;
+        if (platform === 0)
+            return 3;
+        if (platform === 3 && encoding === 0)
+            return 2;
+        if (platform === 1 && encoding === 0)
+            return 1;
+        return -1;
+    };
+    const best = subtables.filter(s => rank(s) >= 0).sort((a, b) => rank(b) - rank(a))[0];
+    if (!best)
+        throw new Error('Font: no supported character map');
+    const { table, format, platform, encoding } = best;
+    const symbol = platform === 3 && encoding === 0;
+    let lookup;
+    if (format === 0)
+        lookup = (c) => c < 256 ? font.u8(table + 6 + c) : 0;
+    else if (format === 6) {
+        const first = font.u16(table + 6), entries = font.u16(table + 8);
+        lookup = (c) => c >= first && c < first + entries ? font.u16(table + 10 + (c - first) * 2) : 0;
+    }
+    else if (format === 4) {
+        const segments = font.u16(table + 6) / 2;
+        const ends = table + 14;
+        const starts = ends + segments * 2 + 2;
+        const deltas = starts + segments * 2;
+        const rangeOffsets = deltas + segments * 2;
+        lookup = (c) => {
+            if (c > 0xffff)
+                return 0;
+            let lo = 0, hi = segments - 1;
+            while (lo < hi) {
+                const mid = lo + hi >> 1;
+                if (font.u16(ends + mid * 2) < c)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            }
+            const start = font.u16(starts + lo * 2);
+            if (c < start || c > font.u16(ends + lo * 2))
+                return 0;
+            const delta = font.u16(deltas + lo * 2);
+            const rangeOffset = font.u16(rangeOffsets + lo * 2);
+            if (!rangeOffset)
+                return c + delta & 0xffff;
+            const glyph = font.u16(rangeOffsets + lo * 2 + rangeOffset + (c - start) * 2);
+            return glyph ? glyph + delta & 0xffff : 0;
+        };
+    }
+    else {
+        const groups = font.u32(table + 12);
+        lookup = (c) => {
+            let lo = 0, hi = groups - 1;
+            while (lo <= hi) {
+                const mid = lo + hi >> 1;
+                const group = table + 16 + mid * 12;
+                if (c < font.u32(group))
+                    hi = mid - 1;
+                else if (c > font.u32(group + 4))
+                    lo = mid + 1;
+                else
+                    return font.u32(group + 8) + c - font.u32(group);
+            }
+            return 0;
+        };
+    }
+    return symbol ? (c) => lookup(c) || (c < 256 ? lookup(0xf000 + c) : 0) : lookup;
+}
+function parseGPOSKerning(font, gpos) {
+    const featureList = gpos + font.u16(gpos + 6);
+    const lookupList = gpos + font.u16(gpos + 8);
+    const lookups = new Set();
+    for (let i = 0, count = font.u16(featureList); i < count; i++) {
+        const record = featureList + 2 + i * 6;
+        if (font.u32(record) !== 0x6b65726e)
+            continue;
+        const feature = featureList + font.u16(record + 4);
+        for (let j = 0, n = font.u16(feature + 2); j < n; j++)
+            lookups.add(font.u16(feature + 4 + j * 2));
+    }
+    const pairLookups = [];
+    for (const index of [...lookups].sort((a, b) => a - b)) {
+        if (index >= font.u16(lookupList))
+            continue;
+        const lookup = lookupList + font.u16(lookupList + 2 + index * 2);
+        const type = font.u16(lookup);
+        const subtables = [];
+        for (let i = 0, count = font.u16(lookup + 4); i < count; i++) {
+            let subtable = lookup + font.u16(lookup + 6 + i * 2);
+            if (type === 9) {
+                if (font.u16(subtable + 2) !== 2)
+                    continue;
+                subtable += font.u32(subtable + 4);
+            }
+            else if (type !== 2)
+                continue;
+            const pair = parsePairPos(font, subtable);
+            if (pair)
+                subtables.push(pair);
+        }
+        if (subtables.length)
+            pairLookups.push(subtables);
+    }
+    if (!pairLookups.length)
+        return null;
+    return (left, right) => {
+        let total = 0;
+        for (const subtables of pairLookups) {
+            for (const subtable of subtables) {
+                const value = subtable(left, right);
+                if (value === undefined)
+                    continue;
+                total += value;
+                break;
+            }
+        }
+        return total;
+    };
+}
+function valueRecord(format) {
+    let size = 0, xAdvance = -1;
+    for (let bit = 0; bit < 8; bit++) {
+        if (!(format & 1 << bit))
+            continue;
+        if (bit === 2)
+            xAdvance = size;
+        size += 2;
+    }
+    return { size, xAdvance };
+}
+function parsePairPos(font, table) {
+    const format = font.u16(table);
+    const coverage = parseCoverage(font, table + font.u16(table + 2));
+    const first = valueRecord(font.u16(table + 4));
+    const second = valueRecord(font.u16(table + 6));
+    if (first.xAdvance === -1)
+        return null;
+    if (format === 1) {
+        const sets = font.u16(table + 8);
+        const recordSize = 2 + first.size + second.size;
+        return (left, right) => {
+            const index = coverage(left);
+            if (index === -1 || index >= sets)
+                return undefined;
+            const set = table + font.u16(table + 10 + index * 2);
+            let lo = 0, hi = font.u16(set) - 1;
+            while (lo <= hi) {
+                const mid = lo + hi >> 1;
+                const record = set + 2 + mid * recordSize;
+                const glyph = font.u16(record);
+                if (glyph < right)
+                    lo = mid + 1;
+                else if (glyph > right)
+                    hi = mid - 1;
+                else
+                    return font.i16(record + 2 + first.xAdvance);
+            }
+            return undefined;
+        };
+    }
+    if (format === 2) {
+        const classes1 = parseClassDef(font, table + font.u16(table + 8));
+        const classes2 = parseClassDef(font, table + font.u16(table + 10));
+        const class1Count = font.u16(table + 12), class2Count = font.u16(table + 14);
+        const recordSize = first.size + second.size;
+        return (left, right) => {
+            if (coverage(left) === -1)
+                return undefined;
+            const c1 = classes1(left), c2 = classes2(right);
+            if (c1 >= class1Count || c2 >= class2Count)
+                return undefined;
+            return font.i16(table + 16 + (c1 * class2Count + c2) * recordSize + first.xAdvance);
+        };
+    }
+    return null;
+}
+function parseCoverage(font, table) {
+    const format = font.u16(table), count = font.u16(table + 2);
+    return glyph => {
+        let lo = 0, hi = count - 1;
+        while (lo <= hi) {
+            const mid = lo + hi >> 1;
+            if (format === 1) {
+                const value = font.u16(table + 4 + mid * 2);
+                if (value < glyph)
+                    lo = mid + 1;
+                else if (value > glyph)
+                    hi = mid - 1;
+                else
+                    return mid;
+            }
+            else {
+                const range = table + 4 + mid * 6;
+                if (font.u16(range + 2) < glyph)
+                    lo = mid + 1;
+                else if (font.u16(range) > glyph)
+                    hi = mid - 1;
+                else
+                    return font.u16(range + 4) + glyph - font.u16(range);
+            }
+        }
+        return -1;
+    };
+}
+function parseClassDef(font, table) {
+    const format = font.u16(table);
+    if (format === 1) {
+        const start = font.u16(table + 2), count = font.u16(table + 4);
+        return glyph => glyph >= start && glyph < start + count ? font.u16(table + 6 + (glyph - start) * 2) : 0;
+    }
+    const count = font.u16(table + 2);
+    return glyph => {
+        let lo = 0, hi = count - 1;
+        while (lo <= hi) {
+            const mid = lo + hi >> 1;
+            const range = table + 4 + mid * 6;
+            if (font.u16(range + 2) < glyph)
+                lo = mid + 1;
+            else if (font.u16(range) > glyph)
+                hi = mid - 1;
+            else
+                return font.u16(range + 4);
+        }
+        return 0;
+    };
+}
+function parseKern(font, kern) {
+    if (font.u16(kern) !== 0)
+        return null;
+    const tables = [];
+    let offset = kern + 4;
+    for (let i = 0, count = font.u16(kern + 2); i < count; i++) {
+        const coverage = font.u16(offset + 4);
+        const length = coverage >> 8 === 0 ? 14 + font.u16(offset + 6) * 6 : font.u16(offset + 2);
+        if ((coverage & 0xff0f) === 1)
+            tables.push({ pairs: font.u16(offset + 6), start: offset + 14 });
+        offset += length;
+    }
+    if (!tables.length)
+        return null;
+    return (left, right) => {
+        const key = (left << 16 | right) >>> 0;
+        let total = 0;
+        for (const { pairs, start } of tables) {
+            let lo = 0, hi = pairs - 1;
+            while (lo <= hi) {
+                const mid = lo + hi >> 1;
+                const pair = start + mid * 6;
+                const value = font.u32(pair);
+                if (value < key)
+                    lo = mid + 1;
+                else if (value > key)
+                    hi = mid - 1;
+                else {
+                    total += font.i16(pair + 4);
+                    break;
+                }
+            }
+        }
+        return total;
+    };
+}
+function parseCFF(font, base) {
+    const data = font.data;
+    const readIndex = (offset) => {
+        const count = font.u16(offset);
+        if (count === 0)
+            return { items: [], end: offset + 2 };
+        const offSize = data[offset + 2];
+        const readOffset = (o) => {
+            let v = 0;
+            for (let i = 0; i < offSize; i++)
+                v = v * 256 + data[o + i];
+            return v;
+        };
+        const dataStart = offset + 3 + (count + 1) * offSize - 1;
+        const items = [];
+        for (let i = 0; i < count; i++) {
+            const start = dataStart + readOffset(offset + 3 + i * offSize);
+            const end = dataStart + readOffset(offset + 3 + (i + 1) * offSize);
+            items.push(data.subarray(start, end));
+        }
+        return { items, end: dataStart + readOffset(offset + 3 + count * offSize) };
+    };
+    const headerSize = data[base + 2];
+    const names = readIndex(base + headerSize);
+    const topDicts = readIndex(names.end);
+    const strings = readIndex(topDicts.end);
+    const globalSubrs = readIndex(strings.end).items;
+    const top = parseDict(topDicts.items[0]);
+    if (!top[17])
+        throw new Error('Font: CFF font has no charstrings');
+    const charStrings = readIndex(base + top[17][0]).items;
+    const readPrivate = (entry) => {
+        if (!entry)
+            return { subrs: [] };
+        const [size, offset] = entry;
+        const dict = parseDict(data.subarray(base + offset, base + offset + size));
+        const subrs = dict[19] ? readIndex(base + offset + dict[19][0]).items : [];
+        return { subrs };
+    };
+    let privateFor;
+    if (top[1236]) {
+        const fdArray = readIndex(base + top[1236][0]).items.map(dict => readPrivate(parseDict(dict)[18]));
+        const fdSelect = base + top[1237][0];
+        const format = data[fdSelect];
+        privateFor = glyph => {
+            if (format === 0)
+                return fdArray[data[fdSelect + 1 + glyph]];
+            const ranges = font.u16(fdSelect + 1);
+            for (let i = 0; i < ranges; i++) {
+                const r = fdSelect + 3 + i * 3;
+                const next = font.u16(r + 3);
+                if (glyph >= font.u16(r) && glyph < next)
+                    return fdArray[data[r + 2]];
+            }
+            return fdArray[0];
+        };
+    }
+    else {
+        const shared = readPrivate(top[18]);
+        privateFor = () => shared;
+    }
+    return { charStrings, globalSubrs, privateFor };
+}
+function parseDict(bytes) {
+    const dict = {};
+    const operands = [];
+    for (let i = 0; i < bytes.length;) {
+        const b0 = bytes[i++];
+        if (b0 <= 21) {
+            const op = b0 === 12 ? 1200 + bytes[i++] : b0;
+            dict[op] = operands.splice(0);
+        }
+        else if (b0 === 28) {
+            operands.push((bytes[i] << 24 | bytes[i + 1] << 16) >> 16);
+            i += 2;
+        }
+        else if (b0 === 29) {
+            operands.push(bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]);
+            i += 4;
+        }
+        else if (b0 === 30) {
+            let s = '';
+            for (let done = false; !done;) {
+                const byte = bytes[i++];
+                for (const nibble of [byte >> 4, byte & 15]) {
+                    if (nibble === 15) {
+                        done = true;
+                        break;
+                    }
+                    s += ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', 'E', 'E-', '', '-'][nibble];
+                }
+            }
+            operands.push(parseFloat(s));
+        }
+        else if (b0 >= 32 && b0 <= 246)
+            operands.push(b0 - 139);
+        else if (b0 >= 247 && b0 <= 250)
+            operands.push((b0 - 247) * 256 + bytes[i++] + 108);
+        else if (b0 >= 251 && b0 <= 254)
+            operands.push(-(b0 - 251) * 256 - bytes[i++] - 108);
+    }
+    return dict;
+}
+function subrBias(count) {
+    return count < 1240 ? 107 : count < 33900 ? 1131 : 32768;
+}
+function cffCharString(cff, glyph) {
+    const code = cff.charStrings[glyph];
+    if (!code)
+        return [];
+    const { subrs } = cff.privateFor(glyph);
+    const globalBias = subrBias(cff.globalSubrs.length);
+    const localBias = subrBias(subrs.length);
+    const path = [];
+    const stack = [];
+    let x = 0, y = 0;
+    let stems = 0;
+    let open = false;
+    let widthParsed = false;
+    let depth = 0;
+    const moveTo = (dx, dy) => {
+        if (open)
+            path.push(['Z']);
+        x += dx;
+        y += dy;
+        path.push(['M', x, y]);
+        open = true;
+    };
+    const lineTo = (dx, dy) => {
+        x += dx;
+        y += dy;
+        path.push(['L', x, y]);
+    };
+    const curveTo = (dx1, dy1, dx2, dy2, dx3, dy3) => {
+        const c1x = x + dx1, c1y = y + dy1;
+        const c2x = c1x + dx2, c2y = c1y + dy2;
+        x = c2x + dx3;
+        y = c2y + dy3;
+        path.push(['C', c1x, c1y, c2x, c2y, x, y]);
+    };
+    const stripWidth = (expectedEven) => {
+        if (!widthParsed && (stack.length % 2 === 1) === expectedEven)
+            stack.shift();
+        widthParsed = true;
+    };
+    const run = (code) => {
+        if (++depth > 10)
+            return true;
+        for (let i = 0; i < code.length;) {
+            const b0 = code[i++];
+            if (b0 >= 32 || b0 === 28) {
+                if (b0 === 28) {
+                    stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
+                    i += 2;
+                }
+                else if (b0 <= 246)
+                    stack.push(b0 - 139);
+                else if (b0 <= 250)
+                    stack.push((b0 - 247) * 256 + code[i++] + 108);
+                else if (b0 <= 254)
+                    stack.push(-(b0 - 251) * 256 - code[i++] - 108);
+                else {
+                    stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
+                    i += 4;
+                }
+                continue;
+            }
+            switch (b0) {
+                case 1:
+                case 3:
+                case 18:
+                case 23:
+                    stripWidth(true);
+                    stems += stack.length >> 1;
+                    stack.length = 0;
+                    break;
+                case 19:
+                case 20:
+                    stripWidth(true);
+                    stems += stack.length >> 1;
+                    stack.length = 0;
+                    i += stems + 7 >> 3;
+                    break;
+                case 21:
+                    stripWidth(true);
+                    moveTo(stack[0], stack[1]);
+                    stack.length = 0;
+                    break;
+                case 22:
+                    stripWidth(false);
+                    moveTo(stack[0], 0);
+                    stack.length = 0;
+                    break;
+                case 4:
+                    stripWidth(false);
+                    moveTo(0, stack[0]);
+                    stack.length = 0;
+                    break;
+                case 5:
+                    for (let j = 0; j + 1 < stack.length; j += 2)
+                        lineTo(stack[j], stack[j + 1]);
+                    stack.length = 0;
+                    break;
+                case 6:
+                case 7: {
+                    let horizontal = b0 === 6;
+                    for (const v of stack) {
+                        if (horizontal)
+                            lineTo(v, 0);
+                        else
+                            lineTo(0, v);
+                        horizontal = !horizontal;
+                    }
+                    stack.length = 0;
+                    break;
+                }
+                case 8:
+                    for (let j = 0; j + 5 < stack.length; j += 6)
+                        curveTo(stack[j], stack[j + 1], stack[j + 2], stack[j + 3], stack[j + 4], stack[j + 5]);
+                    stack.length = 0;
+                    break;
+                case 24: {
+                    let j = 0;
+                    for (; j + 5 < stack.length - 2; j += 6)
+                        curveTo(stack[j], stack[j + 1], stack[j + 2], stack[j + 3], stack[j + 4], stack[j + 5]);
+                    lineTo(stack[j], stack[j + 1]);
+                    stack.length = 0;
+                    break;
+                }
+                case 25: {
+                    let j = 0;
+                    for (; j + 1 < stack.length - 6; j += 2)
+                        lineTo(stack[j], stack[j + 1]);
+                    curveTo(stack[j], stack[j + 1], stack[j + 2], stack[j + 3], stack[j + 4], stack[j + 5]);
+                    stack.length = 0;
+                    break;
+                }
+                case 26: {
+                    let j = 0, dx1 = 0;
+                    if (stack.length % 4)
+                        dx1 = stack[j++];
+                    for (; j + 3 < stack.length; j += 4) {
+                        curveTo(dx1, stack[j], stack[j + 1], stack[j + 2], 0, stack[j + 3]);
+                        dx1 = 0;
+                    }
+                    stack.length = 0;
+                    break;
+                }
+                case 27: {
+                    let j = 0, dy1 = 0;
+                    if (stack.length % 4)
+                        dy1 = stack[j++];
+                    for (; j + 3 < stack.length; j += 4) {
+                        curveTo(stack[j], dy1, stack[j + 1], stack[j + 2], stack[j + 3], 0);
+                        dy1 = 0;
+                    }
+                    stack.length = 0;
+                    break;
+                }
+                case 30:
+                case 31: {
+                    let horizontal = b0 === 31;
+                    for (let j = 0; j + 3 < stack.length; j += 4) {
+                        const last = j + 5 === stack.length ? stack[j + 4] : 0;
+                        if (horizontal)
+                            curveTo(stack[j], 0, stack[j + 1], stack[j + 2], last, stack[j + 3]);
+                        else
+                            curveTo(0, stack[j], stack[j + 1], stack[j + 2], stack[j + 3], last);
+                        horizontal = !horizontal;
+                    }
+                    stack.length = 0;
+                    break;
+                }
+                case 10:
+                case 29: {
+                    const local = b0 === 10;
+                    const index = stack.pop() + (local ? localBias : globalBias);
+                    const subr = (local ? subrs : cff.globalSubrs)[index];
+                    if (subr && run(subr))
+                        return true;
+                    break;
+                }
+                case 11:
+                    depth--;
+                    return false;
+                case 14:
+                    stripWidth(true);
+                    if (open)
+                        path.push(['Z']);
+                    open = false;
+                    return true;
+                case 12: {
+                    const op = code[i++];
+                    const s = stack;
+                    if (op === 35) {
+                        curveTo(s[0], s[1], s[2], s[3], s[4], s[5]);
+                        curveTo(s[6], s[7], s[8], s[9], s[10], s[11]);
+                    }
+                    else if (op === 34) {
+                        const startY = y;
+                        curveTo(s[0], 0, s[1], s[2], s[3], 0);
+                        curveTo(s[4], 0, s[5], startY - y, s[6], 0);
+                    }
+                    else if (op === 36) {
+                        const startY = y;
+                        curveTo(s[0], s[1], s[2], s[3], s[4], 0);
+                        curveTo(s[5], 0, s[6], s[7], s[8], startY - (y + s[7]));
+                    }
+                    else if (op === 37) {
+                        const startX = x, startY = y;
+                        let dx = 0, dy = 0;
+                        for (let j = 0; j < 10; j += 2) {
+                            dx += s[j];
+                            dy += s[j + 1];
+                        }
+                        curveTo(s[0], s[1], s[2], s[3], s[4], s[5]);
+                        const lastX = Math.abs(dx) > Math.abs(dy);
+                        curveTo(s[6], s[7], s[8], s[9], lastX ? s[10] : startX - (x + s[6] + s[8]), lastX ? startY - (y + s[7] + s[9]) : s[10]);
+                    }
+                    stack.length = 0;
+                    break;
+                }
+                default:
+                    stack.length = 0;
+            }
+        }
+        depth--;
+        return false;
+    };
+    run(code);
+    if (open)
+        path.push(['Z']);
+    return path;
+}