ntk 8.12.8 → 8.12.10

package/lib/renderingcontext_2d.js

@@ -4637,6 +4637,8 @@ class RenderingContext2d {
         1,
       ]);
       picture.setFilter("bilinear");
+      // the edge clamped, as drawImage's scaled path explains
+      R.ChangePicture(picture.id, { repeat: 2 }); // Repeat.Pad
     }
     // with a transform in place the mask is already sampled from (sx, sy)
     const mx = scaled ? 0 : sx;
@@ -4756,6 +4758,7 @@ class RenderingContext2d {
       // restore defaults so the cached surface stays reusable as-is
       R.SetPictureTransform(picture.id, [1, 0, 0, 0, 1, 0, 0, 0, 1]);
       picture.setFilter("nearest");
+      R.ChangePicture(picture.id, { repeat: 0 }); // Repeat.None
     }
     this._markDirty();
   }
@@ -4814,6 +4817,16 @@ class RenderingContext2d {
           1,
         ]);
         picture.setFilter("bilinear");
+        // Bilinear sampling at the rim reads half a source pixel past the
+        // image, and a picture's default repeat reads transparent there: an
+        // upscaled image faded into whatever it was drawn over across its
+        // outer pixels — three of them for a 15-pixel swatch drawn at 96.
+        // The canvas spec's drawImage clamps to the image's edge, and so do
+        // browsers; RepeatPad is that. Only on this axis-aligned path, whose
+        // composite box is the destination rectangle exactly: under a
+        // rotation the box is the bounding box, and pad would paint its
+        // corners.
+        this.Render.ChangePicture(picture.id, { repeat: 2 }); // Repeat.Pad
         this.Render.Composite(
           op,
           picture.id,
@@ -4834,6 +4847,7 @@ class RenderingContext2d {
           [1, 0, 0, 0, 1, 0, 0, 0, 1],
         );
         picture.setFilter("nearest");
+        this.Render.ChangePicture(picture.id, { repeat: 0 }); // Repeat.None
       } else {
         this.Render.Composite(
           op,

package/lib/text/layout.js

@@ -5,9 +5,12 @@ import { drawGlyphRuns } from './glyphs.js';
 import { embeddingLevels, normalizedLevels, reorderRuns } from './shape.js';
 import { worthKeeping } from './paragraphs.js';
 
-const WS = new Set([0x20, 0x09, 0xa0]);
+// The white space a line may end on and hang past its edge: spaces and tabs,
+// as CSS hangs them. A no-break space is not one — CSS measures it, and
+// ` ` at the end of a cell or a span is there to take room.
+const WS = new Set([0x20, 0x09]);
 const HARD_BREAKS = /[\n\r\u2028\u2029]+$/;
-const TRAILING_WS = /[ \t\u00a0]+$/;
+const TRAILING_WS = /[ \t]+$/;
 
 function isWsGlyph(g) {
   return g.codePoints.length > 0 && g.codePoints.every((cp) => WS.has(cp));

package/lib/text/shape.js

@@ -104,18 +104,16 @@ function spacedFeatures(features) {
 /**
  * Space a shaped run's glyphs apart by `spacing` px: added to the advance of
  * every glyph that has one, so a combining mark keeps sitting on its base.
- * An rtl run stores its glyphs in visual order, and its spacing belongs on
- * the *reading* side of each glyph — the left — so there the glyph is drawn
- * that much further along its advance as well.
+ * The gap is on each glyph's right in an rtl run as in an ltr one — where
+ * CoreText's kerning attribute and browsers put it — so a line that changes
+ * direction keeps one gap between every two neighbours: on the reading side
+ * of an rtl run's glyphs it came out twice where the direction changed one
+ * way and not at all where it changed back.
  */
 function spaceGlyphs(shaped, spacing) {
-  const rtl = shaped.direction === 'rtl';
   let width = 0;
   for (const g of shaped.glyphs) {
-    if (g.ax > 0) {
-      g.ax += spacing;
-      if (rtl) g.dx += spacing;
-    }
+    if (g.ax > 0) g.ax += spacing;
     width += g.ax;
   }
   shaped.width = width;

package/package.json

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