ntk 8.17.8 → 8.18.1

package/lib/renderingcontext_2d.js

@@ -29,6 +29,7 @@ import Picture from "./picture.js";
 import { formatForDepth } from "./pictformat.js";
 import Pixmap from "./pixmap.js";
 import { REGION_DOCS, regionId } from "./region.js";
+import { snapFixed16 } from "./precise.js";
 import { routeRaster } from "./rasterize.js";
 import {
   clipRingToRect,
@@ -2098,29 +2099,33 @@ class RenderingContext2d {
     });
   }
 
-  _rasterizePolys(
-    picture,
-    shapes,
-    rule,
-    dx = 0,
-    dy = 0,
-    w = this.width,
-    h = this.height,
-  ) {
-    if (!shapes.length) return;
-    // Trapezoids are 16.16 fixed point, and a coordinate past 32,767 throws
-    // out of the paint (lib/cliprect.js). A shape that reaches that far is
-    // cut to the picture first, a pixel to spare on every side: nothing
-    // outside the picture is ever composited. One that does not goes as it
-    // came, for the server to clip.
+  /**
+   * The shapes a `w`×`h` picture whose pixel (0, 0) is device (-dx, -dy)
+   * is sent, in device space: `_rasterizePolys` trapezoidizes them for the
+   * server, and the local route hands the same ones to the rasterizer, so
+   * that both rasterize one geometry (lib/precise.js).
+   *
+   * Trapezoids are 16.16 fixed point, and a coordinate past 32,767 throws
+   * out of the paint (lib/cliprect.js). They go on the wire in device space
+   * with the picture's offset beside them, which the server adds, so a
+   * shape has to be in reach both in device space and in the picture's.
+   * One that is not is cut to the picture first, a pixel to spare on every
+   * side: nothing outside the picture is ever composited. One in reach
+   * goes as it came, for the server to clip.
+   */
+  _wireShapes(shapes, dx = 0, dy = 0, w = this.width, h = this.height) {
     const x0 = -dx - 1;
     const y0 = -dy - 1;
     const x1 = w - dx + 1;
     const y1 = h - dy + 1;
+    const rx0 = Math.max(-WIRE_REACH, -WIRE_REACH - dx);
+    const ry0 = Math.max(-WIRE_REACH, -WIRE_REACH - dy);
+    const rx1 = Math.min(WIRE_REACH, WIRE_REACH - dx);
+    const ry1 = Math.min(WIRE_REACH, WIRE_REACH - dy);
     let fitted = null;
     for (let i = 0; i < shapes.length; i++) {
       const shape = shapes[i];
-      if (withinRect(shape, -WIRE_REACH - dx, -WIRE_REACH - dy, WIRE_REACH - dx, WIRE_REACH - dy)) {
+      if (withinRect(shape, rx0, ry0, rx1, ry1)) {
         if (fitted) fitted.push(shape);
         continue;
       }
@@ -2128,11 +2133,30 @@ class RenderingContext2d {
       const ring = clipRingToRect(shape, x0, y0, x1, y1);
       if (ring.length >= 6) fitted.push(ring);
     }
-    const traps = trapezoidize(fitted ?? shapes, dx, dy, [], rule);
+    return fitted ?? shapes;
+  }
+
+  _rasterizePolys(
+    picture,
+    shapes,
+    rule,
+    dx = 0,
+    dy = 0,
+    w = this.width,
+    h = this.height,
+  ) {
+    if (!shapes.length) return;
+    // In device space and on the 16.16 grid, with the offset into the
+    // picture left to the request: these are the numbers PreciseRasterizer
+    // rasterizes when the same mask is drawn here, so the two routes agree
+    // to the byte. An offset folded into the coordinates instead rounds
+    // differently from one added to them on the wire.
+    const traps = trapezoidize(this._wireShapes(shapes, dx, dy, w, h), 0, 0, [], rule);
+    for (let i = 0; i < traps.length; i++) traps[i] = snapFixed16(traps[i]);
     // stay under the server's maximum request size
     const chunk = 4000 * 6;
     for (let i = 0; i < traps.length; i += chunk) {
-      this.Render.AddTraps(picture.id, 0, 0, traps.slice(i, i + chunk));
+      this.Render.AddTraps(picture.id, dx, dy, traps.slice(i, i + chunk));
     }
   }
 
@@ -2491,17 +2515,20 @@ class RenderingContext2d {
         box = box ? unionBox(box, shown) : shown;
       }
       if (!box) continue;
+      // what the server would be sent for the surface-sized mask, so that
+      // drawn here it comes out the same
+      const wire = this._wireShapes(flat);
       painted =
         this._paintThroughMask(
           box,
-          { polys: flat, rule },
+          { polys: wire, rule },
           {
             edges: drawn,
             route: this._routeFor(cluster, edges),
             src,
             op,
             alpha,
-            server: () => this._rasterizePolys(this.fillMask, flat, rule),
+            server: () => this._rasterizePolys(this.fillMask, wire, rule),
           },
         ) || painted;
     }
@@ -2864,6 +2891,10 @@ class RenderingContext2d {
     }
     if (w < tris.length) tris.length = w;
     if (!tris.length) return;
+    // On the 16.16 grid the wire carries, once, for every route below: the
+    // server rasterizes these numbers, and so does PreciseRasterizer when
+    // the stroke is drawn here (lib/precise.js)
+    for (let i = 0; i < tris.length; i++) tris[i] = snapFixed16(tris[i]);
 
     const op = this._op();
     // round-cap/join disks overlap the stroke body; overlapping coverage
@@ -3138,8 +3169,12 @@ class RenderingContext2d {
    * relative positions, painted under the glyphs (issue #283). A paragraph
    * whose spans change colour draws as several calls, and — as several
    * `fillText`s would — casts a shadow per call.
+   *
+   * So does `globalAlpha`, to the glyphs and their shadow both, as it does
+   * to every fill: at 0 nothing is drawn, not even the shadow.
    */
   drawGlyphs(op, src, positioned) {
+    if (this.globalAlpha <= 0) return;
     const m = this._m;
     if (!matIsIdentity(m)) {
       positioned = positioned.map((p) => {
@@ -3164,12 +3199,19 @@ class RenderingContext2d {
    * instead, intersect that with the clip, and paint the real source
    * through the result — the same shape as _fillPolys. A rectangular clip
    * takes the server-side fast path below instead of the mask.
+   *
+   * Nor has it a mask slot for `globalAlpha`, which is why text used to be
+   * drawn at full opacity whatever it was. A solid source takes the alpha
+   * in its colour, as `fillRect`'s does, and the glyphs go the way they
+   * always went; a gradient or a pattern has no one colour to fold it
+   * into, and paints through the scratch mask with the alpha in there.
    */
   _drawGlyphsDevice(op, src, positioned) {
+    if (this.globalAlpha <= 0) return;
     const app = this.window.app;
-    const R = this.Render;
     if (!prepareStyle(src, this._m, this.width, this.height)) return;
-    if (!this._hasPolyClip) {
+    const faded = this._fadedSource(src);
+    if (faded && !this._hasPolyClip) {
       // Fast path: a rectangular clip is something the server can do itself.
       // Two small requests around the ordinary glyph composite, instead of
       // clearing and compositing a full-surface a8 mask three times — which
@@ -3184,77 +3226,37 @@ class RenderingContext2d {
       drawGlyphRuns(
         app,
         op,
-        src.id,
+        faded.id,
         this._dst(),
         positioned,
         rect ?? { x: 0, y: 0, w: this.width, h: this.height },
-        sourceOrigin(src),
+        sourceOrigin(faded),
       );
       if (rect) this._invalidatePictureClip();
       this._markDirty();
       return;
     }
-    const clipMask = this._requireClipMask();
-    this._ensureFillMask();
-    this._glyphSource ??= this.createSolidPicture(1, 1, 1, 1);
-    R.FillRectangles(
-      R.PictOp.Src,
-      this.fillMask.id,
-      [0, 0, 0, 0],
-      [0, 0, this.width, this.height],
-    );
-    // solid white through the glyphs leaves their coverage in the a8 mask
-    drawGlyphRuns(
-      app,
-      R.PictOp.Over,
-      this._glyphSource.id,
-      this.fillMask.id,
-      positioned,
-      { x: 0, y: 0, w: this.width, h: this.height },
-    );
-    R.Composite(
-      R.PictOp.In,
-      clipMask.id,
-      0,
-      this.fillMask.id,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      this.width,
-      this.height,
-    );
-    const [ox, oy] = sourceOrigin(src);
-    R.Composite(
-      op,
-      src.id,
-      this.fillMask.id,
-      this._dst(),
-      -ox,
-      -oy,
-      0,
-      0,
-      0,
-      0,
-      this.width,
-      this.height,
+    const R = this.Render;
+    const alpha = faded ? 1 : this.globalAlpha;
+    const surface = { x: 0, y: 0, w: this.width, h: this.height };
+    this._paintThroughScratch(op, faded ?? src, alpha, (white, mask) =>
+      drawGlyphRuns(app, R.PictOp.Over, white, mask, positioned, surface),
     );
-    this._markDirty();
   }
 
   /**
    * Trapezoid coverage under the clip — `drawGlyphs` for vector shapes that
    * are already trapezoidized (KaTeX radicals and rules go this way).
    * Without it they composite straight to the destination picture and spill
-   * out of clipped boxes, which is what glyphs used to do.
+   * out of clipped boxes, which is what glyphs used to do. `globalAlpha`
+   * applies as it does to glyphs, so a radical fades with the formula.
    */
   drawTraps(op, src, traps) {
-    if (!traps.length) return;
+    if (!traps.length || this.globalAlpha <= 0) return;
     const app = this.window.app;
-    const R = this.Render;
-    if (!this._hasPolyClip) {
+    if (!prepareStyle(src, this._m, this.width, this.height)) return;
+    const faded = this._fadedSource(src);
+    if (faded && !this._hasPolyClip) {
       const rect = this._clipRect();
       if (rect) {
         if (rect.w === 0 || rect.h === 0) return;
@@ -3263,18 +3265,57 @@ class RenderingContext2d {
       compositeTraps(
         app,
         op,
-        src.id,
+        faded.id,
         this._dst(),
         traps,
         undefined,
         undefined,
-        sourceOrigin(src),
+        sourceOrigin(faded),
       );
       if (rect) this._invalidatePictureClip();
       this._markDirty();
       return;
     }
-    const clipMask = this._requireClipMask();
+    const alpha = faded ? 1 : this.globalAlpha;
+    this._paintThroughScratch(op, faded ?? src, alpha, (white, mask) =>
+      compositeTraps(app, this.Render.PictOp.Over, white, mask, traps),
+    );
+  }
+
+  /**
+   * `src` with `globalAlpha` folded into it: the source itself at full
+   * opacity, and at less, a solid of its colour with all four premultiplied
+   * components scaled — which is compositing it at that opacity, for any op
+   * (`_foldedColor`). Null when there is an alpha to apply and no colour to
+   * fold it into: a gradient, a pattern, a picture of the caller's, or a
+   * solid from a host whose `solidPicture` does not say what it paints with
+   * (App#solidPicture does).
+   */
+  _fadedSource(src) {
+    const a = this.globalAlpha;
+    if (a >= 1) return src;
+    const c = src._rgba;
+    if (!c) return null;
+    return this.createSolidPicture(c[0] * a, c[1] * a, c[2] * a, c[3] * a);
+  }
+
+  /**
+   * Paint `src` through coverage the server draws into the scratch a8 mask:
+   * how glyphs and trapezoids reach the surface when their own composite
+   * cannot carry what applies to it — a clip that is not a rectangle, or a
+   * `globalAlpha` with no colour to fold into.
+   *
+   * `drawCoverage(white, mask)` composites the coverage into the mask, with
+   * a solid white source: what that leaves in an a8 picture is exactly the
+   * coverage. `alpha` scales it, the clip cuts it — the clip mask for a
+   * stack with a path in it, the picture's clip rectangle for one of
+   * rectangles — and `src` is composited through the result.
+   */
+  _paintThroughScratch(op, src, alpha, drawCoverage) {
+    const R = this.Render;
+    const rect = this._clipRect();
+    if (rect && (rect.w === 0 || rect.h === 0)) return;
+    const clipMask = this._hasPolyClip ? this._requireClipMask() : null;
     this._ensureFillMask();
     this._glyphSource ??= this.createSolidPicture(1, 1, 1, 1);
     R.FillRectangles(
@@ -3283,27 +3324,34 @@ class RenderingContext2d {
       [0, 0, 0, 0],
       [0, 0, this.width, this.height],
     );
-    compositeTraps(
-      app,
-      R.PictOp.Over,
-      this._glyphSource.id,
-      this.fillMask.id,
-      traps,
-    );
-    R.Composite(
-      R.PictOp.In,
-      clipMask.id,
-      0,
-      this.fillMask.id,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      this.width,
-      this.height,
-    );
+    drawCoverage(this._glyphSource.id, this.fillMask.id);
+    if (alpha < 1) {
+      // In with a constant color scales the a8 coverage by that alpha
+      R.FillRectangles(
+        R.PictOp.In,
+        this.fillMask.id,
+        [0, 0, 0, alpha],
+        [0, 0, this.width, this.height],
+      );
+    }
+    if (clipMask) {
+      R.Composite(
+        R.PictOp.In,
+        clipMask.id,
+        0,
+        this.fillMask.id,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        this.width,
+        this.height,
+      );
+    } else if (rect) {
+      this._setPictureClip(rect);
+    }
     const [ox, oy] = sourceOrigin(src);
     R.Composite(
       op,
@@ -3319,6 +3367,7 @@ class RenderingContext2d {
       this.width,
       this.height,
     );
+    if (rect) this._invalidatePictureClip();
     this._markDirty();
   }
 
@@ -4556,7 +4605,8 @@ class RenderingContext2d {
       return false;
 
     const coverage = rasterizer.rasterize({
-      polys: shapes,
+      // what the AddTraps fallback in _applyPolyClip would send
+      polys: this._wireShapes(shapes, -bb.x, -bb.y, bb.w, bb.h),
       rule: entry.rule,
       dx: -bb.x,
       dy: -bb.y,
@@ -4691,7 +4741,8 @@ class RenderingContext2d {
    */
   fillText(text, x, y) {
     text = String(text ?? "");
-    if (!text) return;
+    // nothing to draw, and at globalAlpha 0 nothing to shape it for
+    if (!text || this.globalAlpha <= 0) return;
     if (this._shadowed()) this._shadowOfText(text, x, y);
     const style = this._resolvedTextStyle();
     const app = this.window.app;
@@ -5184,14 +5235,19 @@ class RenderingContext2d {
    * into it. The mask slot is taken by the coverage, so the alpha has to go
    * somewhere — and a 1x1 solid is free, where a surface-sized alpha mask is
    * not. Falls back to the fill picture for gradients, which have no single
-   * colour to fold into; `_drawCoverage` routes those through the scratch. */
+   * colour to fold into; `_drawCoverage` routes those through the scratch.
+   *
+   * All four components are scaled, not the alpha alone: the colour is
+   * premultiplied, and one whose alpha shrank under unchanged components is
+   * brighter than it can be — `#0000ff` at 0.5 over black came out
+   * `#0000ff`, where `fillRect` draws `#000080`. */
   _coverageSource() {
     const style = this._fillStyle;
     if (this.globalAlpha >= 1 || !isPlainColor(style)) {
       return this._backgroundPicture;
     }
-    const c = parseColor(style);
-    return this.createSolidPicture(c[0], c[1], c[2], c[3] * this.globalAlpha);
+    const c = this._foldedColor(style);
+    return this.createSolidPicture(c[0], c[1], c[2], c[3]);
   }
 
   /**

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;
+}