emf-converter 4.8.0 → 4.8.2

package/dist/index.js

@@ -16404,8 +16404,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;
@@ -16422,6 +16422,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);
@@ -16454,14 +16471,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) {
@@ -16484,29 +16493,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],
@@ -16521,28 +16531,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) {
@@ -20542,8 +20564,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) {
@@ -23356,6 +23377,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) {
@@ -23369,9 +23405,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;
@@ -29190,9 +29229,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) {
@@ -29231,7 +29270,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]]);
@@ -29326,7 +29365,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;
@@ -29344,7 +29383,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 {
@@ -29440,7 +29480,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;
@@ -29451,12 +29491,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];
@@ -29467,7 +29507,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];
@@ -29523,7 +29563,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) {
@@ -29538,12 +29578,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;
@@ -29552,10 +29602,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;
@@ -29566,9 +29618,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;
@@ -29603,10 +29658,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];
@@ -29614,9 +29672,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);
@@ -29824,7 +29883,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) {