ntk 8.14.0 → 8.14.2

package/lib/text/anchors.js

@@ -0,0 +1,81 @@
+// fontkit's mark attachment, for a face whose tables leave an anchor out.
+//
+// A mark-to-base, mark-to-ligature or mark-to-mark subtable holds an anchor
+// for each base (ligature component, earlier mark) and mark class, and the
+// OpenType spec lets one be NULL: that subtable attaches no mark of that
+// class to that glyph. HarfBuzz answers "not applied", and the lookup's next
+// subtable gets its turn. fontkit reads the NULL's coordinates and throws
+// `Cannot read properties of null (reading 'xCoordinate')` out of a layout,
+// and faces ship them: Noto Sans Bold holds 2,822, DejaVu Sans Mono 198 (a
+// Lithuanian Į̃ reaches one), Amiri, Noto Naskh Arabic and FreeSerif
+// thousands. Upstream that is foliojs/fontkit#367; #374 returns early
+// instead, which ends the crash but still counts the subtable as applied.
+//
+// Answering "not applied" means wrapping the processor's `applyLookup`,
+// which runs for every glyph at every lookup: 2% of shaping a word the
+// first time. So a face pays it only from the first NULL its text reaches.
+// Until then `applyAnchor` alone is watched — it runs when a mark attaches —
+// and a NULL there abandons the layout (`NO_ANCHOR`), which `Font#_layout`
+// shapes again with the wrapper in. Abandoning loses nothing: fontkit keeps
+// no state from a layout but the tables it decoded, which a second one
+// reads the same.
+
+/**
+ * Thrown through fontkit's layout from a NULL anchor, and caught here or in
+ * `Font#_layout`. One error, made once: a face can reach NULLs many times a
+ * word, and a fresh error would take a stack trace each time. It says what
+ * happened to anything that calls a watched face's `layout` directly.
+ */
+export const NO_ANCHOR = new Error(
+  'a mark attachment subtable has a NULL anchor for this glyph and mark class: ' +
+    "shaped through ntk's Font, that is a subtable that did not apply"
+);
+
+/** The face's GPOS processor, where fontkit shapes it through GPOS; else null. */
+function processorOf(fk) {
+  try {
+    return fk._layoutEngine?.engine?.GPOSProcessor ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Watch a face's mark attachment for a NULL anchor, which then abandons the
+ * layout it is reached in with `NO_ANCHOR`.
+ *
+ * @param {object} fk a fontkit font
+ * @returns {boolean} whether there is anything to watch: false for a face
+ *   fontkit does not position through GPOS
+ */
+export function watchAnchors(fk) {
+  const gpos = processorOf(fk);
+  if (!gpos || typeof gpos.applyAnchor !== 'function') return false;
+  if (Object.hasOwn(gpos, 'applyAnchor')) return true;
+  const applyAnchor = gpos.applyAnchor;
+  gpos.applyAnchor = function (markRecord, baseAnchor, baseGlyphIndex) {
+    if (baseAnchor == null || markRecord.markAnchor == null) throw NO_ANCHOR;
+    return applyAnchor.call(this, markRecord, baseAnchor, baseGlyphIndex);
+  };
+  return true;
+}
+
+/**
+ * From here on a subtable that reaches a NULL anchor is one that did not
+ * apply, so the lookup's next subtable is tried, as HarfBuzz tries it.
+ *
+ * @param {object} fk a fontkit font `watchAnchors` has been handed
+ */
+export function tolerateAnchors(fk) {
+  const gpos = processorOf(fk);
+  if (!gpos || Object.hasOwn(gpos, 'applyLookup')) return;
+  const applyLookup = gpos.applyLookup;
+  gpos.applyLookup = function (lookupType, table) {
+    try {
+      return applyLookup.call(this, lookupType, table);
+    } catch (err) {
+      if (err === NO_ANCHOR) return false;
+      throw err;
+    }
+  };
+}

package/lib/text/font.js

@@ -1,6 +1,7 @@
 import * as fontkit from 'fontkit';
 
 import { flatten, rasterizePath } from '../rasterize.js';
+import { NO_ANCHOR, tolerateAnchors, watchAnchors } from './anchors.js';
 import { marksCover, standInMarks } from './marks.js';
 
 // Axis coordinates are rounded to this many decimals before anything is
@@ -127,6 +128,10 @@ export default class Font {
     // at its first shaping; null once the real ones are back, or never were
     // stood in for
     this._marks = undefined;
+    this._drawable = undefined;
+    // whether the face's mark attachment is watched for a NULL anchor
+    // (./anchors.js): set at its first shaping, false once one has been met
+    this._anchors = false;
   }
 
   static loadSync(path, postscriptName) {
@@ -308,8 +313,29 @@ export default class Font {
     return this._space * this.scale(size);
   }
 
+  /**
+   * Whether fontkit can make a glyph of this face at all. It makes one from
+   * `glyf`, `CFF ` or `CFF2` outlines, or an `sbix` or `COLR`/`CPAL` colour
+   * glyph, and answers null for anything else — and its shaper throws on the
+   * null. A bitmap-only colour font (`CBDT`/`CBLC`) is that face: Noto Color
+   * Emoji and EmojiOne as most Linux desktops ship them, which fontconfig
+   * answers first for an emoji. Its cmap says it has the character and
+   * nothing can be shaped or drawn from it, so it covers nothing here
+   * (`hasGlyph`), and `FontManager` hands it out neither as a match nor as a
+   * fallback.
+   */
+  get drawable() {
+    if (this._drawable === undefined) {
+      const t = this.fk.directory?.tables ?? {};
+      this._drawable = Boolean(
+        t.glyf || t['CFF '] || t.CFF2 || t.sbix || (t.COLR && t.CPAL)
+      );
+    }
+    return this._drawable;
+  }
+
   hasGlyph(codepoint) {
-    return this.fk.hasGlyphForCodePoint(codepoint);
+    return this.drawable && this.fk.hasGlyphForCodePoint(codepoint);
   }
 
   /**
@@ -329,7 +355,7 @@ export default class Font {
    * @returns {number|null} font glyph id, as `shape()` would report in `glyphs[].id`
    */
   glyphIdFor(codepoint) {
-    if (!this.fk.hasGlyphForCodePoint(codepoint)) return null;
+    if (!this.hasGlyph(codepoint)) return null;
     return this.fk.glyphForCodePoint(codepoint).id;
   }
 
@@ -376,16 +402,38 @@ export default class Font {
    */
   _layout(text, opts) {
     const { features, script, language, direction } = opts;
-    if (this._marks === undefined) this._marks = standInMarks(this.fk);
+    if (this._marks === undefined) {
+      this._marks = standInMarks(this.fk);
+      this._anchors = watchAnchors(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);
+    const run = this._fkLayout(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);
+    return this._fkLayout(text, again, script, language, direction);
+  }
+
+  /**
+   * fontkit's layout, shaped once more where a NULL anchor abandoned it: a
+   * face's mark attachment is watched for one until its text reaches the
+   * first, and takes one as a subtable that did not apply from then on
+   * (./anchors.js).
+   */
+  _fkLayout(text, features, script, language, direction) {
+    if (!this._anchors) return this.fk.layout(text, features, script, language, direction);
+    const again = features == null ? features : Array.isArray(features) ? [...features] : { ...features };
+    try {
+      return this.fk.layout(text, features, script, language, direction);
+    } catch (err) {
+      if (err !== NO_ANCHOR) throw err;
+      tolerateAnchors(this.fk);
+      this._anchors = false;
+      return this.fk.layout(text, again, script, language, direction);
+    }
   }
 
   /** nominal (unshaped) advance of a glyph id, in pixels */

package/lib/text/fontmanager.js

@@ -82,6 +82,13 @@ const shapePrefixes = new WeakMap();
 /** The key a style's words are memoized under, with the embedding levels
  *  they were shaped at: one string per style and level, kept, so a lookup
  *  hashes nothing it has not hashed before. */
+/** A levels key (`normalizedLevels`) for part of the text it was made for. */
+function sliceKey(key, start, end) {
+  if (!key.includes(',')) return key;
+  const levels = key.split(',').slice(start, end);
+  return levels.every((l) => l === levels[0]) ? levels[0] : levels.join(',');
+}
+
 function shapeGroupOf(style, levelsKey) {
   const font = style.font;
   let known = shapePrefixes.get(style);
@@ -111,8 +118,12 @@ function shapePrefixOf(style) {
   // plain answered every later request for it with the plain glyphs, and a
   // `tnum` asked for after that point was silently ignored.
   const shaping = shapingKeyOf(style);
+  // The family list too where a face is given, since the letters that face
+  // lacks are set in the families after it (`fallbackFor`): a word shaped
+  // under `Ahem, Times New Roman` answered the same word under `Ahem,
+  // Arial`, in Times.
   return font
-    ? `${font.key}|${style.size}|${style.weight}|${style.style}|${shaping}`
+    ? `${font.key}|${style.family ?? ''}|${style.size}|${style.weight}|${style.style}|${shaping}`
     : `${style.family}|${style.size}|${style.weight}|${style.style}|${variationsKeyOf(
         style.variations
       )}|${opticalKeyOf(style)}|${shaping}`;
@@ -217,6 +228,8 @@ export default class FontManager {
     this._shapeCache = new Map();
     this._shapeCacheBefore = new Map();
     this._shapeCount = 0;
+    // whether two letters shape otherwise together than apart (`_meets`)
+    this._meetings = new Map();
     // a paragraph's layout up to the line fill, for its next width
     // (text/paragraphs.js, TextLayout)
     this._paragraphs = new ParagraphCache();
@@ -253,6 +266,28 @@ export default class FontManager {
     );
   }
 
+  /**
+   * The best of `candidates` a glyph can be made from (`Font.drawable`):
+   * `emoji`, or a stylesheet's `"Noto Color Emoji"`, is a bitmap-only face
+   * on most Linux desktops, and a base face nothing can be shaped in threw
+   * on the first character of its text. The first candidate still, where
+   * none is — there is nothing better to hand out.
+   */
+  _firstDrawable(candidates) {
+    let first = null;
+    for (const c of candidates) {
+      let font;
+      try {
+        font = this._open(c);
+      } catch {
+        continue; // unparseable candidate — try the next one
+      }
+      if (font.drawable) return font;
+      first ??= font;
+    }
+    return first ?? this._open(candidates[0]);
+  }
+
   /** open (and cache) a match candidate — see fontsource.js for the shape */
   _open(candidate) {
     const key = candidate.key ?? `${candidate.path}#${candidate.postscriptName || ''}`;
@@ -309,7 +344,7 @@ export default class FontManager {
     let bestScore = Infinity;
     for (const family of families) {
       for (const r of this._registered) {
-        if (r.family !== family) continue;
+        if (r.family !== family || !r.font.drawable) continue;
         const score = Math.abs(r.weight - weight) + (r.italic !== italic ? 1000 : 0);
         if (score < bestScore) {
           bestScore = score;
@@ -361,12 +396,19 @@ export default class FontManager {
     if (!face) {
       // 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
+      // face may never need — unless no glyph can be made from that face
       const pattern = patternOf(family, weight, italic);
       const source = this.source;
-      face = this._open(
-        typeof source.matchFirst === 'function' ? source.matchFirst(pattern) : source.matchSorted(pattern)[0]
-      );
+      let head = null;
+      if (typeof source.matchFirst === 'function') {
+        const candidate = source.matchFirst(pattern);
+        try {
+          head = this._open(candidate);
+        } catch {
+          // unparseable: the chain has the next candidate
+        }
+      }
+      face = head?.drawable ? head : this._firstDrawable(source.matchSorted(pattern));
     }
     this._matches.set(cacheKey, face);
     // A long-lived app can name a lot of families. Same sweep as the shaping
@@ -383,9 +425,17 @@ export default class FontManager {
 
   /**
    * Find a font that has a glyph for `codepoint`, for use when the primary
-   * font doesn't. Registered fonts first, then the source's fallback chain
-   * (filtered by the source's coverage data — font files are only opened to
-   * confirm). Returns null when nothing on the system covers the codepoint.
+   * font doesn't. The registered faces of the families the style names
+   * first, in the order it names them, then any registered face, then the
+   * source's fallback chain (filtered by the source's coverage data — font
+   * files are only opened to confirm). Returns null when nothing on the
+   * system covers the codepoint.
+   *
+   * The families first because that is what a list of them is for: CSS's
+   * `font-family: Icons, Arial` sets a letter the icon face lacks in Arial,
+   * as a browser does. Walking every registered face instead gave it to
+   * whichever was registered first — an app's serif — however far down the
+   * list, or off it, that face was.
    *
    * "Nothing covers it" includes "this environment has no system fonts at
    * all". An app that loaded its own faces still reaches here for the first
@@ -404,10 +454,23 @@ export default class FontManager {
     if (perCp.has(codepoint)) return perCp.get(codepoint);
 
     let found = null;
-    for (const r of this._registered) {
-      if (r.font.hasGlyph(codepoint)) {
-        found = r.font;
-        break;
+    if (this._registered.length) {
+      const weight = numWeight(opts.weight);
+      const italic = !!opts.style?.includes('italic');
+      for (const name of familiesOf(family)) {
+        const font = this._matchRegistered([name.toLowerCase()], weight, italic);
+        if (font && font.hasGlyph(codepoint)) {
+          found = font;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      for (const r of this._registered) {
+        if (r.font.hasGlyph(codepoint)) {
+          found = r.font;
+          break;
+        }
       }
     }
     if (!found) {
@@ -474,6 +537,32 @@ export default class FontManager {
    * embedding-levels encoding: a single number when uniform for the whole
    * fragment (the common case), else comma-separated per-char levels.
    */
+  /**
+   * Whether the two letters of `pair`, cut at `cut`, shape otherwise
+   * together than apart in this style: their glyphs or their advances
+   * change — a kerning pair, a ligature, a joining script, a mark on the
+   * letter before. Compared as a set and a sum, so a right-to-left pair,
+   * whose glyphs come in visual order, is read as a left-to-right one is.
+   * Kept, since the pairs a paragraph's spans meet at are few and repeat.
+   */
+  _meets(pair, cut, style, levelsKey = '0') {
+    const key = `${shapeGroupOf(style, levelsKey)}|${cut}|${pair}`;
+    let meets = this._meetings.get(key);
+    if (meets !== undefined) return meets;
+    const whole = this._shapeCached(pair, style, levelsKey);
+    const left = this._shapeCached(pair.slice(0, cut), style, sliceKey(levelsKey, 0, cut));
+    const right = this._shapeCached(pair.slice(cut), style, sliceKey(levelsKey, cut, pair.length));
+    const ids = (...shaped) =>
+      shaped
+        .flatMap((s) => s.runs.flatMap((r) => r.glyphs.map((g) => g.id)))
+        .sort((a, b) => a - b)
+        .join(',');
+    meets = Math.abs(whole.width - left.width - right.width) > 1e-6 || ids(whole) !== ids(left, right);
+    if (this._meetings.size >= SHAPE_GENERATION) this._meetings.clear();
+    this._meetings.set(key, meets);
+    return meets;
+  }
+
   _shapeCached(text, style, levelsKey = '0') {
     // A hit in this generation is the whole cost of a word a paragraph has
     // shaped before — a relayout at a new width asks for every word again,

package/lib/text/layout.js

@@ -40,12 +40,16 @@ function isWsGlyph(g) {
  *
  * Content is a plain string or an array of spans
  * `{ text, family?, size?, weight?, style?, features?, language?,
- * letterSpacing?, color?, nowrap? }`;
+ * letterSpacing?, color?, nowrap?, shapeApart? }`;
  * span fields override the base style. Spans that share a truthy `nowrap` —
  * `true`, or any value a caller tells its groups apart by — have no break
  * opportunity inside them or between them, as the text of an element with
  * CSS's `white-space: nowrap` has none: the break after the last of them is
- * the next span's to allow. Options:
+ * the next span's to allow. Neighbouring spans shaped alike — a colour
+ * apart — are shaped as one text, so a word across them keeps its kerning
+ * and its joining; a span with a truthy `shapeApart` is shaped on its own,
+ * as CSS breaks the shaping at an inline box with a margin, border or
+ * padding. Options:
  *
  * - `maxWidth` — target container width (default: unlimited)
  * - `align` — 'left' | 'right' | 'center' | 'start' | 'end'
@@ -393,24 +397,80 @@ export class TextLayout {
     return { spans, text, baseLevel, tokens };
   }
 
+  /**
+   * Whether the letters that meet at an edge between two spans of a group
+   * shape otherwise together than apart: their glyphs or their advances
+   * change. Compared as a set and a sum, which holds in a right-to-left
+   * pair as in a left-to-right one.
+   */
+  _meets(text, group, levels, shaping) {
+    for (let i = 1; i < group.length; i++) {
+      const at = group[i].start;
+      const low = text.charCodeAt(at - 1);
+      const before = low >= 0xdc00 && low < 0xe000 && at >= 2 ? 2 : 1;
+      const after = text.codePointAt(at) > 0xffff ? 2 : 1;
+      const from = at - before;
+      const to = at + after;
+      if (this.fonts._meets(text.slice(from, to), before, shaping, normalizedLevels(levels, from, to))) return true;
+    }
+    return false;
+  }
+
   _makeToken(text, start, end, levels, spanAt, required) {
     const fragments = [];
     let width = 0;
     let pos = start;
     while (pos < end) {
-      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, shaping, fragLevels);
+      // The spans of the token shaped alike — a colour apart, say — are
+      // shaped as one text and the glyphs shared out among them after, so
+      // a word that crosses from one to the next keeps the kerning between
+      // its letters there, and a script its joining, as a browser shapes
+      // it: an opening quote an `::before` makes kerned with nothing, and
+      // an Arabic word in two colours came apart into isolated letters.
+      // A span marked `shapeApart` is shaped on its own, as CSS breaks the
+      // shaping at an inline box with a margin, border or padding.
+      const group = [];
+      let shaping = null;
+      for (let at = pos; at < end; ) {
+        const next = spanAt(at);
+        if (shaping && (next.shaping !== shaping || next.span.shapeApart || group[group.length - 1].span.shapeApart))
+          break;
+        shaping = next.shaping;
+        const fragEnd = Math.min(end, next.end);
+        group.push({ span: next.span, start: at, end: fragEnd });
+        at = fragEnd;
+      }
+      const groupEnd = group[group.length - 1].end;
+      // Only where the letters either side of a span's edge shape otherwise
+      // together than apart — a kerning pair, a joining script, a mark on
+      // the letter before — is the word shaped whole: two letters are a
+      // lookup the memo almost always holds, and a syntax-coloured line of
+      // code, a span to a token, shaped each of its words afresh otherwise,
+      // at twice the cost of the line.
+      let pieces = null;
+      if (group.length > 1) {
+        const joined = text.slice(pos, groupEnd);
+        if (!HARD_BREAKS.test(joined) && this._meets(text, group, levels, shaping)) {
+          const whole = this.fonts._shapeCached(joined, shaping, normalizedLevels(levels, pos, groupEnd));
+          pieces = splitShapedOnce(
+            whole,
+            group.slice(1).map((g) => g.start - pos)
+          );
+        }
+      }
+      for (let i = 0; i < group.length; i++) {
+        const { span, start: fragStart, end: fragEnd } = group[i];
+        // hard-break controls only terminate the line; never shape them
+        const fragText = text.slice(fragStart, fragEnd).replace(HARD_BREAKS, '');
+        if (fragText.length === 0) continue;
+        const fragLevels = normalizedLevels(levels, fragStart, fragStart + fragText.length);
+        const shaped = pieces ? pieces[i] : 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, shaping, shaped, start: pos, levels: fragLevels });
+        fragments.push({ text: fragText, span, shaping, shaped, start: fragStart, levels: fragLevels });
         width += shaped.width;
       }
-      pos = fragEnd;
+      pos = groupEnd;
     }
     // trailing whitespace does not count against the container width
     let wsWidth = 0;
@@ -1077,6 +1137,83 @@ function stripTrailingWhitespace(entries) {
 
 // The levels key for a code-unit slice of a fragment. A uniform key covers
 // any slice of itself; a per-character one has to be cut to match.
+/**
+ * A shaped text (`shapeText`) cut at `cuts` — code-unit offsets inside it,
+ * ascending — into as many shaped texts, each of its own piece of the text
+ * with its runs and their glyphs, or null where a cut falls inside what a
+ * glyph was made from: a ligature, or a cluster the font set as one, which
+ * no cut can share out. A glyph keeps the advance shaping gave it, so the
+ * kerning between the last letter before a cut and the first after it
+ * stays with the first piece. A right-to-left run's glyphs are in visual
+ * order, and are walked from their end.
+ */
+/** `splitShaped`, kept per shaped text and cut, since a shaped text is the
+ *  memo's and never changes, and a word a paragraph lays out again is cut
+ *  the same way. */
+const SPLITS = new WeakMap();
+function splitShapedOnce(shaped, cuts) {
+  const key = cuts.join(',');
+  let byCut = SPLITS.get(shaped);
+  if (!byCut) {
+    byCut = new Map();
+    SPLITS.set(shaped, byCut);
+  }
+  if (byCut.has(key)) return byCut.get(key);
+  const pieces = splitShaped(shaped, cuts);
+  byCut.set(key, pieces);
+  return pieces;
+}
+
+function splitShaped(shaped, cuts) {
+  const bounds = [0, ...cuts, shaped.text.length];
+  const pieces = cuts.concat(shaped.text.length).map((to, i) => ({
+    text: shaped.text.slice(bounds[i], to),
+    width: 0,
+    baseLevel: shaped.baseLevel,
+    runs: []
+  }));
+  for (const run of shaped.runs) {
+    const rtl = (run.level & 1) === 1;
+    const logical = rtl ? [...run.glyphs].reverse() : run.glyphs;
+    let piece = 0;
+    while (bounds[piece + 1] <= run.start) piece++;
+    let at = run.start;
+    let from = at;
+    let glyphs = [];
+    const close = () => {
+      if (at === from && glyphs.length === 0) return;
+      const offset = bounds[piece];
+      let width = 0;
+      for (const g of glyphs) width += g.ax;
+      pieces[piece].runs.push({
+        ...run,
+        glyphs: rtl ? glyphs.reverse() : glyphs,
+        width,
+        text: shaped.text.slice(from, at),
+        start: from - offset,
+        end: at - offset
+      });
+      pieces[piece].width += width;
+    };
+    for (const g of logical) {
+      let units = 0;
+      for (const cp of g.codePoints ?? []) units += cp > 0xffff ? 2 : 1;
+      if (units > 0 && at >= bounds[piece + 1]) {
+        close();
+        while (at >= bounds[piece + 1]) piece++;
+        from = at;
+        glyphs = [];
+      }
+      if (at + units > bounds[piece + 1]) return null;
+      glyphs.push(g);
+      at += units;
+    }
+    if (at !== run.end) return null;
+    close();
+  }
+  return pieces;
+}
+
 function sliceLevels(key, start, end) {
   if (key === undefined) return '0';
   if (!key.includes(',')) return key;

package/lib/text/shape.js

@@ -74,23 +74,32 @@ export function normalizedLevels(levels, start, end) {
  */
 const OPTIONAL_LIGATURES = ['liga', 'clig', 'dlig', 'hlig'];
 
-/**
- * The features a letter-spaced run shapes with: the optional ligatures off,
- * underneath whatever the caller asked for — a style that names `liga`
- * itself still gets it. `features` is either form fontkit takes, an array of
- * tags to turn on or an object of tag → on/off.
- */
 /**
  * A copy of `features` for fontkit, which **adds to the object it is handed**
  * — `rvrn` and the like, as it plans the shaping. Handed a caller's own
  * object that is a style quietly growing keys, which changes the memo key it
  * is filed under next time, and a frozen one throws.
+ *
+ * A feature a 0 turns off, as CSS writes one (`font-feature-settings: "kern"
+ * 0`, and `font-kerning: none`), goes to fontkit as `false`. It reads a 0 as
+ * off where it plans the OpenType features, but where a face keeps its
+ * kerning in the older `kern` table — Times New Roman's, and DejaVu's beside
+ * its GPOS pairs — it asks `kern !== false`, and a 0 kerned all the same.
  */
 function ownFeatures(features) {
   if (!features) return features;
-  return Array.isArray(features) ? [...features] : { ...features };
+  if (Array.isArray(features)) return [...features];
+  const out = {};
+  for (const tag in features) out[tag] = features[tag] === 0 ? false : features[tag];
+  return out;
 }
 
+/**
+ * The features a letter-spaced run shapes with: the optional ligatures off,
+ * underneath whatever the caller asked for — a style that names `liga`
+ * itself still gets it. `features` is either form fontkit takes, an array of
+ * tags to turn on or an object of tag → on/off.
+ */
 function spacedFeatures(features) {
   const off = Object.fromEntries(OPTIONAL_LIGATURES.map((tag) => [tag, false]));
   if (!features) return off;
@@ -98,7 +107,7 @@ function spacedFeatures(features) {
     for (const tag of features) off[tag] = true;
     return off;
   }
-  return { ...off, ...features };
+  return { ...off, ...ownFeatures(features) };
 }
 
 /**

package/package.json

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