emf-converter 4.8.0 → 4.8.2

package/README.md

@@ -217,7 +217,7 @@ Everything is measured against output painted by Windows itself; `src/gdi-parity
 - **Colour adjustment and image effects**: all eleven EMF+ image effects are supported. Complete native tables cover every legal ColorCurve intensity. Deferred draws retain their effects. JPEG, GIF and TIFF have bundled decoders for environments without Canvas. HSL, tint, red-eye, blur, sharpen and GDI colour adjustment retain measured differences; see [the detailed limitations](docs/limitations.md) and the native fixture bounds.
 - **Pen transforms**: EMF+ pen transforms (uniform, nonuniform and skewed) match GDI+ exactly on the 17 pen-transform fixtures, including dashes, which GDI+ lays out along the path in world space at the untransformed pen width. Native fixtures verify dashes under both uniform and non-uniform scales. GDI+ rejects singular pen transforms; the converter ignores such malformed transform data. Square, round, diamond and arrow anchor caps use their native shapes; the new centered-cap fixtures match every pixel with and without antialiasing.
 - **Text**: ANSI, multi-string and small-text records now render; the Windows text fixtures retain a few glyph-edge differences and a `PolyTextOut` C1 control-glyph difference (under 0.1% of pixels; bounds in `src/emf-text-records.fixture.test.ts`). ANSI decoding uses the host's `TextDecoder` for common Windows code pages; Johab and OEM CP437 use bundled Windows mappings. Vertical `ETO_PDY` advances work with and without the `fonts` engine. Without `fonts`, SVG text measurements use deterministic estimates, so precise justification requires supplying the matching fonts.
-- **Wide pens and paths**: flat-capped GDI pens 7 px and wider can differ by a few pixels at round joins, and dashed wide Bezier curves follow `WidenPath` (which Windows' direct drawing does not quite match); at most 0.2% of pixels on the fixtures. `EMR_WIDENPATH` does not reproduce the extra inner join triangles GDI's own `WidenPath` emits (visible only when the widened outline is itself stroked). EMF+ 1-pixel antialiased lines can differ by one antialiasing sample at their ends, some closed widened outlines by one sample along an edge, and Inset or compound pens on closed figures are approximate.
+- **Wide pens and paths**: flat-capped GDI pens 7 px and wider can differ by a few pixels at round joins, and dashed wide curves follow `WidenPath` (exact for round and flat caps at one logical unit per pixel; square caps differ slightly at path ends); at most 0.2% of pixels on the fixtures. `EMR_WIDENPATH` does not reproduce the extra inner join triangles GDI's own `WidenPath` emits (visible only when the widened outline is itself stroked). EMF+ 1-pixel antialiased lines can differ by one antialiasing sample at their ends, some closed widened outlines by one sample along an edge, and Inset or compound pens on closed figures are approximate.
 - **GM_COMPATIBLE recordings**: EMF files do not record the graphics mode, and Windows plays RoundRect, Arc, Chord, Pie and null-pen Ellipse records back differently from how a GM_COMPATIBLE application drew them on screen; the converter follows Windows' playback.
 - **Small EMF+ residuals**: rotated `HighQualityBicubic` `DrawImage` edge pixels (0.14%), one-level differences at exact half-level `Blend` knots, and a few pixels of a metafile nested in `DrawImage` under a scale.
 - **WMF**: `PS_INSIDEFRAME` boxes can come out a pixel short at non-integer scales, right-to-left (`LAYOUT_RTL`) layouts differ by single pixels on mirrored diagonals, and metric map modes assume a 96 dpi reference device (Windows derives them from the physical display, so its own output varies per machine).

package/dist/browser.js

@@ -16403,8 +16403,8 @@ function midtoneGamma(t) {
     low = high;
     high = (high + 100) / 2;
   }
-  gamma = Math.abs(t) === 100 ? 10 : Math.min(10, gamma + (Math.abs(t) - low) / (high - low));
-  return Math.fround(t < 0 ? gamma : 1 / gamma);
+  gamma = Math.abs(t) === 100 ? 10 : Math.min(10, truncF32(gamma + truncF32(truncF32(Math.abs(t) - low) / truncF32(high - low))));
+  return t < 0 ? truncF32(gamma) : truncF32(1 / truncF32(gamma));
 }
 function brightnessContrastLut(brightness, contrast) {
   const gain = contrast >= 100 ? 1e6 : contrast >= 0 ? 100 / (100 - contrast) : (100 + contrast) / 100;
@@ -16421,6 +16421,23 @@ function curveAdjustmentLut(adjustment, intensity) {
   return nativeCurveLookup(adjustment, clamp(Math.trunc(intensity), min, max)).slice();
 }
 function levelsLut(highlight, midtone, shadow) {
+  if (highlight !== shadow) {
+    const forward = highlight > shadow;
+    const lo = truncF32((forward ? shadow : highlight) * 255 / 100);
+    const hi = truncF32((forward ? highlight : shadow) * 255 / 100);
+    const scale = truncF32(1 / truncF32(hi - lo));
+    const exponent2 = midtoneGamma(midtone);
+    const lut = new Uint8Array(256);
+    for (let v = 0; v < 256; v++) {
+      let level = clamp(truncF32(truncF32(v - lo) * scale), 0, 1);
+      if (midtone !== 0) {
+        level = truncF32(level ** exponent2);
+      }
+      const out = forward ? truncF32(255 * level) : truncF32(255 - truncF32(255 * level));
+      lut[v] = clamp(Math.floor(out + 0.5), 0, 255);
+    }
+    return lut;
+  }
   const base = shadow * 255 / 100 - (highlight === shadow && shadow < 50 ? 1 : 0);
   const span = highlight === shadow ? 1 : (highlight - shadow) * 255 / 100;
   const exponent = midtoneGamma(midtone);
@@ -16453,14 +16470,6 @@ function applyColorMatrix(src, m) {
   }
   return out;
 }
-function hslToRgb(h, s, l) {
-  const c = (1 - Math.abs(2 * l - 1)) * s;
-  const hp = (h % 360 + 360) % 360 / 60;
-  const x = c * (1 - Math.abs(hp % 2 - 1));
-  const m = l - c / 2;
-  const [r, g, b] = hp < 1 ? [c, x, 0] : hp < 2 ? [x, c, 0] : hp < 3 ? [0, c, x] : hp < 4 ? [0, x, c] : hp < 5 ? [x, 0, c] : [c, 0, x];
-  return [r + m, g + m, b + m];
-}
 var HUE_SEXTANT = 43;
 var HUE_CIRCLE = 255;
 function gdipHue(r, g, b) {
@@ -16483,29 +16492,30 @@ function gdipHue(r, g, b) {
 function applyHueSaturationLightness(src, hue, saturation, lightness) {
   const out = new Uint8ClampedArray(src);
   const shift = Math.round(hue * HUE_CIRCLE / 360);
-  const sMul = 1 + saturation / 100;
+  const satScale = 65536 + Math.floor(saturation * 65536 / 100);
+  const lightOffset = Math.round(255 * Math.floor(lightness * 65536 / 100) / 65536);
   for (let i = 0; i < src.length; i += 4) {
     const r = src[i];
     const g = src[i + 1];
     const b = src[i + 2];
     const max = Math.max(r, g, b);
     const min = Math.min(r, g, b);
-    const l = clamp(Math.round(((max + min >> 1) * 100 + 255 * lightness) / 100), 0, 255);
+    const l = clamp((max + min >> 1) + lightOffset, 0, 255);
     if (max === min) {
       out[i] = out[i + 1] = out[i + 2] = l;
       continue;
     }
     const sum = max + min;
-    const s = Math.fround(clamp((max - min) / (sum <= 255 ? sum : 510 - sum) * sMul, 0, 1));
-    const hi = l <= 127 ? l * (1 + s) : l + s * (255 - l);
-    const m1 = l <= 127 ? 2 * l - Math.trunc(hi) : Math.round(2 * l - hi);
-    const m2 = 2 * l - m1;
+    const sat2 = clamp(Math.round(Math.floor((max - min) * 255 / (sum <= 255 ? sum : 510 - sum)) * satScale / 65536), 0, 255);
+    const hi = l <= 127 ? Math.floor(l * (255 + sat2) / 255) : l + sat2 - Math.floor(l * sat2 / 255);
+    const m1 = 2 * l - hi;
+    const m2 = hi;
     const index = ((gdipHue(r, g, b) + shift) % HUE_CIRCLE + HUE_CIRCLE) % HUE_CIRCLE;
     const q = index + Math.floor((index + 41) / 85);
     const sextant = Math.min(5, Math.floor(q / HUE_SEXTANT));
-    const f = (q - sextant * HUE_SEXTANT) / HUE_SEXTANT;
-    const up = Math.trunc(m1 + (m2 - m1) * f);
-    const down = Math.trunc(m1 + (m2 - m1) * (1 - f));
+    const position = q - sextant * HUE_SEXTANT;
+    const up = m1 + Math.floor((m2 - m1) * position / HUE_SEXTANT);
+    const down = m1 + Math.floor((m2 - m1) * (HUE_SEXTANT - position) / HUE_SEXTANT);
     const [nr, ng, nb] = [
       [m2, up, m1],
       [down, m2, m1],
@@ -16520,28 +16530,40 @@ function applyHueSaturationLightness(src, hue, saturation, lightness) {
   }
   return out;
 }
-var LUMA_709 = [0.2126, 0.7152, 0.0722];
-var TINT_CHROMA_SCALE = 0.985;
 function applyTint(src, hue, amount) {
   const index = (Math.round(hue * 255 / 360) + 256) % 256;
   const q = (index + Math.floor((index + 41) / 85)) % 258;
-  const tint = hslToRgb(q * 60 / 43, 1, 0.5);
-  const ty = tint[0] * LUMA_709[0] + tint[1] * LUMA_709[1] + tint[2] * LUMA_709[2];
-  const chroma = tint.map((c) => (c - ty) * TINT_CHROMA_SCALE);
-  const a = amount / 100;
+  const sextant = Math.min(5, Math.floor(q / HUE_SEXTANT));
+  const position = q - sextant * HUE_SEXTANT;
+  const up = Math.floor(TINT_FULL * position / HUE_SEXTANT);
+  const down = Math.floor(TINT_FULL * (HUE_SEXTANT - position) / HUE_SEXTANT);
+  const [tr, tg, tb] = [
+    [TINT_FULL, up, 0],
+    [down, TINT_FULL, 0],
+    [0, TINT_FULL, up],
+    [0, down, TINT_FULL],
+    [up, 0, TINT_FULL],
+    [TINT_FULL, 0, down]
+  ][sextant];
+  const weight = Math.sign(amount) * Math.floor((255 * Math.abs(amount) + 49) / 100);
+  const original = 255 - weight;
   const out = new Uint8ClampedArray(src);
   for (let i = 0; i < src.length; i += 4) {
     const r = src[i];
     const g = src[i + 1];
     const b = src[i + 2];
-    const y = r * LUMA_709[0] + g * LUMA_709[1] + b * LUMA_709[2];
-    const v = Math.max(r, g, b);
-    out[i] = Math.round((1 - a) * r + a * (y + v * chroma[0]));
-    out[i + 1] = Math.round((1 - a) * g + a * (y + v * chroma[1]));
-    out[i + 2] = Math.round((1 - a) * b + a * (y + v * chroma[2]));
+    const u = weight * Math.max(r, g, b) >> 8;
+    const x0 = original * r + tr * u;
+    const x1 = original * g + tg * u;
+    const x2 = original * b + tb * u;
+    const base = 54 * r + 183 * g + 19 * b - (54 * (x0 >> 8) + 183 * (x1 >> 8) + 19 * (x2 >> 8));
+    out[i] = base + x0 >> 8;
+    out[i + 1] = base + x1 >> 8;
+    out[i + 2] = base + x2 >> 8;
   }
   return out;
 }
+var TINT_FULL = 254;
 function applyRedEyeCorrection(src, width, height, areas) {
   const out = new Uint8ClampedArray(src);
   for (const a of areas) {
@@ -20541,8 +20563,7 @@ function resampleImage(rgba, width, height, spec, surface) {
   const axisAligned = m[1] === 0 && m[2] === 0;
   if (hq && axisAligned) {
     const ox = m[0] * spec.srcX + m[4];
-    const oy = m[3] * spec.srcY + m[5];
-    m = [m[0], 0, 0, m[3], m[4] + mirroredOrigin(ox) - ox, m[5] + mirroredOrigin(oy) - oy];
+    m = [m[0], 0, 0, m[3], m[4] + mirroredOrigin(ox) - ox, m[5]];
   }
   const inv2 = invert2(m);
   if (!inv2) {
@@ -23355,6 +23376,21 @@ var nestedReplayer = null;
 function registerNestedMetafileReplayer(fn) {
   nestedReplayer = fn;
 }
+function inclusiveNestedMapping(toDevice, srcX, srcY, srcW, srcH) {
+  const [a, b, c, d, e, f] = toDevice;
+  const lengthU = Math.hypot(a, b) * srcW;
+  const lengthV = Math.hypot(c, d) * srcH;
+  if (!(srcW > 1 && srcH > 1 && lengthU > 1 && lengthV > 1)) {
+    return toDevice;
+  }
+  const ku = (lengthU - 1) / lengthU * (srcW / (srcW - 1));
+  const kv = (lengthV - 1) / lengthV * (srcH / (srcH - 1));
+  const na = a * ku;
+  const nb = b * ku;
+  const nc = c * kv;
+  const nd = d * kv;
+  return [na, nb, nc, nd, e + (a - na) * srcX + (c - nc) * srcY, f + (b - nb) * srcX + (d - nd) * srcY];
+}
 function drawNestedMetafile(rCtx, img, cached, source) {
   const depth = rCtx.nestingDepth ?? 0;
   if (!nestedReplayer || !source || !img.data || source.unit !== UNIT_PIXEL || depth >= MAX_NESTED_METAFILE_DEPTH) {
@@ -23368,9 +23404,12 @@ function drawNestedMetafile(rCtx, img, cached, source) {
   if (!size) {
     return false;
   }
-  const toCanvas = mulMatrix(
-    [1, 0, 0, 1, -0.5, -0.5],
-    mulMatrix(mulMatrix(plusWorldMatrix(rCtx), source.toWorld(srcX, srcY, srcW, srcH)), [1, 0, 0, 1, 0.5, 0.5])
+  const toCanvas = inclusiveNestedMapping(
+    mulMatrix(plusWorldMatrix(rCtx), source.toWorld(srcX, srcY, srcW, srcH)),
+    srcX,
+    srcY,
+    srcW,
+    srcH
   );
   const bytes = img.data.slice(0);
   const caches = cached && cached.kind === "metafile" ? cached.caches : void 0;
@@ -29189,9 +29228,9 @@ function perpendicularVectors(width, dx0, dy0) {
   const vx = rounded[0], vy = rounded[1];
   return { v: flip ? [-vx, -vy] : [vx, vy], ray: flip ? [-x, -y] : [x, y] };
 }
-function squareExtension(width, dx, dy) {
+function squareExtension(width, dx, dy, scale = 1) {
   const len = Math.hypot(dx, dy);
-  const r = width / 2;
+  const r = width / 2 * scale;
   return [Math.floor(dx / len * r + 0.5), Math.floor(dy / len * r + 0.5)];
 }
 function turnSign(ax, ay, bx, by) {
@@ -29230,7 +29269,7 @@ var Outliner = class {
     const [L, R] = drawVertices(this.pen, d[0], d[1]);
     const perpendicular = curve && drawDir ? drawDir : [dx, dy];
     const vectors = perpendicularVectors(this.opts.width, perpendicular[0], perpendicular[1]);
-    return { dx, dy, L, R, v: vectors.v, vRaw: vectors.ray, e: squareExtension(this.opts.width, perpendicular[0], perpendicular[1]), curveEnd: !!drawDir, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
+    return { dx, dy, L, R, v: vectors.v, vRaw: vectors.ray, e: squareExtension(this.opts.width, perpendicular[0], perpendicular[1]), pe: [perpendicular[0], perpendicular[1]], curveEnd: !!drawDir, tangentLength: drawDir ? drawDir[0] * drawDir[0] + drawDir[1] * drawDir[1] : 0, curve };
   }
   push(p, v) {
     this.pts.push([p[0] + v[0], p[1] + v[1]]);
@@ -29325,7 +29364,7 @@ var Outliner = class {
     return side === "R" ? s.v : [-s.v[0], -s.v[1]];
   }
   /** A cap at `p` from the `from` side of `s` round to the other side (`start`: around the back). */
-  cap(p, s, start) {
+  cap(p, s, start, scale = 1) {
     const from = start ? "L" : "R";
     const to = start ? "R" : "L";
     const { cap } = this.opts;
@@ -29343,7 +29382,8 @@ var Outliner = class {
     const sv = this.capSide(s, from);
     const ev = this.capSide(s, to);
     if (cap === "square") {
-      const e = start ? [-s.e[0], -s.e[1]] : s.e;
+      const e0 = scale === 1 ? s.e : squareExtension(this.opts.width, s.pe[0], s.pe[1], scale);
+      const e = start ? [-e0[0], -e0[1]] : e0;
       this.push(p, [sv[0] + e[0], sv[1] + e[1]]);
       this.push(p, [ev[0] + e[0], ev[1] + e[1]]);
     } else {
@@ -29439,7 +29479,7 @@ var Outliner = class {
    * lets a single point stand for a zero-length dash along `dirs[0]`;
    * `draws` (curve end tangents) picks draw vertices only.
    */
-  open(P, dirs, draws, curves) {
+  open(P, dirs, draws, curves, startScale = 1, endScale = 1) {
     if (P.length < 2 && !dirs?.[0]) {
       this.dot(P[0]);
       return;
@@ -29450,12 +29490,12 @@ var Outliner = class {
     }
     if (segs2.length === 0) {
       const s = this.seg(P[0], P[0], dirs?.[0], draws?.[0], curves?.[0]);
-      this.cap(P[0], s, true);
-      this.cap(P[0], s, false);
+      this.cap(P[0], s, true, startScale);
+      this.cap(P[0], s, false, endScale);
       this.flush();
       return;
     }
-    this.cap(P[0], segs2[0], true);
+    this.cap(P[0], segs2[0], true, startScale);
     for (let i = 0; i + 1 < segs2.length; i++) {
       const s = segs2[i];
       const t = segs2[i + 1];
@@ -29466,7 +29506,7 @@ var Outliner = class {
         this.join(P[i + 1], s, t, "R", tr < 0);
       }
     }
-    this.cap(P[P.length - 1], segs2[segs2.length - 1], false);
+    this.cap(P[P.length - 1], segs2[segs2.length - 1], false, endScale);
     for (let i = segs2.length - 1; i > 0; i--) {
       const s = segs2[i];
       const t = segs2[i - 1];
@@ -29522,7 +29562,7 @@ var Outliner = class {
     this.flush();
   }
 };
-function dashPieces(P, tangents, pattern, shorten) {
+function dashPieces(P, tangents, curveFlags, pattern, shorten, wholePixelVectors) {
   const out = [];
   const dashes = [];
   for (let i = 0; i < pattern.length; i += 2) {
@@ -29537,12 +29577,22 @@ function dashPieces(P, tangents, pattern, shorten) {
   let idx = 0;
   let left = dashes[0];
   let on = true;
-  let cur = { pts: [P[0]], dirs: [], draws: [] };
+  let cur = { pts: [P[0]], dirs: [], draws: [], curves: [], startScale: 1, endScale: 1 };
   for (let i = 0; i + 1 < P.length; i++) {
     const [x0, y0] = P[i];
     const [x1, y1] = P[i + 1];
     const dir = [x1 - x0, y1 - y0];
-    const len = Math.hypot(dir[0], dir[1]);
+    const real = Math.hypot(dir[0], dir[1]);
+    const len = wholePixelVectors ? Math.hypot(Math.floor(dir[0] / 16), Math.floor(dir[1] / 16)) * 16 : Math.hypot(dir[0], dir[1]);
+    if (len === 0) {
+      if (on && cur) {
+        cur.pts.push(P[i + 1]);
+        cur.dirs.push(dir);
+        cur.draws.push(tangents[i]);
+        cur.curves.push(curveFlags[i]);
+      }
+      continue;
+    }
     let t = 0;
     while (len - t > left || left === 0 && on) {
       t += left;
@@ -29551,10 +29601,12 @@ function dashPieces(P, tangents, pattern, shorten) {
         cur.pts.push(q);
         cur.dirs.push(dir);
         cur.draws.push(tangents[i]);
+        cur.curves.push(curveFlags[i]);
+        cur.endScale = cur.pts[0] === P[0] && q[0] === P[0][0] && q[1] === P[0][1] ? 1 : real / len;
         out.push(cur);
         cur = null;
       } else {
-        cur = { pts: [q], dirs: [], draws: [] };
+        cur = { pts: [q], dirs: [], draws: [], curves: [], startScale: real / len, endScale: 1 };
       }
       on = !on;
       idx = (idx + 1) % dashes.length;
@@ -29565,9 +29617,12 @@ function dashPieces(P, tangents, pattern, shorten) {
       cur.pts.push(P[i + 1]);
       cur.dirs.push(dir);
       cur.draws.push(tangents[i]);
+      cur.curves.push(curveFlags[i]);
+      cur.endScale = real / len;
     }
   }
   if (on && cur && cur.dirs.length > 0) {
+    cur.endScale = 1;
     out.push(cur);
   }
   return out;
@@ -29602,10 +29657,13 @@ function widenPath(path, opts) {
     if (dashed) {
       const run = closed ? [...P, P[0]] : P;
       const shorten = opts.cap === "flat" || opts.shortenDashes === false ? 0 : opts.width;
-      for (const piece of dashPieces(run, closed ? [...dirs, void 0] : dirs, opts.dashes, shorten)) {
+      const runTangents = closed ? [...dirs, void 0] : dirs;
+      const runCurves = closed ? [...curves, !!fig.roundWiden] : curves;
+      for (const piece of dashPieces(run, runTangents, runCurves, opts.dashes, shorten, !!opts.wholePixelDashVectors)) {
         const pts = [piece.pts[0]];
         const pdirs = [];
         const pdraws = [];
+        const pcurves = [];
         for (let i = 1; i < piece.pts.length; i++) {
           const q = piece.pts[i];
           const last = pts[pts.length - 1];
@@ -29613,9 +29671,10 @@ function widenPath(path, opts) {
             pts.push(q);
             pdirs.push(piece.dirs[i - 1]);
             pdraws.push(piece.draws[i - 1]);
+            pcurves.push(piece.curves[i - 1]);
           }
         }
-        outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pts.map(() => !!fig.roundWiden));
+        outliner.open(pts, pdirs.length > 0 ? pdirs : [piece.dirs[0]], pdirs.length > 0 ? pdraws : [piece.draws[0]], pdirs.length > 0 ? pcurves : [piece.curves[0]], piece.startScale, piece.endScale);
       }
     } else if (closed && P.length >= 3) {
       outliner.closed(P, dirs, curves);
@@ -29823,7 +29882,10 @@ function penWidenOptions(rCtx, opts = {}) {
     join: opts.roundPen ? "round" : opts.rectangle && !state.penExtended ? "miter" : !state.penExtended || joinBits === 0 ? "round" : joinBits === 4096 ? "bevel" : "miter",
     miterLimit: state.miterLimit ?? 10,
     dashes: dashes ? dashes.map((v) => v * 16) : null,
-    shortenDashes: (flags & 15) !== 7
+    shortenDashes: (flags & 15) !== 7,
+    // One logical unit per device pixel, unrotated: GDI measures dash
+    // segments in whole pixels.
+    wholePixelDashVectors: Math.abs(matrix[0] - 1) < 1e-6 && Math.abs(matrix[3] - 1) < 1e-6 && Math.abs(matrix[1]) < 1e-6 && Math.abs(matrix[2]) < 1e-6
   };
 }
 function hatchBackgroundMask(hatch) {