ntk 8.17.8 → 8.18.0

package/lib/text/brotlidictionary.js

@@ -0,0 +1,99 @@
+// Keeps brotli's static dictionary out of every app's startup (issue #427).
+//
+// The fontkit build ntk carries (lib/vendor/fontkit.js) imports brotli's
+// decoder at the top, for WOFF2, and the decoder's last line is `BrotliDictionary.init()`, at module scope.
+// `dec/dictionary.js` requires `dec/dictionary-data.js` to have something to
+// init from: RFC 7932's 122,784-byte dictionary written out as a 756 KB array
+// literal. Compiling and running it is 8 of the 10 ms the decoder takes to
+// load on an M1 Pro — the issue measured the decoder at 16 ms on an i7-7700K
+// — and `import 'ntk'` paid it in every app, including the ones that never
+// open a WOFF2.
+//
+// The decoder reads the dictionary's fields as it decompresses, and nothing
+// else does; `init()` is the one thing done at load. So before fontkit loads,
+// a stand-in for `dec/dictionary.js` goes into `require.cache`: its `init()`
+// does nothing, and the first read of a field — the first WOFF2 decompressed
+// — drops the stand-in from the cache, requires the real module and copies
+// its fields over, so the decoder holds the real values from then on.
+//
+// Why that module and not a shallower one: before ESM evaluates anything, it
+// pre-parses the CommonJS it imports for export names, which leaves loader-
+// owned placeholders in `require.cache` for `decompress.js` and, through
+// what reads as a re-export, `dec/decode.js` — replace one and the import
+// dies with ERR_INTERNAL_ASSERTION. `dec/dictionary.js` is only reached by
+// `require`, while the decoder evaluates, so it is still free when this runs.
+//
+// Each step stands down where it cannot apply: outside Node, in a bundle
+// (which carries its own copy of brotli and never consults `require.cache`),
+// where brotli does not resolve, where something required the
+// dictionary first, and for a brotli other than the 1.3 this was written
+// against. A brotli release that loads the dictionary lazily itself makes
+// this redundant, and the version check retires it.
+//
+// Where the runtime has a Brotli of its own, a WOFF2 ntk opens is not
+// decompressed by this decoder at all (./woff2.js), so with the stand-in in
+// place the dictionary never loads. Without it, it would still load with
+// fontkit, used or not.
+import { builtin, nodeRequire } from '../builtin.js';
+
+// What the decoder reads off brotli 1.3's `dec/dictionary.js`.
+const FIELDS = [
+  'dictionary',
+  'offsetsByLength',
+  'sizeBitsByLength',
+  'minDictionaryWordLength',
+  'maxDictionaryWordLength',
+];
+
+/**
+ * Put the stand-in for fontkit's `brotli/dec/dictionary.js` into
+ * `require.cache`, unless it cannot or should not be.
+ * @returns {boolean} whether it was installed
+ */
+export function deferBrotliDictionary() {
+  try {
+    const require = nodeRequire();
+    if (!require) return false;
+    const { Module } = builtin('node:module');
+    // brotli is ntk's own dependency, for the fontkit build in lib/vendor/,
+    // so it resolves from here to the copy that build imports
+    if (!/^1\.3\./.test(require('brotli/package.json').version)) return false;
+    const file = require.resolve('brotli/dec/dictionary.js');
+    const cache = require.cache;
+    if (cache[file]) return false;
+
+    const standIn = new Module(file);
+    standIn.filename = file;
+    standIn.loaded = true;
+    const exports = (standIn.exports = { init() {} });
+    const load = () => {
+      if (cache[file] === standIn) delete cache[file];
+      const real = require(file);
+      real.init();
+      for (const key of Object.keys(real)) {
+        Object.defineProperty(exports, key, {
+          value: real[key],
+          writable: true,
+          enumerable: true,
+          configurable: true,
+        });
+      }
+      return real;
+    };
+    for (const key of FIELDS) {
+      Object.defineProperty(exports, key, {
+        get: () => load()[key],
+        enumerable: true,
+        configurable: true,
+      });
+    }
+    cache[file] = standIn;
+    return true;
+  } catch {
+    // no node:module, no import.meta.url (a CommonJS bundle), or a layout
+    // that does not resolve: the dictionary loads with fontkit, as before
+    return false;
+  }
+}
+
+deferBrotliDictionary();

package/lib/text/font.js

@@ -1,10 +1,18 @@
-import * as fontkit from 'fontkit';
-
+// Must stay above fontkit, whose import loads brotli's decoder: this keeps
+// the decoder's static dictionary from loading with it (see the module).
+import './brotlidictionary.js';
+import { builtin } from '../builtin.js';
 import { flatten, rasterizePath } from '../rasterize.js';
+// the windowkit fork's build, which ntk carries (scripts/vendor-fontkit.mjs)
+import * as fontkit from '../vendor/fontkit.js';
 import { NO_ANCHOR, tolerateAnchors, watchAnchors } from './anchors.js';
 import { marksCover, standInMarks } from './marks.js';
 import { pairGlyphs, pairsCover } from './pairs.js';
 import { sfntOf } from './sfnt.js';
+import { opened, useNativeBrotli } from './woff2.js';
+
+// a WOFF2 decompresses with the runtime's Brotli where it has one (see the module)
+useNativeBrotli(fontkit);
 
 // Axis coordinates are rounded to this many decimals before anything is
 // instantiated or cached. Every distinct coordinate is a font in its own
@@ -228,16 +236,18 @@ export default class Font {
   }
 
   static loadSync(path, postscriptName) {
-    let fk = fontkit.openSync(path);
+    // what fontkit's openSync does, which the build ntk carries leaves out:
+    // it is the one that imports node:fs
+    let fk = fontkit.create(builtin('node:fs').readFileSync(path));
     // select the face of a .ttc/.dfont collection (first face by default);
-    // don't pass the name to openSync — for single variable fonts it would
+    // don't pass the name to create — for single variable fonts it would
     // be misread as a named variation instance
     if (fk.fonts) {
       fk =
         (postscriptName && fk.fonts.find((f) => f.postscriptName === postscriptName)) ||
         fk.fonts[0];
     }
-    return new Font(instantiable(fk), path, postscriptName);
+    return new Font(instantiable(opened(fk, path)), path, postscriptName);
   }
 
   /**
@@ -258,7 +268,7 @@ export default class Font {
         (postscriptName && fk.fonts.find((f) => f.postscriptName === postscriptName)) ||
         fk.fonts[0];
     }
-    const font = new Font(instantiable(fk), null, postscriptName);
+    const font = new Font(instantiable(opened(fk)), null, postscriptName);
     font.key = key ?? `mem:#${fk.postscriptName || ''}`;
     return font;
   }

package/lib/text/woff2.js

@@ -0,0 +1,102 @@
+// A WOFF2's font data, decompressed by the runtime's own Brotli.
+//
+// A WOFF2 keeps every table in one Brotli stream. The fontkit build ntk
+// carries (lib/vendor/fontkit.js) is the fork's browser build, and it
+// decompresses that with brotli.js, a decoder written in JavaScript. Node,
+// Bun and Deno each carry a native one in `node:zlib` — every Node ntk runs
+// on, and Bun since 1.1.8 — which gives the same bytes about six times as
+// fast: the twenty KaTeX faces and the variable fixture decompress in 3.9 ms
+// instead of 21.4 on an M1 Pro. It also never reaches brotli.js's static
+// dictionary, which ./brotlidictionary.js keeps out of startup so that only a
+// WOFF2 pays for it. On these runtimes, none does.
+//
+// The fork takes a decompressor from outside, `setBrotliDecompressor`
+// (windowkit/fontkit#6), and checks what comes back against the size the
+// table directory gives, as Google's reference decoder does. So this is one
+// function, handed over once: zlib's Brotli where the runtime has one, looked
+// for at the first WOFF2 rather than at import, and the build's own brotli.js
+// where it has none, in a browser.
+//
+// What fontkit does not do is say so when a file is damaged. It decompresses
+// at a WOFF2's first table read, and swallows a table's errors: the table
+// reads as undefined. So a damaged WOFF2 opened as a font with no tables,
+// and failed at the first glyph drawn, with brotli.js's own message. `opened`
+// decompresses it as it is opened, calling fontkit's `_decompress` as
+// ./sfnt.js does, and a damaged file is an error naming it, at the call that
+// named it. Font sources skip a face that throws there (./fontsource.js),
+// and a match moves on to the next candidate (./fontmanager.js).
+import { builtin } from '../builtin.js';
+
+// `node:zlib`, or null where it has no Brotli; undefined until first asked
+let zlib;
+
+function nativeBrotli() {
+  if (zlib === undefined) {
+    zlib = null;
+    try {
+      const z = builtin('node:zlib');
+      if (typeof z?.brotliDecompressSync === 'function') zlib = z;
+    } catch {
+      // no builtins to reach: brotli.js it is
+    }
+  }
+  return zlib;
+}
+
+/**
+ * Test seam: what decompresses a WOFF2 — a `node:zlib`-shaped module, `null`
+ * for the build's brotli.js, or `undefined` to look for the runtime's again.
+ */
+export function setNativeBrotli(module) {
+  zlib = module;
+}
+
+/**
+ * Hand `fontkit` the runtime's Brotli for WOFF2, keeping the decompressor it
+ * had for where there is none.
+ *
+ * @param {object} fontkit the build ntk carries
+ */
+export function useNativeBrotli(fontkit) {
+  const own = fontkit.setBrotliDecompressor(decompress);
+
+  function decompress(buffer, size) {
+    const z = nativeBrotli();
+    if (!z) return own(buffer, size);
+    let bytes;
+    try {
+      bytes = z.brotliDecompressSync(buffer, { maxOutputLength: Math.max(size, 1) });
+    } catch (err) {
+      if (err?.code !== 'ERR_BUFFER_TOO_LARGE') throw err;
+      throw new RangeError(`it holds more than the ${size} bytes its table directory gives`, {
+        cause: err,
+      });
+    }
+    // A plain Uint8Array, as brotli.js returns, not zlib's Buffer: a Buffer's
+    // slice() is a view, and what is read out of this expects a copy —
+    // ./sfnt.js rewrites `head` in the copy it slices.
+    return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.length);
+  }
+}
+
+/**
+ * `fk`, with its font data decompressed now if it is a WOFF2, so that a
+ * damaged file is an error naming it rather than a font with no tables.
+ *
+ * @param {object} fk a fontkit font
+ * @param {string} [where] the file it was read from
+ * @returns {object} `fk`
+ */
+export function opened(fk, where) {
+  if (fk?.type !== 'WOFF2' || typeof fk._decompress !== 'function') return fk;
+  try {
+    fk._decompress();
+  } catch (err) {
+    throw new Error(
+      `${where ? `${where}: ` : ''}${err.message} — the file is damaged or cut short; ` +
+        'browsers reject it too.',
+      { cause: err }
+    );
+  }
+  return fk;
+}

package/lib/trapezoid.js

@@ -1,13 +1,25 @@
 // Trapezoidal decomposition of flattened closed polygons (non-zero winding
 // by default, even-odd optionally), producing XRender AddTraps data.
 //
-// A horizontal slab sweep: slab boundaries are the sorted unique vertex y
-// coordinates, so edges never cross inside a slab (self-intersecting input —
-// e.g. overlapping composite-glyph contours — degrades gracefully to a
-// near-correct fill instead of failing). Spans where the winding number is
-// non-zero become trapezoids; a span whose left/right edges continue through
-// consecutive slabs is merged into a single tall trapezoid, which is what
-// keeps the output at roughly one trapezoid per outline edge.
+// A horizontal slab sweep. Slab boundaries are the sorted unique vertex y
+// coordinates, and where two edges cross inside a slab the slab is split at
+// the crossing, so that within every slab the active edges keep one
+// left-to-right order from top to bottom. Spans between them are then true
+// trapezoids, and self-intersecting input — a pentagram, two crossed bars,
+// overlapping composite-glyph contours — is filled exactly by its rule.
+// Spans where the rule says "inside" become trapezoids; a span whose
+// left/right edges continue through consecutive slabs is merged into a
+// single tall trapezoid, which is what keeps the output at roughly one
+// trapezoid per outline edge (plus a few per crossing).
+//
+// Crossings are found the way a Bentley-Ottmann sweep finds them: the first
+// change of order below a line is always between two edges adjacent on it,
+// so each step takes the earliest crossing of an adjacent pair whose order
+// is reversed at the slab's bottom, cuts there and swaps the pair. Every
+// swap removes one inversion of the bottom order, so the loop ends however
+// the floats round. Differences within a hair of the input's magnitude —
+// collinear edges, crossings right at a slab's top or bottom — are rounding,
+// not geometry: they cause no split and cut no sliver.
 //
 // Output is the flat number list node-x11's Render.AddTraps expects:
 // 6 values per trapezoid — top spanfix (left x, right x, y) then bottom
@@ -26,6 +38,8 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
   // collect non-horizontal edges, normalized to y0 < y1 with winding dir
   const edges = [];
   const ys = [];
+  // the largest coordinate magnitude, which sets the rounding noise
+  let reach = 1;
   for (const poly of polys) {
     const n = poly.length / 2;
     for (let i = 0; i < n; ++i) {
@@ -35,15 +49,22 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
       const bx = poly[j * 2] + dx;
       const by = poly[j * 2 + 1] + dy;
       if (ay === by) continue;
+      const slope = (bx - ax) / (by - ay);
       edges.push(
         ay < by
-          ? { x0: ax, y0: ay, x1: bx, y1: by, dir: 1, xa: 0, xb: 0 }
-          : { x0: bx, y0: by, x1: ax, y1: ay, dir: -1, xa: 0, xb: 0 }
+          ? { x0: ax, y0: ay, y1: by, slope, dir: 1, xt: 0, xb: 0, xc: 0 }
+          : { x0: bx, y0: by, y1: ay, slope, dir: -1, xt: 0, xb: 0, xc: 0 }
       );
       ys.push(ay, by);
+      const m = Math.max(Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by));
+      if (m > reach) reach = m;
     }
   }
   if (edges.length === 0) return out;
+  // ~256 ulps of the largest coordinate: far above what evaluating an edge
+  // at a height rounds by, far below a 16.16 fixed-point step at any
+  // coordinate that fits one
+  const eps = reach * 2 ** -44;
 
   ys.sort((a, b) => a - b);
   edges.sort((a, b) => a.y0 - b.y0);
@@ -72,52 +93,97 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
       continue;
     }
 
-    // x at slab top/bottom for each active edge; sort left-to-right
+    // x at slab top/bottom for each active edge; sort left-to-right just
+    // below the top (edges leaving one point go by where they are headed)
     for (const e of active) {
-      const inv = (e.x1 - e.x0) / (e.y1 - e.y0);
-      e.xa = e.x0 + (ya - e.y0) * inv;
-      e.xb = e.x0 + (yb - e.y0) * inv;
+      e.xt = e.x0 + (ya - e.y0) * e.slope;
+      e.xb = e.x0 + (yb - e.y0) * e.slope;
     }
-    active.sort((a, b) => a.xa + a.xb - (b.xa + b.xb));
+    active.sort((a, b) => a.xt - b.xt || a.xb - b.xb);
 
-    // emit a span per maximal interior interval; interiority is decided by
-    // the fill rule (non-zero winding, or crossing parity for even-odd)
-    const spans = [];
-    let winding = 0;
-    let crossings = 0;
-    let left = null;
-    for (const e of active) {
-      const wasInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
-      winding += e.dir;
-      crossings++;
-      const isInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
-      if (!wasInside && isInside) {
-        left = e;
-      } else if (wasInside && !isInside && left) {
-        // merge with a span from the previous slab bounded by the same edges
-        let merged = false;
-        for (const p of prevSpans) {
-          if (p.l === left && p.r === e && out[p.at + 5] === ya) {
-            out[p.at + 3] = left.xb;
-            out[p.at + 4] = e.xb;
-            out[p.at + 5] = yb;
-            spans.push(p);
-            merged = true;
-            break;
-          }
+    // cut the slab at each crossing, top to bottom; `y` is where the part
+    // still to emit starts, and `xt` each edge's x there
+    let y = ya;
+    for (;;) {
+      let yc = yb;
+      let k = -1;
+      for (let i = 0; i + 1 < active.length; ++i) {
+        const a = active[i];
+        const b = active[i + 1];
+        // how far `a` ends up right of `b`, and how far left of it it starts
+        const over = a.xb - b.xb;
+        if (!(over > eps)) continue;
+        const gap = b.xt - a.xt;
+        const at = gap > 0 ? y + (yb - y) * (gap / (gap + over)) : y;
+        if (at < yc) {
+          yc = at;
+          k = i;
         }
-        if (!merged && (e.xa > left.xa || e.xb > left.xb)) {
-          spans.push({ l: left, r: e, at: out.length });
-          out.push(left.xa, e.xa, ya, left.xb, e.xb, yb);
-        }
-        left = null;
       }
+      if (k < 0 || yc >= yb - eps) {
+        prevSpans = emitSpans(active, y, yb, true, evenodd, prevSpans, out);
+        break;
+      }
+      if (yc > y + eps) {
+        for (const e of active) e.xc = e.x0 + (yc - e.y0) * e.slope;
+        prevSpans = emitSpans(active, y, yc, false, evenodd, prevSpans, out);
+        for (const e of active) e.xt = e.xc;
+        y = yc;
+      }
+      const a = active[k];
+      active[k] = active[k + 1];
+      active[k + 1] = a;
     }
-    prevSpans = spans;
   }
   return out;
 }
 
+/**
+ * Emit a span per maximal interior interval of the slab `ya`..`yb`;
+ * interiority is decided by the fill rule (non-zero winding, or crossing
+ * parity for even-odd). Each edge is at `xt` at the top, and at the bottom
+ * at `xb` when this is the `last` part of its vertex slab, else at `xc`. A
+ * span bounded by the same two edges as one ending at `ya` extends that
+ * trapezoid instead.
+ * @returns the spans, for the next slab to merge with
+ */
+function emitSpans(active, ya, yb, last, evenodd, prevSpans, out) {
+  const spans = [];
+  let winding = 0;
+  let crossings = 0;
+  let left = null;
+  for (const e of active) {
+    const wasInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
+    winding += e.dir;
+    crossings++;
+    const isInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
+    if (!wasInside && isInside) {
+      left = e;
+    } else if (wasInside && !isInside && left) {
+      const lb = last ? left.xb : left.xc;
+      const rb = last ? e.xb : e.xc;
+      // merge with a span from the previous slab bounded by the same edges
+      let merged = false;
+      for (const p of prevSpans) {
+        if (p.l === left && p.r === e && out[p.at + 5] === ya) {
+          out[p.at + 3] = lb;
+          out[p.at + 4] = rb;
+          out[p.at + 5] = yb;
+          spans.push(p);
+          merged = true;
+          break;
+        }
+      }
+      if (!merged && (e.xt > left.xt || rb > lb)) {
+        spans.push({ l: left, r: e, at: out.length });
+        out.push(left.xt, e.xt, ya, lb, rb, yb);
+      }
+      left = null;
+    }
+  }
+  return spans;
+}
+
 /** area covered by a trapezoid list (useful for tests/diagnostics) */
 export function trapArea(traps) {
   let area = 0;