ntk 8.13.0 → 8.14.0

package/lib/text/font.js

@@ -1,6 +1,7 @@
 import * as fontkit from 'fontkit';
 
 import { flatten, rasterizePath } from '../rasterize.js';
+import { marksCover, standInMarks } from './marks.js';
 
 // Axis coordinates are rounded to this many decimals before anything is
 // instantiated or cached. Every distinct coordinate is a font in its own
@@ -122,6 +123,10 @@ export default class Font {
     this._upem = 0;
     this._vertical = null;
     this._space = -1;
+    // the face's mark lookups while they are stood in for (./marks.js), set
+    // at its first shaping; null once the real ones are back, or never were
+    // stood in for
+    this._marks = undefined;
   }
 
   static loadSync(path, postscriptName) {
@@ -339,7 +344,7 @@ export default class Font {
    *   ax = advance, dx/dy = drawing offset from pen position (y up = positive dy)
    */
   shape(text, size, opts = {}) {
-    const run = this.fk.layout(text, opts.features, opts.script, opts.language, opts.direction);
+    const run = this._layout(text, opts);
     const s = this.scale(size);
     const glyphs = new Array(run.glyphs.length);
     let width = 0;
@@ -358,6 +363,31 @@ export default class Font {
     return { font: this, size, direction: run.direction, width, glyphs };
   }
 
+  /**
+   * fontkit's layout, with the face's mark lookups stood in for until a run
+   * holds a glyph they act at.
+   *
+   * fontkit decodes a feature's lookups the first time a run asks for it,
+   * and a face's mark attachment can be most of its tables: 14 ms of Noto
+   * Sans' first shaping, in the first frame. Until a run needs them the
+   * lookups are empty stand-ins (./marks.js), which a run holding none of
+   * their glyphs comes out the same with. A run that holds one puts the
+   * real ones back and is shaped again, and so is every run after it.
+   */
+  _layout(text, opts) {
+    const { features, script, language, direction } = opts;
+    if (this._marks === undefined) this._marks = standInMarks(this.fk);
+    const marks = this._marks;
+    // fontkit adds to the features object it is handed: a second shaping
+    // gets what the caller asked for, not what the first left there
+    const again = marks === null || features == null ? features : Array.isArray(features) ? [...features] : { ...features };
+    const run = this.fk.layout(text, features, script, language, direction);
+    if (marks === null || !run.glyphs.some((glyph) => marksCover(marks.bits, glyph.id))) return run;
+    marks.restore();
+    this._marks = null;
+    return this.fk.layout(text, again, script, language, direction);
+  }
+
   /** nominal (unshaped) advance of a glyph id, in pixels */
   advanceOf(glyphId, size) {
     return this.fk.getGlyph(glyphId).advanceWidth * this.scale(size);

package/lib/text/fontmanager.js

@@ -227,6 +227,32 @@ export default class FontManager {
     return this._source ?? defaultFontSource();
   }
 
+  /**
+   * Have `family` ready before a layout asks for it: a source that resolves
+   * families by asking the system (fontconfig) starts on its faces now, off
+   * the event loop, so the first layout in that family takes the answer
+   * instead of stalling for it. For a family the caller knows is coming — a
+   * code editor's monospace, set before it renders. A source with nothing to
+   * look up ignores it, and it never throws.
+   *
+   * `faces`, each `{ weight, style }`, names the faces to start on instead
+   * of the family's regular, bold, italic and bold italic: a face outside
+   * those that the caller knows text will be set in, such as a menu's
+   * medium. The family is spelled the way `match` spells it, so a list or a
+   * quoted name warms the pattern a layout will ask for.
+   */
+  prewarm(family, faces) {
+    const spelled = familiesOf(family).join(',');
+    if (!spelled) return;
+    this.source.prewarm?.(
+      spelled,
+      faces?.map(({ weight, style }) => ({
+        weight: numWeight(weight),
+        style: style?.includes('italic') ? 'italic' : 'normal'
+      }))
+    );
+  }
+
   /** open (and cache) a match candidate — see fontsource.js for the shape */
   _open(candidate) {
     const key = candidate.key ?? `${candidate.path}#${candidate.postscriptName || ''}`;
@@ -333,9 +359,14 @@ export default class FontManager {
       italic
     );
     if (!face) {
-      // sources understand comma-separated family lists natively
-      const candidates = this.source.matchSorted(patternOf(family, weight, italic));
-      face = this._open(candidates[0]);
+      // sources understand comma-separated family lists natively; one that
+      // can answer the best face alone saves reading the fallback chain the
+      // face may never need
+      const pattern = patternOf(family, weight, italic);
+      const source = this.source;
+      face = this._open(
+        typeof source.matchFirst === 'function' ? source.matchFirst(pattern) : source.matchSorted(pattern)[0]
+      );
     }
     this._matches.set(cacheKey, face);
     // A long-lived app can name a lot of families. Same sweep as the shaping

package/lib/text/fontsource.js

@@ -48,10 +48,12 @@
 import { builtin } from '../builtin.js';
 import {
   charsetHas,
+  matchFirstSync,
   matchSorted,
   matchSortedSync,
   noFontsError,
   prewarmFaces,
+  prewarmPatterns,
   supported
 } from '../fontconfig.js';
 import Font from './font.js';
@@ -129,6 +131,29 @@ export class FontconfigFontSource {
     return matchSortedSync(pattern);
   }
 
+  /**
+   * `matchSorted(pattern)[0]`, reading only the head of a prewarm's answer
+   * where one is waiting (`matchFirstSync` in fontconfig.js): a face's
+   * match needs its first candidate, and the fallback chain behind it is
+   * read when a character first falls back.
+   */
+  matchFirst(pattern) {
+    return matchFirstSync(pattern);
+  }
+
+  /**
+   * The family's faces — regular, bold, and both in italic, or the `faces`
+   * named, each `{ weight, style }` — matched off the event loop, as the
+   * constructor does for sans-serif, and answerable by a layout that asks
+   * before the loop runs again (see `prewarm` in fontconfig.js). A pattern
+   * already cached or running is not asked again; never rejects and never
+   * reports.
+   */
+  prewarm(family, faces) {
+    if (faces) prewarmPatterns(faces.map(({ weight, style }) => ({ family, weight, style })));
+    else prewarmFaces({ family });
+  }
+
   /**
    * Non-blocking sibling: the fc-match spawn runs off the event loop and
    * seeds the same cache, so a later synchronous layout for the pattern is

package/lib/text/layout.js

@@ -310,6 +310,13 @@ export class TextLayout {
     // and every line still needs a style to take its metrics from, so
     // stand one in rather than crashing on the first empty line.
     const given = typeof content === 'string' ? [{ text: content }] : content;
+    // What a span is shaped with, one per distinct style rather than one a
+    // span (`shapingStyleOf`): the spans of a highlighted source file are its
+    // tokens, half a million for twenty thousand lines over a handful of
+    // styles, and the font lookup and the shaping memo's key, worked out
+    // afresh for each, were most of what laying such a file out cost.
+    const styles = [];
+    const shapings = [];
     const spans = (given.length ? given : [{ text: '' }]).map((s) => {
       const merged = {
         ...s,
@@ -327,7 +334,9 @@ export class TextLayout {
         letterSpacing: s.letterSpacing ?? style.letterSpacing,
         color: s.color ?? style.color ?? null
       };
-      merged.font = s.font ?? style.font ?? fonts.match(merged.family, merged);
+      const shaping = shapingStyleOf(styles, merged, s.font ?? style.font, fonts);
+      merged.font = shaping.font;
+      shapings.push(shaping);
       return merged;
     });
 
@@ -355,6 +364,7 @@ export class TextLayout {
       }
       return {
         span: spans[lo],
+        shaping: shapings[lo],
         end: lo + 1 < spanStarts.length ? spanStarts[lo + 1] : text.length
       };
     };
@@ -388,16 +398,16 @@ export class TextLayout {
     let width = 0;
     let pos = start;
     while (pos < end) {
-      const { span, end: spanEnd } = spanAt(pos);
+      const { span, shaping, end: spanEnd } = spanAt(pos);
       const fragEnd = Math.min(end, spanEnd);
       // hard-break controls only terminate the line; never shape them
       const fragText = text.slice(pos, fragEnd).replace(HARD_BREAKS, '');
       if (fragText.length > 0) {
         const fragLevels = normalizedLevels(levels, pos, pos + fragText.length);
-        const shaped = this.fonts._shapeCached(fragText, span, fragLevels);
+        const shaped = this.fonts._shapeCached(fragText, shaping, fragLevels);
         // the levels ride along so a later split can re-shape a piece at the
         // level it actually has, rather than assuming ltr
-        fragments.push({ text: fragText, span, shaped, start: pos, levels: fragLevels });
+        fragments.push({ text: fragText, span, shaping, shaped, start: pos, levels: fragLevels });
         width += shaped.width;
       }
       pos = fragEnd;
@@ -487,33 +497,47 @@ export class TextLayout {
         used += frag.shaped.width;
         continue;
       }
-      // binary search the longest grapheme prefix of this fragment that fits.
+      // shaped at the bidi level this text actually has: assuming level 0
+      // here re-shapes an rtl word as ltr, which lays its glyphs out
+      // backwards and hands reorderRuns an even level that stops it from
+      // being reordered at all
+      const shaping = frag.shaping ?? frag.span;
+      const shape = (text, from, to) =>
+        this.fonts._shapeCached(text, shaping, sliceLevels(frag.levels, from, to));
+      let best = null;
       // Graphemes rather than code points: cutting between a base character
       // and its combining mark, or inside an emoji ZWJ sequence, leaves a
       // dotted circle or a pair of half-emoji on the two sides of the break.
-      const cps = graphemes(frag.text);
-      let lo = 0;
-      let hi = cps.length - 1;
-      let best = null;
-      while (lo <= hi) {
-        const mid = (lo + hi) >> 1;
-        const prefix = cps.slice(0, mid + 1).join('');
-        // shaped at the bidi level this text actually has: assuming level 0
-        // here re-shapes an rtl word as ltr, which lays its glyphs out
-        // backwards and hands reorderRuns an even level that stops it from
-        // being reordered at all
-        const shaped = this.fonts._shapeCached(prefix, frag.span, sliceLevels(frag.levels, 0, prefix.length));
-        if (used + shaped.width <= maxWidth) {
-          best = { len: prefix.length, shaped, text: prefix };
-          lo = mid + 1;
-        } else {
-          hi = mid - 1;
+      const lead = firstGrapheme(frag.text);
+      if (used + shape(lead, 0, lead.length).width <= maxWidth) {
+        // binary search the longest grapheme prefix of this fragment that fits
+        const cps = graphemes(frag.text);
+        let lo = 0;
+        let hi = cps.length - 1;
+        while (lo <= hi) {
+          const mid = (lo + hi) >> 1;
+          const prefix = cps.slice(0, mid + 1).join('');
+          const shaped = shape(prefix, 0, prefix.length);
+          if (used + shaped.width <= maxWidth) {
+            best = { len: prefix.length, shaped, text: prefix };
+            lo = mid + 1;
+          } else {
+            hi = mid - 1;
+          }
         }
+      } else if (!headFrags.length) {
+        // Not even its first cluster fits, so nothing of the token does: the
+        // caller lets it overflow whole. That is every word at width 0, where
+        // a layout is asked for the narrowest it can be, and the search found
+        // it out by segmenting the whole word and shaping a dozen prefixes of
+        // it, each a word the memo had never seen.
+        return [null, token];
       }
       if (best) {
         headFrags.push({
           text: best.text,
           span: frag.span,
+          shaping,
           shaped: best.shaped,
           start: frag.start,
           levels: sliceLevels(frag.levels, 0, best.len)
@@ -528,7 +552,8 @@ export class TextLayout {
         restFrags.push({
           text: restText,
           span: frag.span,
-          shaped: this.fonts._shapeCached(restText, frag.span, restLevels),
+          shaping,
+          shaped: this.fonts._shapeCached(restText, shaping, restLevels),
           start: frag.start + cut,
           levels: restLevels
         });
@@ -595,7 +620,20 @@ export class TextLayout {
       }
       batch = [];
     };
+    // Only the lines the context can show. A layout taller than the view it
+    // is drawn in — a code block of twenty thousand lines in a scroll pane —
+    // built every line's glyphs, sent them, and had the server clip them
+    // away, on every paint. A line is skipped when its box, grown by its
+    // height and its font's extent again on either side for ink that
+    // overhangs the box, is outside the rows the clip lets through: nothing
+    // of it could have landed on a pixel.
+    const rows = visibleRows(ctx, y);
     for (const line of this.lines) {
+      if (rows) {
+        const reach = line.height + line.ascent + line.descent;
+        if (line.y + line.height + reach < rows.top) continue;
+        if (line.y - reach > rows.bottom) continue;
+      }
       for (const r of line.runs) {
         const color = r.span.color;
         if (batch.length && color !== batchColor) flush();
@@ -935,19 +973,48 @@ export class TextLayout {
 // somehow absent, code points are the old behaviour and still safe for the
 // scripts that reach a force-break most often.
 let segmenter;
-function graphemes(text) {
+function graphemeSegmenter() {
   if (segmenter === undefined) {
     segmenter =
       typeof Intl !== 'undefined' && Intl.Segmenter
         ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
         : null;
   }
-  if (!segmenter) return Array.from(text);
+  return segmenter;
+}
+
+// Two ASCII characters are never one cluster, bar a CR before a LF (UAX#29
+// GB3): whatever extends a cluster or joins into one — marks, joiners,
+// spacing marks, prepends — sits above U+02FF. So text of nothing else,
+// which is most of what a document cuts, needs no segmenter: it costs a
+// microsecond a call, and the width floors ask once a word.
+function plainAscii(text) {
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 0x80 || (c === 13 && text.charCodeAt(i + 1) === 10)) return false;
+  }
+  return true;
+}
+
+function graphemes(text) {
+  if (plainAscii(text)) return text.split('');
+  const segments = graphemeSegmenter();
+  if (!segments) return Array.from(text);
   const out = [];
-  for (const { segment } of segmenter.segment(text)) out.push(segment);
+  for (const { segment } of segments.segment(text)) out.push(segment);
   return out;
 }
 
+/** The first grapheme cluster of `text`, without segmenting the rest. */
+function firstGrapheme(text) {
+  const c0 = text.charCodeAt(0);
+  if (c0 < 0x80 && c0 !== 13 && !(text.charCodeAt(1) >= 0x80)) return text.slice(0, 1);
+  const segments = graphemeSegmenter();
+  if (!segments) return String.fromCodePoint(text.codePointAt(0));
+  for (const { segment } of segments.segment(text)) return segment;
+  return '';
+}
+
 // UTF-16 length of a glyph cluster's codePoints array
 function cuLength(codePoints) {
   let len = 0;
@@ -1015,3 +1082,77 @@ function sliceLevels(key, start, end) {
   if (!key.includes(',')) return key;
   return key.split(',').slice(start, end).join(',');
 }
+
+/**
+ * The rows of a layout drawn at `y` that the context can show — its clip's
+ * box, or the whole surface with no clip — in the layout's own coordinates.
+ * Null where that cannot be said, and the whole layout is drawn: a context
+ * that is not ntk's, a transform that is more than a translation, or a
+ * shadow, which lands where the text is not.
+ */
+function visibleRows(ctx, y) {
+  if (typeof ctx.drawGlyphs !== 'function') return null;
+  if (typeof ctx._clipExtents !== 'function') return null;
+  const m = ctx._m;
+  if (!m || m[0] !== 1 || m[1] !== 0 || m[2] !== 0 || m[3] !== 1) return null;
+  if (typeof ctx._shadowed !== 'function' || ctx._shadowed()) return null;
+  const height = ctx.height;
+  if (!(height > 0)) return null;
+  // the clip's extents skip a region clip, so they are never smaller than
+  // what the server lets through
+  const box = ctx._clipExtents() ?? { y: 0, h: height };
+  const top = box.y - (y + m[5]);
+  return { top, bottom: top + box.h };
+}
+
+/**
+ * How many distinct styles one layout shares shaping styles among. Past it a
+ * span is shaped with a style of its own, as every span once was, rather
+ * than the search growing with the document.
+ */
+const MAX_SHAPING_STYLES = 16;
+
+/**
+ * The style `span` is shaped with: one already made for a span whose every
+ * property shaping reads is the same (`===`), or a new one. Its font is the
+ * one the span or the layout named (`given`), else the one its family
+ * matches, looked up once for all the spans that share it. What shaping
+ * reads is what `shapeText`, `fallbackFor` and the memo key read: the face
+ * and what picks it, the size, and features, language and spacing.
+ */
+function shapingStyleOf(known, span, given, fonts) {
+  for (let i = 0; i < known.length; i++) {
+    const k = known[i];
+    if (
+      k.given === given &&
+      k.family === span.family &&
+      k.size === span.size &&
+      k.weight === span.weight &&
+      k.style === span.style &&
+      k.variations === span.variations &&
+      k.opticalSize === span.opticalSize &&
+      k.opticalSizing === span.opticalSizing &&
+      k.features === span.features &&
+      k.language === span.language &&
+      k.letterSpacing === span.letterSpacing
+    ) {
+      return k;
+    }
+  }
+  const k = {
+    given,
+    font: given ?? fonts.match(span.family, span),
+    family: span.family,
+    size: span.size,
+    weight: span.weight,
+    style: span.style,
+    variations: span.variations,
+    opticalSize: span.opticalSize,
+    opticalSizing: span.opticalSizing,
+    features: span.features,
+    language: span.language,
+    letterSpacing: span.letterSpacing
+  };
+  if (known.length < MAX_SHAPING_STYLES) known.push(k);
+  return k;
+}

package/lib/text/marks.js

@@ -0,0 +1,212 @@
+// The glyphs a face's mark positioning can move, read from the GPOS table's
+// own bytes, so that its lookups need not be decoded until a run holds one.
+//
+// fontkit decodes a lookup whole the first time a run asks for its feature,
+// and `mark` is the one that costs: Noto Sans' mark-to-base subtable holds an
+// anchor for every base glyph in every mark class, and decoding it took 14 ms
+// of each face's first shaping (21 ms in all), inside the first frame of
+// every app whose sans-serif is Noto. A line of Latin UI text has no glyph
+// any of those lookups acts on.
+//
+// So each `mark` and `mkmk` lookup is stood in for, in fontkit's cache of the
+// face's lookups, by an empty one (`standInMarks`): a run applies the stand-in
+// and decodes nothing, and fontkit is handed the caller's features as they
+// are. A run that turns out to hold a glyph one of the real lookups acts at
+// puts them back and is shaped again (`Font#_layout`).
+//
+// That is exact rather than a guess about scripts. Every GPOS lookup acts
+// only at a glyph in its first coverage — the mark coverage of a mark
+// attachment, the first glyph's of a pair, the first input's of a context —
+// wherever it is reached from: its feature, another feature that names it,
+// the feature table a variation swaps in, a context that nests it. A run
+// holding no glyph from the coverage of any stood-in lookup is one the real
+// lookups would have left as it is.
+//
+// An earlier cut left the two features out through fontkit's own feature
+// overrides instead. That was exact too, and cost every shaping a pass over
+// the overrides that deletes the tags from the plan: 1-3 us a word, 6% of a
+// frame scrolling a long document into text it had not shaped.
+//
+// Null — shape as fontkit shapes — for a face that has nothing to stand in
+// for, that fontkit shapes through AAT's morx rather than GPOS, or whose
+// tables this cannot read to the end.
+
+const TAGS = new Set(['mark', 'mkmk']);
+
+/**
+ * @param {object} fk a fontkit font
+ * @returns {{ bits: Uint8Array, lookups: Set<number> }|null} the `mark` and
+ *   `mkmk` lookups, and a bit per glyph id, set for every glyph one of them
+ *   can act at; null where none can be stood in for
+ */
+export function markGlyphs(fk) {
+  try {
+    if (fk.directory?.tables?.morx) return null;
+    const gpos = table(fk, 'GPOS');
+    if (!gpos) return null;
+    const lookups = markLookups(gpos);
+    if (lookups.size === 0) return null;
+    const bits = new Uint8Array(8192);
+    const lookupList = gpos.offset(8, 0);
+    for (const index of lookups) {
+      if (!coverLookup(gpos, lookupList, index, bits)) return null;
+    }
+    return { bits, lookups };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Stand an empty lookup in for each `mark` and `mkmk` lookup of a face, in
+ * fontkit's cache of its GPOS lookups (restructure's lazy array, which
+ * decodes an index the first time it is asked and keeps it in `items`).
+ * Applied, a stand-in has no subtables and moves nothing.
+ *
+ * @param {object} fk a fontkit font, before its first layout
+ * @returns {{ bits: Uint8Array, restore: () => void }|null} `restore` puts the
+ *   real lookups back, to be decoded by the next run that asks; null where
+ *   there is nothing to stand in for, where fontkit's cache is not the shape
+ *   this knows, or where a lookup was decoded already
+ */
+export function standInMarks(fk) {
+  const marks = markGlyphs(fk);
+  if (marks === null) return null;
+  let list;
+  try {
+    list = fk.GPOS?.lookupList;
+  } catch {
+    return null;
+  }
+  if (!list || typeof list.get !== 'function' || !Array.isArray(list.items)) return null;
+  for (const index of marks.lookups) if (list.items[index] != null) return null;
+  const standIn = { lookupType: 0, flags: {}, subTableCount: 0, subTables: [] };
+  for (const index of marks.lookups) list.items[index] = standIn;
+  return {
+    bits: marks.bits,
+    restore() {
+      for (const index of marks.lookups) {
+        if (list.items[index] === standIn) list.items[index] = null;
+      }
+    }
+  };
+}
+
+/** Whether `bits` (from `markGlyphs`) has glyph `id`. */
+export function marksCover(bits, id) {
+  return (bits[id >> 3] & (1 << (id & 7))) !== 0;
+}
+
+/**
+ * A table's bytes, read big-endian at positions from its start. `offset(pos,
+ * base)` reads the 16-bit offset stored at `pos` and answers where it
+ * points, `base` being what the format measures it from.
+ */
+function table(fk, tag) {
+  const entry = fk.directory?.tables?.[tag];
+  if (!entry) return null;
+  const stream = fk._getTableStream(tag);
+  if (!stream) return null;
+  const buf = stream.buffer;
+  const start = stream.pos;
+  const end = Math.min(start + entry.length, buf.length);
+  const u16 = (pos) => {
+    const p = start + pos;
+    if (pos < 0 || p + 2 > end) throw new RangeError(`${tag} read past its end`);
+    return (buf[p] << 8) | buf[p + 1];
+  };
+  const u32 = (pos) => u16(pos) * 65536 + u16(pos + 2);
+  const offset = (pos, base) => base + u16(pos);
+  return { u16, u32, offset };
+}
+
+/**
+ * The lookup indices of every `mark` and `mkmk` feature record, in any
+ * script: a superset of what fontkit applies, which only widens what
+ * counts as a mark.
+ */
+function markLookups(t) {
+  const list = t.offset(6, 0);
+  const lookups = new Set();
+  for (let i = 0, n = t.u16(list); i < n; i++) {
+    const rec = list + 2 + i * 6;
+    const tag = String.fromCharCode(t.u16(rec) >> 8, t.u16(rec) & 255, t.u16(rec + 2) >> 8, t.u16(rec + 2) & 255);
+    if (!TAGS.has(tag)) continue;
+    const feature = t.offset(rec + 4, list);
+    for (let j = 0, m = t.u16(feature + 2); j < m; j++) lookups.add(t.u16(feature + 4 + j * 2));
+  }
+  return lookups;
+}
+
+/** Adds the first coverage of each of a lookup's subtables; false for one it cannot read. */
+function coverLookup(t, lookupList, index, bits) {
+  if (index >= t.u16(lookupList)) return false;
+  const lookup = t.offset(lookupList + 2 + index * 2, lookupList);
+  const type = t.u16(lookup);
+  for (let i = 0, n = t.u16(lookup + 4); i < n; i++) {
+    let sub = t.offset(lookup + 6 + i * 2, lookup);
+    let subType = type;
+    if (subType === 9) {
+      // an extension: the real subtable, at a 32-bit offset from here
+      if (t.u16(sub) !== 1) return false;
+      subType = t.u16(sub + 2);
+      sub += t.u32(sub + 4);
+    }
+    const coverage = firstCoverage(t, subType, sub);
+    if (coverage < 0) return false;
+    addCoverage(t, coverage, bits);
+  }
+  return true;
+}
+
+/**
+ * Where the coverage a subtable is entered from starts, or -1 for a
+ * subtable this does not know.
+ */
+function firstCoverage(t, type, sub) {
+  const format = t.u16(sub);
+  switch (type) {
+    case 1: // single adjustment
+    case 2: // pair adjustment: the pair's first glyph
+      return format === 1 || format === 2 ? t.offset(sub + 2, sub) : -1;
+    case 3: // cursive attachment
+    case 4: // mark to base: the mark
+    case 5: // mark to ligature: the mark
+    case 6: // mark to mark: the mark that attaches
+      return format === 1 ? t.offset(sub + 2, sub) : -1;
+    case 7: // context
+      if (format === 1 || format === 2) return t.offset(sub + 2, sub);
+      // the first input glyph's, after the glyph and lookup counts
+      return format === 3 && t.u16(sub + 2) > 0 ? t.offset(sub + 6, sub) : -1;
+    case 8: {
+      // chained context
+      if (format === 1 || format === 2) return t.offset(sub + 2, sub);
+      if (format !== 3) return -1;
+      // past the backtrack coverages to the input's count, then its first
+      const input = sub + 4 + t.u16(sub + 2) * 2;
+      return t.u16(input) > 0 ? t.offset(input + 2, sub) : -1;
+    }
+    default:
+      return -1;
+  }
+}
+
+function addCoverage(t, coverage, bits) {
+  const format = t.u16(coverage);
+  const count = t.u16(coverage + 2);
+  if (format === 1) {
+    for (let i = 0; i < count; i++) set(bits, t.u16(coverage + 4 + i * 2));
+  } else if (format === 2) {
+    for (let i = 0; i < count; i++) {
+      const rec = coverage + 4 + i * 6;
+      const last = t.u16(rec + 2);
+      for (let id = t.u16(rec); id <= last; id++) set(bits, id);
+    }
+  } else {
+    throw new RangeError(`coverage format ${format}`);
+  }
+}
+
+function set(bits, id) {
+  bits[id >> 3] |= 1 << (id & 7);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.13.0",
+  "version": "8.14.0",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",