ntk 8.18.0 → 8.18.1

package/lib/app.js

@@ -991,6 +991,9 @@ export default class App {
       p = new Picture(this, { id: pid });
       p._sourcePixmap = pixmap; // keep the 1x1 pixmap alive alongside the picture
     }
+    // what it paints with, so a drawing can fold `globalAlpha` into it: glyphs
+    // composite straight from their source, with no mask slot to carry one
+    p._rgba = Object.freeze([r, g, b, a]);
     this._solidPictures.set(key, p);
     return p;
   }

package/lib/precise.js

@@ -144,22 +144,27 @@ function edgeInit(edge, yStart, xTop, yTop, xBot, yBot) {
   let signdx = 0;
   let rem = 0;
   if (dy) {
+    // Plain float divisions truncate exactly here. A quotient of integers
+    // whose dividend is below 2^45 sits at least 1/dy from any integer it
+    // is not, and a double holds it to within (dividend / dy) · 2^-52, far
+    // closer than that. The step from the line's top below, whose dividend
+    // can pass 2^53, keeps idiv.
     if (dx >= 0) {
       signdx = 1;
-      stepx = idiv(dx, dy);
-      rem = dx % dy;
+      stepx = Math.trunc(dx / dy);
+      rem = dx - stepx * dy;
       e = -dy;
     } else {
       signdx = -1;
-      stepx = -idiv(-dx, dy);
-      rem = -dx % dy;
+      stepx = -Math.trunc(-dx / dy);
+      rem = -dx + stepx * dy;
     }
     // _pixman_edge_multi_init for the small and the big step; n is at most
     // 4370, so every product here is exact in a double
     let ne = STEP_Y_SMALL * rem;
     let sx = (STEP_Y_SMALL * stepx) | 0;
     if (ne > 0) {
-      const nx = idiv(ne, dy) | 0;
+      const nx = Math.trunc(ne / dy);
       ne -= nx * dy;
       sx = (sx + nx * signdx) | 0;
     }
@@ -168,7 +173,7 @@ function edgeInit(edge, yStart, xTop, yTop, xBot, yBot) {
     ne = STEP_Y_BIG * rem;
     sx = (STEP_Y_BIG * stepx) | 0;
     if (ne > 0) {
-      const nx = idiv(ne, dy) | 0;
+      const nx = Math.trunc(ne / dy);
       ne -= nx * dy;
       sx = (sx + nx * signdx) | 0;
     }
@@ -219,9 +224,20 @@ function edgeInit(edge, yStart, xTop, yTop, xBot, yBot) {
   edge[SIGNDX] = signdx;
 }
 
+// RENDER_SAMPLES_X for every fraction of a pixel: how many of a pixel's 17
+// sample columns lie left of an edge that crosses it there
+const SAMPLES_X = new Uint8Array(65536);
+for (let f = 0; f < 65536; f++) SAMPLES_X[f] = ((f + X_FRAC_FIRST) / STEP_X_SMALL) | 0;
+
 /**
  * rasterize_edges_8 between `left` and `right`, from sample row `t` to `b`
  * inclusive, into the difference array `acc` (rows `stride` apart).
+ *
+ * A span adds 17 - ls to the pixel it starts in, 17 to each pixel after, rs
+ * to the pixel it ends in and nothing past it: the difference of two steps,
+ * each two cells of `acc`. While an edge stays in one pixel from sample row
+ * to sample row, as a steep one does for all fifteen, its two cells are
+ * summed here and written once.
  */
 function addSpans(acc, stride, width, t, b) {
   let y = t;
@@ -245,54 +261,92 @@ function addSpans(acc, stride, width, t, b) {
   // pixman clips the span to the image: from 0, and to the last pixel of
   // the row taken whole. Both are what an unclipped span would add there.
   const lastX = (width << 16) - 1;
+  // each edge's step not yet written: the pixel it is in (-1 for none), and
+  // what it adds to that cell and to the next
+  let lPixel = -1;
+  let lAt = 0;
+  let lPast = 0;
+  let rPixel = -1;
+  let rAt = 0;
+  let rPast = 0;
+  // an edge's step carries one more unit of x when its error term passes
+  // zero: computed, not branched on, since a slope's carries come in no
+  // pattern a branch predictor can learn
+  let c = 0;
   for (;;) {
     const l = lx < 0 ? 0 : lx;
     const r = rx >> 16 >= width ? lastX : rx;
     if (r > l) {
-      // the span adds 17 - ls to the pixel it starts in, 17 to each pixel
-      // after, rs to the pixel it ends in and nothing past it: the
-      // difference of two steps, each two cells of `acc`
       const li = l >> 16;
+      const ls = SAMPLES_X[l & 0xffff];
+      if (li !== lPixel) {
+        if (lPixel >= 0) {
+          acc[row + lPixel] += lAt;
+          acc[row + lPixel + 1] += lPast;
+        }
+        lPixel = li;
+        lAt = 0;
+        lPast = 0;
+      }
+      lAt += N_X_FRAC - ls;
+      lPast += ls;
       const ri = r >> 16;
-      const ls = (((l & 0xffff) + X_FRAC_FIRST) / STEP_X_SMALL) | 0;
-      const rs = (((r & 0xffff) + X_FRAC_FIRST) / STEP_X_SMALL) | 0;
-      acc[row + li] += N_X_FRAC - ls;
-      acc[row + li + 1] += ls;
-      acc[row + ri] -= N_X_FRAC - rs;
-      acc[row + ri + 1] -= rs;
+      const rs = SAMPLES_X[r & 0xffff];
+      if (ri !== rPixel) {
+        if (rPixel >= 0) {
+          acc[row + rPixel] -= rAt;
+          acc[row + rPixel + 1] -= rPast;
+        }
+        rPixel = ri;
+        rAt = 0;
+        rPast = 0;
+      }
+      rAt += N_X_FRAC - rs;
+      rPast += rs;
     }
-    if (y === b) return;
+    if (y === b) break;
     if ((y & 0xffff) !== Y_FRAC_LAST) {
-      lx = (lx + lsxs) | 0;
       le = (le + ldxs) | 0;
-      if (le > 0) {
-        le = (le - ldy) | 0;
-        lx = (lx + lsign) | 0;
-      }
-      rx = (rx + rsxs) | 0;
+      c = -le >>> 31;
+      le = (le - c * ldy) | 0;
+      lx = (lx + lsxs + c * lsign) | 0;
       re = (re + rdxs) | 0;
-      if (re > 0) {
-        re = (re - rdy) | 0;
-        rx = (rx + rsign) | 0;
-      }
+      c = -re >>> 31;
+      re = (re - c * rdy) | 0;
+      rx = (rx + rsxs + c * rsign) | 0;
       y = (y + STEP_Y_SMALL) | 0;
     } else {
-      lx = (lx + lsxb) | 0;
       le = (le + ldxb) | 0;
-      if (le > 0) {
-        le = (le - ldy) | 0;
-        lx = (lx + lsign) | 0;
-      }
-      rx = (rx + rsxb) | 0;
+      c = -le >>> 31;
+      le = (le - c * ldy) | 0;
+      lx = (lx + lsxb + c * lsign) | 0;
       re = (re + rdxb) | 0;
-      if (re > 0) {
-        re = (re - rdy) | 0;
-        rx = (rx + rsign) | 0;
-      }
+      c = -re >>> 31;
+      re = (re - c * rdy) | 0;
+      rx = (rx + rsxb + c * rsign) | 0;
       y = (y + STEP_Y_BIG) | 0;
+      // the pixel row is done: write what it left pending
+      if (lPixel >= 0) {
+        acc[row + lPixel] += lAt;
+        acc[row + lPixel + 1] += lPast;
+        lPixel = -1;
+      }
+      if (rPixel >= 0) {
+        acc[row + rPixel] -= rAt;
+        acc[row + rPixel + 1] -= rPast;
+        rPixel = -1;
+      }
       row += stride;
     }
   }
+  if (lPixel >= 0) {
+    acc[row + lPixel] += lAt;
+    acc[row + lPixel + 1] += lPast;
+  }
+  if (rPixel >= 0) {
+    acc[row + rPixel] -= rAt;
+    acc[row + rPixel + 1] -= rPast;
+  }
 }
 
 /** the first sample row of a band from `top`, inside the grid */

package/lib/renderingcontext_2d.js

@@ -3169,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) => {
@@ -3195,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
@@ -3215,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;
@@ -3294,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(
@@ -3314,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,
@@ -3350,6 +3367,7 @@ class RenderingContext2d {
       this.width,
       this.height,
     );
+    if (rect) this._invalidatePictureClip();
     this._markDirty();
   }
 
@@ -4723,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;
@@ -5216,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/trapezoid.js

@@ -37,7 +37,7 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
   const evenodd = rule === 'evenodd';
   // collect non-horizontal edges, normalized to y0 < y1 with winding dir
   const edges = [];
-  const ys = [];
+  let ys = [];
   // the largest coordinate magnitude, which sets the rounding noise
   let reach = 1;
   for (const poly of polys) {
@@ -66,14 +66,17 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
   // coordinate that fits one
   const eps = reach * 2 ** -44;
 
-  ys.sort((a, b) => a - b);
+  // a typed array sorts numerically without a comparator call per step
+  ys = Float64Array.from(ys).sort();
   edges.sort((a, b) => a.y0 - b.y0);
 
   const active = [];
   let nextEdge = 0;
-  // spans open from the previous slab, for vertical merging:
-  // { l: leftEdge, r: rightEdge, at: index of the trap in `out` }
+  // spans open from the previous slab, for vertical merging, and the ones
+  // this slab opens: flat [leftEdge, rightEdge, index of the trap in `out`]
+  // triples, two buffers that trade places every slab
   let prevSpans = [];
+  let spans = [];
 
   for (let yi = 0; yi < ys.length - 1; ++yi) {
     const ya = ys[yi];
@@ -81,25 +84,38 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
     if (yb === ya) continue;
 
     // update the active edge list for this slab
-    for (let i = active.length - 1; i >= 0; --i) {
-      if (active[i].y1 <= ya) active.splice(i, 1);
+    let kept = 0;
+    for (let i = 0; i < active.length; ++i) {
+      if (active[i].y1 > ya) active[kept++] = active[i];
     }
+    active.length = kept;
     while (nextEdge < edges.length && edges[nextEdge].y0 <= ya) {
       if (edges[nextEdge].y1 > ya) active.push(edges[nextEdge]);
       nextEdge++;
     }
     if (active.length === 0) {
-      prevSpans = [];
+      prevSpans.length = 0;
       continue;
     }
 
     // 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) {
+    for (let i = 0; i < active.length; ++i) {
+      const e = active[i];
       e.xt = e.x0 + (ya - e.y0) * e.slope;
       e.xb = e.x0 + (yb - e.y0) * e.slope;
     }
-    active.sort((a, b) => a.xt - b.xt || a.xb - b.xb);
+    // a slab holds a handful of edges, mostly in last slab's order: an
+    // insertion sort, stable as Array#sort is, so the order is the same
+    for (let i = 1; i < active.length; ++i) {
+      const e = active[i];
+      let j = i - 1;
+      while (j >= 0 && (active[j].xt - e.xt || active[j].xb - e.xb) > 0) {
+        active[j + 1] = active[j];
+        --j;
+      }
+      active[j + 1] = e;
+    }
 
     // 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
@@ -121,13 +137,18 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
         }
       }
       if (k < 0 || yc >= yb - eps) {
-        prevSpans = emitSpans(active, y, yb, true, evenodd, prevSpans, out);
+        emitSpans(active, y, yb, true, evenodd, prevSpans, spans, out);
+        [prevSpans, spans] = [spans, prevSpans];
         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;
+        for (let i = 0; i < active.length; ++i) {
+          const e = active[i];
+          e.xc = e.x0 + (yc - e.y0) * e.slope;
+        }
+        emitSpans(active, y, yc, false, evenodd, prevSpans, spans, out);
+        [prevSpans, spans] = [spans, prevSpans];
+        for (let i = 0; i < active.length; ++i) active[i].xt = active[i].xc;
         y = yc;
       }
       const a = active[k];
@@ -144,15 +165,16 @@ export function trapezoidize(polys, dx = 0, dy = 0, out = [], rule = 'nonzero')
  * 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
+ * trapezoid instead. The spans go into `spans`, emptied first, for the next
+ * slab to merge with.
  */
-function emitSpans(active, ya, yb, last, evenodd, prevSpans, out) {
-  const spans = [];
+function emitSpans(active, ya, yb, last, evenodd, prevSpans, spans, out) {
+  spans.length = 0;
   let winding = 0;
   let crossings = 0;
   let left = null;
-  for (const e of active) {
+  for (let i = 0; i < active.length; ++i) {
+    const e = active[i];
     const wasInside = evenodd ? (crossings & 1) === 1 : winding !== 0;
     winding += e.dir;
     crossings++;
@@ -164,24 +186,24 @@ function emitSpans(active, ya, yb, last, evenodd, prevSpans, out) {
       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);
+      for (let p = 0; p < prevSpans.length; p += 3) {
+        const at = prevSpans[p + 2];
+        if (prevSpans[p] === left && prevSpans[p + 1] === e && out[at + 5] === ya) {
+          out[at + 3] = lb;
+          out[at + 4] = rb;
+          out[at + 5] = yb;
+          spans.push(left, e, at);
           merged = true;
           break;
         }
       }
       if (!merged && (e.xt > left.xt || rb > lb)) {
-        spans.push({ l: left, r: e, at: out.length });
+        spans.push(left, e, 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) */

package/package.json

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