emf-converter 4.3.2 → 4.3.4

package/README.md

@@ -212,10 +212,10 @@ Everything below is verified against output painted by Windows itself; `src/gdi-
 
 ## Limitations
 
-Everything is measured against output painted by Windows itself; `src/gdi-parity.fixture.test.ts` holds the exact per-fixture bounds.
+Everything is measured against output painted by Windows itself; `src/gdi-parity.fixture.test.ts` holds the exact per-fixture bounds. Open work items are tracked in [docs/outstanding-work.md](docs/outstanding-work.md).
 
-- **Colour adjustment and image effects**: The `HALFTONE` stretch mode resamples with an area-averaging box filter. Integer enlargements match Windows exactly; reductions do not, because Windows' halftone engine uses a narrower kernel and its own colour mapping (1.05% of pixels differ on the fixture). `EMR_SETCOLORADJUSTMENT` is applied to the source of `HALFTONE` `StretchBlt` and `StretchDIBits` calls, as in GDI. Windows does not publish its adjustment formulas, so gamma, reference black/white, contrast, brightness, colourfulness, red-green tint, negative and log filter use documented approximations, and Windows' dithering of the adjusted colours is not reproduced (6.6% of pixels differ by more than 24 on the fixture). The illuminant is ignored. EMF+ image effects (`SerializableObject`) are applied to the image's pixels before it is drawn. Colour matrix and lookup table effects follow GDI+'s definitions; MS-EMFPLUS does not specify the algorithms of the others (blur, sharpen, brightness/contrast, levels, colour balance, colour curves, hue/saturation/lightness, tint, red-eye), so those use documented approximations and have not been checked against GDI+ output. An effect is applied to the draw's source rectangle only, and a blur with `expandEdge` grows it by the blur radius, as GDI+ does. When the source rectangle is not in pixels, the effect is applied to the whole image without that growth. An effect is skipped when the image cannot be decoded to pixels: PNG and BMP always can be, while JPEG, GIF, TIFF and similar formats need a canvas backend (a browser or `@napi-rs/canvas`).
-- **Pen transforms**: nonuniform and skewed EMF+ pen transforms are drawn with the transformed (elliptical or sheared) nib, but unlike uniform ones they are not yet verified against Windows output, and a singular pen transform is ignored.
+- **Colour adjustment and image effects**: The `HALFTONE` stretch mode reproduces Windows' halftone engine for 32-bit output: an enlargement smooths isolated pixels and then takes the nearest source pixel, and a reduction averages each pixel's footprint and then sharpens. All seven plain `HALFTONE` fixtures (2x, 3x, 0.5x, 0.65x and 1.37x) match exactly. It is not verified for a stretch that enlarges one axis and reduces the other. `EMR_SETCOLORADJUSTMENT` is applied to the source of `HALFTONE` `StretchBlt` and `StretchDIBits` calls, as in GDI. Windows does not publish its adjustment formulas. The converter uses a model fitted to two Windows captures: contrast and brightness on CIE L*, colourfulness and red-green tint on u'v' chromaticity, with gamma as the source encoding, so a gamma on its own changes nothing. Windows also dithers the adjusted colours over 32 levels per channel, and that pattern is not reproduced. On the fixtures, 0% to 15.1% of pixels differ by more than 24. The log filter uses an unverified curve, and the illuminant is ignored. EMF+ image effects (`SerializableObject`) are applied to the image's pixels before it is drawn. Colour matrix and lookup table effects follow GDI+'s definitions; MS-EMFPLUS does not specify the algorithms of the others (blur, sharpen, brightness/contrast, levels, colour balance, colour curves, hue/saturation/lightness, tint, red-eye), so those use documented approximations and have not been checked against GDI+ output. An effect is applied to the draw's source rectangle only, and a blur with `expandEdge` grows it by the blur radius, as GDI+ does. When the source rectangle is not in pixels, the effect is applied to the whole image without that growth. An effect is skipped when the image cannot be decoded to pixels: PNG and BMP always can be, while JPEG, GIF, TIFF and similar formats need a canvas backend (a browser or `@napi-rs/canvas`).
+- **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. The fixtures include dashes only under a non-uniform scale. Dashes under a uniform scale follow the same rule but have not been checked. A pen transform that cannot be inverted is ignored. Of the anchor caps, only `ArrowAnchor` is drawn with its real shape. The others are drawn as their base cap.
 - **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; unsupported encodings (including Johab and OEM on standard runtimes) fall back to Windows-1252. Vertical `ETO_PDY` advances require 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.
 - **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.

package/dist/index.js

@@ -12702,7 +12702,10 @@ function dashFigure(pts, closed, pen) {
   for (let i = 0; i + 1 < path.length; i++) {
     const a = path[i];
     const b = path[i + 1];
-    let segLen = Math.hypot(b.x - a.x, b.y - a.y);
+    const m = pen.dashMetric;
+    const vx = b.x - a.x;
+    const vy = b.y - a.y;
+    let segLen = m ? Math.hypot(m[0] * vx + m[2] * vy, m[1] * vx + m[3] * vy) : Math.hypot(vx, vy);
     let t0 = 0;
     while (segLen - t0 > remaining + 1e-9) {
       t0 += remaining;
@@ -12730,6 +12733,26 @@ function dashFigure(pts, closed, pen) {
   }
   return out.filter((d) => d.pts.length > 1);
 }
+var ARROW_ANCHOR = 20;
+function arrowAnchor(pp, atEnd, half) {
+  const w = 2 * half;
+  const tip = atEnd ? pp[pp.length - 1] : pp[0];
+  const next = atEnd ? pp[pp.length - 2] : pp[1];
+  const len = Math.hypot(next.x - tip.x, next.y - tip.y);
+  const ux = (next.x - tip.x) / len;
+  const uy = (next.y - tip.y) / len;
+  const depth = 2 * w;
+  const across = 2 * w / Math.sqrt(3);
+  const base = { x: tip.x + ux * depth, y: tip.y + uy * depth };
+  if (len > depth) {
+    if (atEnd) {
+      pp[pp.length - 1] = base;
+    } else {
+      pp[0] = base;
+    }
+  }
+  return [tip, { x: base.x - uy * across, y: base.y + ux * across }, { x: base.x + uy * across, y: base.y - ux * across }];
+}
 var MIN_DASH = 1 / 256;
 function signedArea(pts) {
   let a = 0;
@@ -12780,6 +12803,19 @@ function widenFigures(figures, pen) {
       if (pp.length < 2) {
         continue;
       }
+      const arrows = [];
+      let startCapOverride = null;
+      let endCapOverride = null;
+      if (!pieceClosed && !(pen.dash && closed)) {
+        if (piece.first && pen.startCap === ARROW_ANCHOR) {
+          arrows.push(arrowAnchor(pp, false, h));
+          startCapOverride = 0;
+        }
+        if (piece.last && pen.endCap === ARROW_ANCHOR) {
+          arrows.push(arrowAnchor(pp, true, h));
+          endCapOverride = 0;
+        }
+      }
       for (const [o1, o2] of bands) {
         if (pieceClosed) {
           polys.push(sidePoints(pp, true, o2, pen));
@@ -12790,11 +12826,16 @@ function widenFigures(figures, pen) {
         const right = sidePoints(pp, false, o1, pen).reverse();
         const fEnd = frame(pp[pp.length - 2], pp[pp.length - 1]);
         const f0 = frame(pp[1], pp[0]);
-        const endCap = piece.last && !(pen.dash && closed) ? pen.endCap : pen.dashCap;
-        const startCap = piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap;
+        const endCap = endCapOverride ?? (piece.last && !(pen.dash && closed) ? pen.endCap : pen.dashCap);
+        const startCap = startCapOverride ?? (piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap);
         const capEnd = capPoints(pp[pp.length - 1], fEnd, o1, o2, endCap, h);
         const capStart = capPoints(pp[0], f0, -o2, -o1, startCap, h);
-        polys.push([...left.slice(0, -1), ...capEnd, ...right.slice(1, -1), ...capStart]);
+        const poly = [...left.slice(0, -1), ...capEnd, ...right.slice(1, -1), ...capStart];
+        polys.push(poly);
+        const sign = Math.sign(signedArea(poly));
+        for (const arrow of arrows) {
+          polys.push(Math.sign(signedArea(arrow)) === sign ? arrow : arrow.slice().reverse());
+        }
       }
     }
   }
@@ -20085,50 +20126,111 @@ function readColorAdjustment(view, off) {
 function isIdentityColorAdjustment(ca) {
   return !ca || ca.flags === 0 && ca.redGamma === 1e4 && ca.greenGamma === 1e4 && ca.blueGamma === 1e4 && ca.referenceBlack === 0 && ca.referenceWhite === 1e4 && ca.contrast === 0 && ca.brightness === 0 && ca.colorfulness === 0 && ca.redGreenTint === 0;
 }
-function colorfulnessScale(c) {
-  return c > 0 ? 1 + 2 * c / 100 : 1 + c / 100;
+var CONTRAST_GAIN = 1.88;
+var BRIGHTNESS_GAIN = 78.5;
+var COLORFULNESS_GAIN = 1.335;
+var TINT_RADIANS = -1.135;
+var RGB_TO_XYZ = [
+  [0.4124, 0.3576, 0.1805],
+  [0.2126, 0.7152, 0.0722],
+  [0.0193, 0.1192, 0.9505]
+];
+var XYZ_TO_RGB = invert3(RGB_TO_XYZ);
+var WHITE = RGB_TO_XYZ.map((row) => row[0] + row[1] + row[2]);
+var WHITE_D = WHITE[0] + 15 * WHITE[1] + 3 * WHITE[2];
+var WHITE_U = 4 * WHITE[0] / WHITE_D;
+var WHITE_V = 9 * WHITE[1] / WHITE_D;
+function invert3(m) {
+  const [[a, b, c], [d, e, f], [g, h, i]] = m;
+  const A = e * i - f * h;
+  const B = f * g - d * i;
+  const C = d * h - e * g;
+  const det = a * A + b * B + c * C;
+  return [
+    [A / det, (c * h - b * i) / det, (b * f - c * e) / det],
+    [B / det, (a * i - c * g) / det, (c * d - a * f) / det],
+    [C / det, (b * g - a * h) / det, (a * e - b * d) / det]
+  ];
+}
+function lightness(t) {
+  return t > 8856e-6 ? 116 * Math.cbrt(t) - 16 : 903.3 * t;
+}
+function fromLightness(l) {
+  return l > 8 ? ((l + 16) / 116) ** 3 : l / 903.3;
 }
 var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 function colorAdjustmentMapper(ca) {
   const black = ca.referenceBlack / 1e4;
   const span = Math.max(1e-6, ca.referenceWhite / 1e4 - black);
   const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
-  const curves = gammas.map((gamma) => {
+  const negative = (ca.flags & CA_NEGATIVE) !== 0;
+  const linear = gammas.map((gamma) => {
     const table = new Float64Array(256);
     for (let i = 0; i < 256; i++) {
-      let v = clamp012((i / 255 - black) / span);
-      v = Math.pow(v, gamma);
-      table[i] = ca.flags & CA_NEGATIVE ? 1 - v : v;
+      const v = negative ? 1 - i / 255 : i / 255;
+      table[i] = clamp012((v - black) / span) ** gamma;
     }
     return table;
   });
-  const chroma = colorfulnessScale(ca.colorfulness);
-  const contrast = 1 + ca.contrast / 100;
-  const brightness = 0.8 * ca.brightness / 100;
-  const tint = 0.3 * ca.redGreenTint / 100;
+  const chroma = ca.colorfulness < 0 ? 1 + ca.colorfulness / 100 : 1 + COLORFULNESS_GAIN * ca.colorfulness / 100;
+  const angle = TINT_RADIANS * ca.redGreenTint / 100;
+  const cos = Math.cos(angle) * chroma;
+  const sin = Math.sin(angle) * chroma;
+  const slope = Math.exp(CONTRAST_GAIN * ca.contrast / 100);
+  const offset = 50 - 50 * slope + BRIGHTNESS_GAIN * ca.brightness / 100;
   const log = (ca.flags & CA_LOG_FILTER) !== 0;
-  const out = (v) => {
-    v = clamp012(v);
+  const colour = ca.colorfulness !== 0 || ca.redGreenTint !== 0;
+  const out = (v, c) => {
+    v = clamp012(fromLightness(slope * lightness(clamp012(v)) + offset)) ** (1 / gammas[c]);
     if (log) {
       v = Math.log10(1 + 9 * v);
     }
     return Math.round(v * 255);
   };
   return (rgb2) => {
-    const r = curves[0][rgb2 >> 16 & 255];
-    const g = curves[1][rgb2 >> 8 & 255];
-    const b = curves[2][rgb2 & 255];
-    let y = 0.299 * r + 0.587 * g + 0.114 * b;
-    let cr = (r - y) * chroma;
-    const cb = (b - y) * chroma;
-    y = (y - 0.5) * contrast + 0.5 + brightness;
-    cr += tint;
-    const r2 = y + cr;
-    const b2 = y + cb;
-    const g2 = (y - 0.299 * r2 - 0.114 * b2) / 0.587;
-    return out(r2) << 16 | out(g2) << 8 | out(b2);
+    let r = linear[0][rgb2 >> 16 & 255];
+    let g = linear[1][rgb2 >> 8 & 255];
+    let b = linear[2][rgb2 & 255];
+    if (colour) {
+      const x = RGB_TO_XYZ[0][0] * r + RGB_TO_XYZ[0][1] * g + RGB_TO_XYZ[0][2] * b;
+      const y = RGB_TO_XYZ[1][0] * r + RGB_TO_XYZ[1][1] * g + RGB_TO_XYZ[1][2] * b;
+      const z = RGB_TO_XYZ[2][0] * r + RGB_TO_XYZ[2][1] * g + RGB_TO_XYZ[2][2] * b;
+      const d = x + 15 * y + 3 * z;
+      if (d > 1e-12 && y > 1e-12) {
+        const du = 4 * x / d - WHITE_U;
+        const dv = 9 * y / d - WHITE_V;
+        const u = WHITE_U + du * cos - dv * sin;
+        const v = Math.max(1e-6, WHITE_V + du * sin + dv * cos);
+        const x2 = y * 9 * u / (4 * v);
+        const z2 = y * (12 - 3 * u - 20 * v) / (4 * v);
+        r = XYZ_TO_RGB[0][0] * x2 + XYZ_TO_RGB[0][1] * y + XYZ_TO_RGB[0][2] * z2;
+        g = XYZ_TO_RGB[1][0] * x2 + XYZ_TO_RGB[1][1] * y + XYZ_TO_RGB[1][2] * z2;
+        b = XYZ_TO_RGB[2][0] * x2 + XYZ_TO_RGB[2][1] * y + XYZ_TO_RGB[2][2] * z2;
+      }
+    }
+    return out(r, 0) << 16 | out(g, 1) << 8 | out(b, 2);
   };
 }
+function colorAdjustRgb(rgbs, ca) {
+  if (!ca || isIdentityColorAdjustment(ca)) {
+    return;
+  }
+  const map = colorAdjustmentMapper(ca);
+  const cache = /* @__PURE__ */ new Map();
+  for (let i = 0; i + 2 < rgbs.length; i += 3) {
+    const rgb2 = rgbs[i] << 16 | rgbs[i + 1] << 8 | rgbs[i + 2];
+    let v = cache.get(rgb2);
+    if (v === void 0) {
+      v = map(rgb2);
+      if (cache.size < 65536) {
+        cache.set(rgb2, v);
+      }
+    }
+    rgbs[i] = v >> 16 & 255;
+    rgbs[i + 1] = v >> 8 & 255;
+    rgbs[i + 2] = v & 255;
+  }
+}
 function applyColorAdjustment(pixels, ca) {
   if (!ca || isIdentityColorAdjustment(ca)) {
     return;
@@ -20223,64 +20325,160 @@ function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
   }
   return { width: W, height: H, data };
 }
-function axisBoxWeights(srcStart, srcLen, dstLen, reverse) {
-  const out = [];
+var FIX = 65536;
+function halftoneNearest(i, srcLen, dstLen) {
+  const num = (2 * i + 1) * srcLen;
+  const den = 2 * dstLen;
+  let k = Math.floor(num / den);
+  if (k * den === num) {
+    k--;
+  }
+  return Math.max(0, Math.min(srcLen - 1, k));
+}
+function halftoneAxis(start, srcLen, dstLen, reverse) {
+  const taps = [];
   if (dstLen <= 0 || srcLen <= 0) {
-    return out;
+    return taps;
   }
-  const at = (k) => reverse ? srcStart + srcLen - 1 - k : srcStart + k;
+  const at = (k) => reverse ? start + srcLen - 1 - k : start + k;
+  if (dstLen >= srcLen) {
+    for (let i = 0; i < dstLen; i++) {
+      taps.push([[at(halftoneNearest(i, srcLen, dstLen)), 1]]);
+    }
+    return taps;
+  }
+  const step = Math.ceil(srcLen * FIX / dstLen);
   for (let i = 0; i < dstLen; i++) {
-    const a = i * srcLen;
-    const b = (i + 1) * srcLen;
-    const taps = [];
-    for (let k = Math.floor(a / dstLen); k * dstLen < b; k++) {
-      const overlap = Math.min(b, (k + 1) * dstLen) - Math.max(a, k * dstLen);
+    const a = i * step;
+    const b = (i + 1) * step;
+    const run = [];
+    for (let k = Math.floor(a / FIX); k * FIX < b && k < srcLen; k++) {
+      const overlap = Math.min(b, (k + 1) * FIX) - Math.max(a, k * FIX);
       if (overlap > 0) {
-        taps.push([at(k), overlap / srcLen]);
+        run.push([at(k), overlap]);
+      }
+    }
+    taps.push(run);
+  }
+  return taps;
+}
+var SPECKLE_OVERSHOOT = 4;
+function halftoneDespeckle(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(y * w + x) * 3 + c];
+  const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  for (let y = 0; y < h; y++) {
+    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
+    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
+    for (let x = 0; x < w; x++) {
+      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
+      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
+      let hClip = 0;
+      let vClip = 0;
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+          hClip++;
+        }
+        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+          vClip++;
+        }
+      }
+      if (hClip < 2 || vClip < 2) {
+        continue;
+      }
+      for (let c = 0; c < 3; c++) {
+        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+      }
+    }
+  }
+}
+function halftoneSharpen(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(Math.max(0, Math.min(h - 1, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
+        const out = v + Math.floor((4 * v - sum) / 8);
+        px[(y * w + x) * 3 + c] = out < 0 ? 0 : out > 255 ? 255 : out;
       }
     }
-    out.push(taps);
   }
-  return out;
 }
-function stretchHalftone(src, sx, sy, sw, sh, dw, dh) {
+function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust) {
   const W = Math.max(0, Math.round(Math.abs(dw)));
   const H = Math.max(0, Math.round(Math.abs(dh)));
+  const SW = Math.round(Math.abs(sw));
+  const SH = Math.round(Math.abs(sh));
+  const x0 = Math.round(Math.min(sx, sx + sw));
+  const y0 = Math.round(Math.min(sy, sy + sh));
   const flipX = dw < 0 !== sw < 0;
   const flipY = dh < 0 !== sh < 0;
-  const cols = axisBoxWeights(Math.round(Math.min(sx, sx + sw)), Math.round(Math.abs(sw)), W, flipX);
-  const rows = axisBoxWeights(Math.round(Math.min(sy, sy + sh)), Math.round(Math.abs(sh)), H, flipY);
   const data = new Uint8ClampedArray(W * H * 4);
-  const s = src.data;
+  if (W === 0 || H === 0 || SW === 0 || SH === 0) {
+    return { width: W, height: H, data };
+  }
+  const rect = new Int32Array(SW * SH * 3);
+  for (let y = 0; y < SH; y++) {
+    const yy = y0 + y;
+    for (let x = 0; x < SW; x++) {
+      const xx = x0 + x;
+      if (yy < 0 || yy >= src.height || xx < 0 || xx >= src.width) {
+        continue;
+      }
+      const i = (yy * src.width + xx) * 4;
+      const o = (y * SW + x) * 3;
+      rect[o] = src.data[i];
+      rect[o + 1] = src.data[i + 1];
+      rect[o + 2] = src.data[i + 2];
+    }
+  }
+  const enlarging = W >= SW && H >= SH && (W > SW || H > SH);
+  const reducing = W < SW && H < SH;
+  if (enlarging) {
+    halftoneDespeckle(rect, SW, SH);
+  }
+  if (adjust) {
+    adjust(rect);
+  }
+  const cols = halftoneAxis(0, SW, W, flipX);
+  const rows = halftoneAxis(0, SH, H, flipY);
+  const out = new Int32Array(W * H * 3);
   for (let y = 0; y < H; y++) {
-    const ys = rows[y] ?? [];
+    const ys = rows[y];
     for (let x = 0; x < W; x++) {
-      const xs = cols[x] ?? [];
+      const xs = cols[x];
       let r = 0;
       let g = 0;
       let b = 0;
+      let total = 0;
       for (const [yy, wy] of ys) {
-        if (yy < 0 || yy >= src.height) {
-          continue;
-        }
         for (const [xx, wx] of xs) {
-          if (xx < 0 || xx >= src.width) {
-            continue;
-          }
           const w = wx * wy;
-          const i = (yy * src.width + xx) * 4;
-          r += s[i] * w;
-          g += s[i + 1] * w;
-          b += s[i + 2] * w;
+          total += w;
+          const i = (yy * SW + xx) * 3;
+          r += rect[i] * w;
+          g += rect[i + 1] * w;
+          b += rect[i + 2] * w;
         }
       }
-      const o = (y * W + x) * 4;
-      data[o] = Math.floor(r + 1e-6);
-      data[o + 1] = Math.floor(g + 1e-6);
-      data[o + 2] = Math.floor(b + 1e-6);
-      data[o + 3] = 255;
+      const o = (y * W + x) * 3;
+      out[o] = Math.floor((2 * r + total) / (2 * total));
+      out[o + 1] = Math.floor((2 * g + total) / (2 * total));
+      out[o + 2] = Math.floor((2 * b + total) / (2 * total));
     }
   }
+  if (reducing) {
+    halftoneSharpen(out, W, H);
+  }
+  for (let i = 0, o = 0; i < W * H; i++, o += 3) {
+    data[i * 4] = out[o];
+    data[i * 4 + 1] = out[o + 1];
+    data[i * 4 + 2] = out[o + 2];
+    data[i * 4 + 3] = 255;
+  }
   return { width: W, height: H, data };
 }
 
@@ -20306,7 +20504,7 @@ function patternOperand(rCtx, brush) {
 function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode) {
   const dLeft = Math.min(req.dx, req.dx + req.dw) - offsetX;
   const dTop = Math.min(req.dy, req.dy + req.dh) - offsetY;
-  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
+  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, decoded.adjust) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
   if (px.width === 0 || px.height === 0) {
     return;
   }
@@ -20334,15 +20532,14 @@ function decodeSource(rCtx, req) {
   if (!image) {
     return null;
   }
-  if (req.stretch && rCtx.state.stretchBltMode === HALFTONE) {
-    applyColorAdjustment(image, rCtx.state.colorAdjustment);
-  }
+  const ca = rCtx.state.colorAdjustment;
+  const adjust = req.stretch && rCtx.state.stretchBltMode === HALFTONE && ca ? (rgb2) => colorAdjustRgb(rgb2, ca) : void 0;
   let { sy } = req;
   if (req.dibOrigin === "bottom-left" && rCtx.view.getInt32(req.source.bmi + 8, true) > 0) {
     sy = image.height - sy - req.sh;
   }
   return {
-    decoded: { pixels: image },
+    decoded: { pixels: image, adjust },
     req: { ...req, sy }
   };
 }
@@ -20498,6 +20695,9 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
       return;
     }
     src = decoded.decoded.pixels;
+    if (decoded.decoded.adjust) {
+      applyColorAdjustment(src, rCtx.state.colorAdjustment);
+    }
     srcX = decoded.req.sx;
     srcY = decoded.req.sy;
   }
@@ -23965,12 +24165,12 @@ function hslToRgb(h, s, l) {
   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];
 }
-function applyHueSaturationLightness(src, hue, saturation, lightness) {
+function applyHueSaturationLightness(src, hue, saturation, lightness2) {
   const out = new Uint8ClampedArray(src);
   const push = (v, t) => t >= 0 ? v + (1 - v) * (t / 100) : v * (1 + t / 100);
   for (let i = 0; i < src.length; i += 4) {
     const [h, s, l] = rgbToHsl(src[i] / 255, src[i + 1] / 255, src[i + 2] / 255);
-    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness));
+    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness2));
     out[i] = Math.round(r * 255);
     out[i + 1] = Math.round(g * 255);
     out[i + 2] = Math.round(b * 255);
@@ -24661,6 +24861,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
     }
   };
   if (pen) {
+    const nibDashed = !!nib && penDashArray(pen).length > 0;
     applyPlusPenStyle(ctx, pen, widthScale);
     const mode = plusRasterMode(rCtx);
     let sampler = pen.brush && !isSvgContext(ctx) ? brushSampler(rCtx, pen.brush) : null;
@@ -24675,7 +24876,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       if (mode !== "canvas" && size && strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, closedFigure)) {
         return;
       }
-      const outline = hasCustomCap(pen) ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
+      const outline = hasCustomCap(pen) || nibDashed ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
       let box = null;
       if (size && outline) {
         box = deviceBounds(outline.flat(), device, size, 2);
@@ -24705,7 +24906,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       }
     }
     const paint = pen.brush ? brushPaint2(rCtx, pen.brush) : pen.color;
-    if ((hasCustomCap(pen) || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
+    if ((hasCustomCap(pen) || nibDashed || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
       return;
     }
     ctx.strokeStyle = paint;
@@ -24727,7 +24928,9 @@ function resolvePenTransform(pen) {
     return { pen: { ...plain, width: pen.width === 0 ? 1 : pen.width }, nib: null };
   }
   if (Math.abs(sx - sy) <= 1e-6 * sx && Math.abs(dot) <= 1e-6 * sx * sy) {
-    return { pen: { ...plain, width: pen.width * sx }, nib: null };
+    const pattern = pen.dashStyle === 5 ? pen.dashPattern : DASH_PATTERNS[pen.dashStyle];
+    const dashed = pattern && pattern.length > 0 ? { dashStyle: 5, dashPattern: pattern.map((v) => v / sx), dashOffset: (pen.dashOffset ?? 0) / sx } : {};
+    return { pen: { ...plain, ...dashed, width: pen.width * sx }, nib: null };
   }
   return { pen: plain, nib: [a, b, c, d, 0, 0] };
 }
@@ -24752,7 +24955,7 @@ function penFrame(device, nib) {
     toDevice: mulMatrix(full, [1 / unit, 0, 0, 1 / unit, 0, 0])
   };
 }
-function framePen(pen, unit) {
+function framePen(pen, unit, nib = null) {
   const dash = penDashArray(pen).map((v) => v * unit);
   return {
     half: (pen.width || 1) * unit / 2,
@@ -24763,6 +24966,7 @@ function framePen(pen, unit) {
     dashCap: pen.dashCap ?? 0,
     dash: dash.length > 0 ? dash : null,
     dashOffset: (pen.dashOffset ?? 0) * (pen.width || 1) * unit,
+    dashMetric: nib ? [nib[0], nib[1], nib[2], nib[3]] : void 0,
     compound: pen.compound ?? null,
     inset: pen.alignment === 1
   };
@@ -24790,7 +24994,7 @@ function strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, c
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
   const width = (pen.width || 1) * frame2.unit;
-  const devicePen = framePen(pen, frame2.unit);
+  const devicePen = framePen(pen, frame2.unit, nib);
   const antialias = mode === "gdiplus-aa";
   const toFix = (poly) => {
     const m = frame2.toDevice;
@@ -24882,7 +25086,7 @@ function penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) {
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
   const width = (pen.width || 1) * frame2.unit;
-  const devicePen = framePen(pen, frame2.unit);
+  const devicePen = framePen(pen, frame2.unit, nib);
   const outline = hasCustomCap(pen) ? customCapOutline(figures, width, devicePen, pen) : widenFigures(figures, devicePen);
   const m = mulMatrix(deviceInv, frame2.toDevice);
   return outline.map((poly) => poly.map((p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] })));

package/dist/index.mjs

@@ -12700,7 +12700,10 @@ function dashFigure(pts, closed, pen) {
   for (let i = 0; i + 1 < path.length; i++) {
     const a = path[i];
     const b = path[i + 1];
-    let segLen = Math.hypot(b.x - a.x, b.y - a.y);
+    const m = pen.dashMetric;
+    const vx = b.x - a.x;
+    const vy = b.y - a.y;
+    let segLen = m ? Math.hypot(m[0] * vx + m[2] * vy, m[1] * vx + m[3] * vy) : Math.hypot(vx, vy);
     let t0 = 0;
     while (segLen - t0 > remaining + 1e-9) {
       t0 += remaining;
@@ -12728,6 +12731,26 @@ function dashFigure(pts, closed, pen) {
   }
   return out.filter((d) => d.pts.length > 1);
 }
+var ARROW_ANCHOR = 20;
+function arrowAnchor(pp, atEnd, half) {
+  const w = 2 * half;
+  const tip = atEnd ? pp[pp.length - 1] : pp[0];
+  const next = atEnd ? pp[pp.length - 2] : pp[1];
+  const len = Math.hypot(next.x - tip.x, next.y - tip.y);
+  const ux = (next.x - tip.x) / len;
+  const uy = (next.y - tip.y) / len;
+  const depth = 2 * w;
+  const across = 2 * w / Math.sqrt(3);
+  const base = { x: tip.x + ux * depth, y: tip.y + uy * depth };
+  if (len > depth) {
+    if (atEnd) {
+      pp[pp.length - 1] = base;
+    } else {
+      pp[0] = base;
+    }
+  }
+  return [tip, { x: base.x - uy * across, y: base.y + ux * across }, { x: base.x + uy * across, y: base.y - ux * across }];
+}
 var MIN_DASH = 1 / 256;
 function signedArea(pts) {
   let a = 0;
@@ -12778,6 +12801,19 @@ function widenFigures(figures, pen) {
       if (pp.length < 2) {
         continue;
       }
+      const arrows = [];
+      let startCapOverride = null;
+      let endCapOverride = null;
+      if (!pieceClosed && !(pen.dash && closed)) {
+        if (piece.first && pen.startCap === ARROW_ANCHOR) {
+          arrows.push(arrowAnchor(pp, false, h));
+          startCapOverride = 0;
+        }
+        if (piece.last && pen.endCap === ARROW_ANCHOR) {
+          arrows.push(arrowAnchor(pp, true, h));
+          endCapOverride = 0;
+        }
+      }
       for (const [o1, o2] of bands) {
         if (pieceClosed) {
           polys.push(sidePoints(pp, true, o2, pen));
@@ -12788,11 +12824,16 @@ function widenFigures(figures, pen) {
         const right = sidePoints(pp, false, o1, pen).reverse();
         const fEnd = frame(pp[pp.length - 2], pp[pp.length - 1]);
         const f0 = frame(pp[1], pp[0]);
-        const endCap = piece.last && !(pen.dash && closed) ? pen.endCap : pen.dashCap;
-        const startCap = piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap;
+        const endCap = endCapOverride ?? (piece.last && !(pen.dash && closed) ? pen.endCap : pen.dashCap);
+        const startCap = startCapOverride ?? (piece.first && !(pen.dash && closed) ? pen.startCap : pen.dashCap);
         const capEnd = capPoints(pp[pp.length - 1], fEnd, o1, o2, endCap, h);
         const capStart = capPoints(pp[0], f0, -o2, -o1, startCap, h);
-        polys.push([...left.slice(0, -1), ...capEnd, ...right.slice(1, -1), ...capStart]);
+        const poly = [...left.slice(0, -1), ...capEnd, ...right.slice(1, -1), ...capStart];
+        polys.push(poly);
+        const sign = Math.sign(signedArea(poly));
+        for (const arrow of arrows) {
+          polys.push(Math.sign(signedArea(arrow)) === sign ? arrow : arrow.slice().reverse());
+        }
       }
     }
   }
@@ -20083,50 +20124,111 @@ function readColorAdjustment(view, off) {
 function isIdentityColorAdjustment(ca) {
   return !ca || ca.flags === 0 && ca.redGamma === 1e4 && ca.greenGamma === 1e4 && ca.blueGamma === 1e4 && ca.referenceBlack === 0 && ca.referenceWhite === 1e4 && ca.contrast === 0 && ca.brightness === 0 && ca.colorfulness === 0 && ca.redGreenTint === 0;
 }
-function colorfulnessScale(c) {
-  return c > 0 ? 1 + 2 * c / 100 : 1 + c / 100;
+var CONTRAST_GAIN = 1.88;
+var BRIGHTNESS_GAIN = 78.5;
+var COLORFULNESS_GAIN = 1.335;
+var TINT_RADIANS = -1.135;
+var RGB_TO_XYZ = [
+  [0.4124, 0.3576, 0.1805],
+  [0.2126, 0.7152, 0.0722],
+  [0.0193, 0.1192, 0.9505]
+];
+var XYZ_TO_RGB = invert3(RGB_TO_XYZ);
+var WHITE = RGB_TO_XYZ.map((row) => row[0] + row[1] + row[2]);
+var WHITE_D = WHITE[0] + 15 * WHITE[1] + 3 * WHITE[2];
+var WHITE_U = 4 * WHITE[0] / WHITE_D;
+var WHITE_V = 9 * WHITE[1] / WHITE_D;
+function invert3(m) {
+  const [[a, b, c], [d, e, f], [g, h, i]] = m;
+  const A = e * i - f * h;
+  const B = f * g - d * i;
+  const C = d * h - e * g;
+  const det = a * A + b * B + c * C;
+  return [
+    [A / det, (c * h - b * i) / det, (b * f - c * e) / det],
+    [B / det, (a * i - c * g) / det, (c * d - a * f) / det],
+    [C / det, (b * g - a * h) / det, (a * e - b * d) / det]
+  ];
+}
+function lightness(t) {
+  return t > 8856e-6 ? 116 * Math.cbrt(t) - 16 : 903.3 * t;
+}
+function fromLightness(l) {
+  return l > 8 ? ((l + 16) / 116) ** 3 : l / 903.3;
 }
 var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
 function colorAdjustmentMapper(ca) {
   const black = ca.referenceBlack / 1e4;
   const span = Math.max(1e-6, ca.referenceWhite / 1e4 - black);
   const gammas = [ca.redGamma / 1e4, ca.greenGamma / 1e4, ca.blueGamma / 1e4];
-  const curves = gammas.map((gamma) => {
+  const negative = (ca.flags & CA_NEGATIVE) !== 0;
+  const linear = gammas.map((gamma) => {
     const table = new Float64Array(256);
     for (let i = 0; i < 256; i++) {
-      let v = clamp012((i / 255 - black) / span);
-      v = Math.pow(v, gamma);
-      table[i] = ca.flags & CA_NEGATIVE ? 1 - v : v;
+      const v = negative ? 1 - i / 255 : i / 255;
+      table[i] = clamp012((v - black) / span) ** gamma;
     }
     return table;
   });
-  const chroma = colorfulnessScale(ca.colorfulness);
-  const contrast = 1 + ca.contrast / 100;
-  const brightness = 0.8 * ca.brightness / 100;
-  const tint = 0.3 * ca.redGreenTint / 100;
+  const chroma = ca.colorfulness < 0 ? 1 + ca.colorfulness / 100 : 1 + COLORFULNESS_GAIN * ca.colorfulness / 100;
+  const angle = TINT_RADIANS * ca.redGreenTint / 100;
+  const cos = Math.cos(angle) * chroma;
+  const sin = Math.sin(angle) * chroma;
+  const slope = Math.exp(CONTRAST_GAIN * ca.contrast / 100);
+  const offset = 50 - 50 * slope + BRIGHTNESS_GAIN * ca.brightness / 100;
   const log = (ca.flags & CA_LOG_FILTER) !== 0;
-  const out = (v) => {
-    v = clamp012(v);
+  const colour = ca.colorfulness !== 0 || ca.redGreenTint !== 0;
+  const out = (v, c) => {
+    v = clamp012(fromLightness(slope * lightness(clamp012(v)) + offset)) ** (1 / gammas[c]);
     if (log) {
       v = Math.log10(1 + 9 * v);
     }
     return Math.round(v * 255);
   };
   return (rgb2) => {
-    const r = curves[0][rgb2 >> 16 & 255];
-    const g = curves[1][rgb2 >> 8 & 255];
-    const b = curves[2][rgb2 & 255];
-    let y = 0.299 * r + 0.587 * g + 0.114 * b;
-    let cr = (r - y) * chroma;
-    const cb = (b - y) * chroma;
-    y = (y - 0.5) * contrast + 0.5 + brightness;
-    cr += tint;
-    const r2 = y + cr;
-    const b2 = y + cb;
-    const g2 = (y - 0.299 * r2 - 0.114 * b2) / 0.587;
-    return out(r2) << 16 | out(g2) << 8 | out(b2);
+    let r = linear[0][rgb2 >> 16 & 255];
+    let g = linear[1][rgb2 >> 8 & 255];
+    let b = linear[2][rgb2 & 255];
+    if (colour) {
+      const x = RGB_TO_XYZ[0][0] * r + RGB_TO_XYZ[0][1] * g + RGB_TO_XYZ[0][2] * b;
+      const y = RGB_TO_XYZ[1][0] * r + RGB_TO_XYZ[1][1] * g + RGB_TO_XYZ[1][2] * b;
+      const z = RGB_TO_XYZ[2][0] * r + RGB_TO_XYZ[2][1] * g + RGB_TO_XYZ[2][2] * b;
+      const d = x + 15 * y + 3 * z;
+      if (d > 1e-12 && y > 1e-12) {
+        const du = 4 * x / d - WHITE_U;
+        const dv = 9 * y / d - WHITE_V;
+        const u = WHITE_U + du * cos - dv * sin;
+        const v = Math.max(1e-6, WHITE_V + du * sin + dv * cos);
+        const x2 = y * 9 * u / (4 * v);
+        const z2 = y * (12 - 3 * u - 20 * v) / (4 * v);
+        r = XYZ_TO_RGB[0][0] * x2 + XYZ_TO_RGB[0][1] * y + XYZ_TO_RGB[0][2] * z2;
+        g = XYZ_TO_RGB[1][0] * x2 + XYZ_TO_RGB[1][1] * y + XYZ_TO_RGB[1][2] * z2;
+        b = XYZ_TO_RGB[2][0] * x2 + XYZ_TO_RGB[2][1] * y + XYZ_TO_RGB[2][2] * z2;
+      }
+    }
+    return out(r, 0) << 16 | out(g, 1) << 8 | out(b, 2);
   };
 }
+function colorAdjustRgb(rgbs, ca) {
+  if (!ca || isIdentityColorAdjustment(ca)) {
+    return;
+  }
+  const map = colorAdjustmentMapper(ca);
+  const cache = /* @__PURE__ */ new Map();
+  for (let i = 0; i + 2 < rgbs.length; i += 3) {
+    const rgb2 = rgbs[i] << 16 | rgbs[i + 1] << 8 | rgbs[i + 2];
+    let v = cache.get(rgb2);
+    if (v === void 0) {
+      v = map(rgb2);
+      if (cache.size < 65536) {
+        cache.set(rgb2, v);
+      }
+    }
+    rgbs[i] = v >> 16 & 255;
+    rgbs[i + 1] = v >> 8 & 255;
+    rgbs[i + 2] = v & 255;
+  }
+}
 function applyColorAdjustment(pixels, ca) {
   if (!ca || isIdentityColorAdjustment(ca)) {
     return;
@@ -20221,64 +20323,160 @@ function stretchGdi(src, sx, sy, sw, sh, dw, dh, mode) {
   }
   return { width: W, height: H, data };
 }
-function axisBoxWeights(srcStart, srcLen, dstLen, reverse) {
-  const out = [];
+var FIX = 65536;
+function halftoneNearest(i, srcLen, dstLen) {
+  const num = (2 * i + 1) * srcLen;
+  const den = 2 * dstLen;
+  let k = Math.floor(num / den);
+  if (k * den === num) {
+    k--;
+  }
+  return Math.max(0, Math.min(srcLen - 1, k));
+}
+function halftoneAxis(start, srcLen, dstLen, reverse) {
+  const taps = [];
   if (dstLen <= 0 || srcLen <= 0) {
-    return out;
+    return taps;
   }
-  const at = (k) => reverse ? srcStart + srcLen - 1 - k : srcStart + k;
+  const at = (k) => reverse ? start + srcLen - 1 - k : start + k;
+  if (dstLen >= srcLen) {
+    for (let i = 0; i < dstLen; i++) {
+      taps.push([[at(halftoneNearest(i, srcLen, dstLen)), 1]]);
+    }
+    return taps;
+  }
+  const step = Math.ceil(srcLen * FIX / dstLen);
   for (let i = 0; i < dstLen; i++) {
-    const a = i * srcLen;
-    const b = (i + 1) * srcLen;
-    const taps = [];
-    for (let k = Math.floor(a / dstLen); k * dstLen < b; k++) {
-      const overlap = Math.min(b, (k + 1) * dstLen) - Math.max(a, k * dstLen);
+    const a = i * step;
+    const b = (i + 1) * step;
+    const run = [];
+    for (let k = Math.floor(a / FIX); k * FIX < b && k < srcLen; k++) {
+      const overlap = Math.min(b, (k + 1) * FIX) - Math.max(a, k * FIX);
       if (overlap > 0) {
-        taps.push([at(k), overlap / srcLen]);
+        run.push([at(k), overlap]);
+      }
+    }
+    taps.push(run);
+  }
+  return taps;
+}
+var SPECKLE_OVERSHOOT = 4;
+function halftoneDespeckle(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(y * w + x) * 3 + c];
+  const over = (v) => v < -SPECKLE_OVERSHOOT * 4 || v > (255 + SPECKLE_OVERSHOOT) * 4;
+  for (let y = 0; y < h; y++) {
+    const up = y > 0 ? y - 1 : Math.min(h - 1, y + 1);
+    const down = y < h - 1 ? y + 1 : Math.max(0, y - 1);
+    for (let x = 0; x < w; x++) {
+      const left = x > 0 ? x - 1 : Math.min(w - 1, x + 1);
+      const right = x < w - 1 ? x + 1 : Math.max(0, x - 1);
+      let hClip = 0;
+      let vClip = 0;
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        if (over(6 * v - at(left, y, c) - at(right, y, c))) {
+          hClip++;
+        }
+        if (over(6 * v - at(x, up, c) - at(x, down, c))) {
+          vClip++;
+        }
+      }
+      if (hClip < 2 || vClip < 2) {
+        continue;
+      }
+      for (let c = 0; c < 3; c++) {
+        px[(y * w + x) * 3 + c] = at(left, y, c) + 2 * at(x, y, c) + at(right, y, c) + 2 >> 2;
+      }
+    }
+  }
+}
+function halftoneSharpen(px, w, h) {
+  const src = px.slice();
+  const at = (x, y, c) => src[(Math.max(0, Math.min(h - 1, y)) * w + Math.max(0, Math.min(w - 1, x))) * 3 + c];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < 3; c++) {
+        const v = at(x, y, c);
+        const sum = at(x - 1, y, c) + at(x + 1, y, c) + at(x, y - 1, c) + at(x, y + 1, c);
+        const out = v + Math.floor((4 * v - sum) / 8);
+        px[(y * w + x) * 3 + c] = out < 0 ? 0 : out > 255 ? 255 : out;
       }
     }
-    out.push(taps);
   }
-  return out;
 }
-function stretchHalftone(src, sx, sy, sw, sh, dw, dh) {
+function stretchHalftone(src, sx, sy, sw, sh, dw, dh, adjust) {
   const W = Math.max(0, Math.round(Math.abs(dw)));
   const H = Math.max(0, Math.round(Math.abs(dh)));
+  const SW = Math.round(Math.abs(sw));
+  const SH = Math.round(Math.abs(sh));
+  const x0 = Math.round(Math.min(sx, sx + sw));
+  const y0 = Math.round(Math.min(sy, sy + sh));
   const flipX = dw < 0 !== sw < 0;
   const flipY = dh < 0 !== sh < 0;
-  const cols = axisBoxWeights(Math.round(Math.min(sx, sx + sw)), Math.round(Math.abs(sw)), W, flipX);
-  const rows = axisBoxWeights(Math.round(Math.min(sy, sy + sh)), Math.round(Math.abs(sh)), H, flipY);
   const data = new Uint8ClampedArray(W * H * 4);
-  const s = src.data;
+  if (W === 0 || H === 0 || SW === 0 || SH === 0) {
+    return { width: W, height: H, data };
+  }
+  const rect = new Int32Array(SW * SH * 3);
+  for (let y = 0; y < SH; y++) {
+    const yy = y0 + y;
+    for (let x = 0; x < SW; x++) {
+      const xx = x0 + x;
+      if (yy < 0 || yy >= src.height || xx < 0 || xx >= src.width) {
+        continue;
+      }
+      const i = (yy * src.width + xx) * 4;
+      const o = (y * SW + x) * 3;
+      rect[o] = src.data[i];
+      rect[o + 1] = src.data[i + 1];
+      rect[o + 2] = src.data[i + 2];
+    }
+  }
+  const enlarging = W >= SW && H >= SH && (W > SW || H > SH);
+  const reducing = W < SW && H < SH;
+  if (enlarging) {
+    halftoneDespeckle(rect, SW, SH);
+  }
+  if (adjust) {
+    adjust(rect);
+  }
+  const cols = halftoneAxis(0, SW, W, flipX);
+  const rows = halftoneAxis(0, SH, H, flipY);
+  const out = new Int32Array(W * H * 3);
   for (let y = 0; y < H; y++) {
-    const ys = rows[y] ?? [];
+    const ys = rows[y];
     for (let x = 0; x < W; x++) {
-      const xs = cols[x] ?? [];
+      const xs = cols[x];
       let r = 0;
       let g = 0;
       let b = 0;
+      let total = 0;
       for (const [yy, wy] of ys) {
-        if (yy < 0 || yy >= src.height) {
-          continue;
-        }
         for (const [xx, wx] of xs) {
-          if (xx < 0 || xx >= src.width) {
-            continue;
-          }
           const w = wx * wy;
-          const i = (yy * src.width + xx) * 4;
-          r += s[i] * w;
-          g += s[i + 1] * w;
-          b += s[i + 2] * w;
+          total += w;
+          const i = (yy * SW + xx) * 3;
+          r += rect[i] * w;
+          g += rect[i + 1] * w;
+          b += rect[i + 2] * w;
         }
       }
-      const o = (y * W + x) * 4;
-      data[o] = Math.floor(r + 1e-6);
-      data[o + 1] = Math.floor(g + 1e-6);
-      data[o + 2] = Math.floor(b + 1e-6);
-      data[o + 3] = 255;
+      const o = (y * W + x) * 3;
+      out[o] = Math.floor((2 * r + total) / (2 * total));
+      out[o + 1] = Math.floor((2 * g + total) / (2 * total));
+      out[o + 2] = Math.floor((2 * b + total) / (2 * total));
     }
   }
+  if (reducing) {
+    halftoneSharpen(out, W, H);
+  }
+  for (let i = 0, o = 0; i < W * H; i++, o += 3) {
+    data[i * 4] = out[o];
+    data[i * 4 + 1] = out[o + 1];
+    data[i * 4 + 2] = out[o + 2];
+    data[i * 4 + 3] = 255;
+  }
   return { width: W, height: H, data };
 }
 
@@ -20304,7 +20502,7 @@ function patternOperand(rCtx, brush) {
 function drawSourceMapped(target, decoded, req, offsetX, offsetY, mode) {
   const dLeft = Math.min(req.dx, req.dx + req.dw) - offsetX;
   const dTop = Math.min(req.dy, req.dy + req.dh) - offsetY;
-  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
+  const px = mode === HALFTONE ? stretchHalftone(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, decoded.adjust) : stretchGdi(decoded.pixels, req.sx, req.sy, req.sw, req.sh, req.dw, req.dh, mode);
   if (px.width === 0 || px.height === 0) {
     return;
   }
@@ -20332,15 +20530,14 @@ function decodeSource(rCtx, req) {
   if (!image) {
     return null;
   }
-  if (req.stretch && rCtx.state.stretchBltMode === HALFTONE) {
-    applyColorAdjustment(image, rCtx.state.colorAdjustment);
-  }
+  const ca = rCtx.state.colorAdjustment;
+  const adjust = req.stretch && rCtx.state.stretchBltMode === HALFTONE && ca ? (rgb2) => colorAdjustRgb(rgb2, ca) : void 0;
   let { sy } = req;
   if (req.dibOrigin === "bottom-left" && rCtx.view.getInt32(req.source.bmi + 8, true) > 0) {
     sy = image.height - sy - req.sh;
   }
   return {
-    decoded: { pixels: image },
+    decoded: { pixels: image, adjust },
     req: { ...req, sy }
   };
 }
@@ -20496,6 +20693,9 @@ function executeRotatedBlit(rCtx, logDx, logDy, logDw, logDh, rop, source, sx, s
       return;
     }
     src = decoded.decoded.pixels;
+    if (decoded.decoded.adjust) {
+      applyColorAdjustment(src, rCtx.state.colorAdjustment);
+    }
     srcX = decoded.req.sx;
     srcY = decoded.req.sy;
   }
@@ -23963,12 +24163,12 @@ function hslToRgb(h, s, l) {
   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];
 }
-function applyHueSaturationLightness(src, hue, saturation, lightness) {
+function applyHueSaturationLightness(src, hue, saturation, lightness2) {
   const out = new Uint8ClampedArray(src);
   const push = (v, t) => t >= 0 ? v + (1 - v) * (t / 100) : v * (1 + t / 100);
   for (let i = 0; i < src.length; i += 4) {
     const [h, s, l] = rgbToHsl(src[i] / 255, src[i + 1] / 255, src[i + 2] / 255);
-    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness));
+    const [r, g, b] = hslToRgb(h + hue, push(s, saturation), push(l, lightness2));
     out[i] = Math.round(r * 255);
     out[i + 1] = Math.round(g * 255);
     out[i + 2] = Math.round(b * 255);
@@ -24659,6 +24859,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
     }
   };
   if (pen) {
+    const nibDashed = !!nib && penDashArray(pen).length > 0;
     applyPlusPenStyle(ctx, pen, widthScale);
     const mode = plusRasterMode(rCtx);
     let sampler = pen.brush && !isSvgContext(ctx) ? brushSampler(rCtx, pen.brush) : null;
@@ -24673,7 +24874,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       if (mode !== "canvas" && size && strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, closedFigure)) {
         return;
       }
-      const outline = hasCustomCap(pen) ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
+      const outline = hasCustomCap(pen) || nibDashed ? penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) : null;
       let box = null;
       if (size && outline) {
         box = deviceBounds(outline.flat(), device, size, 2);
@@ -24703,7 +24904,7 @@ function strokePlusGeometry(rCtx, pen, buildPath, points, closedFigure = false)
       }
     }
     const paint = pen.brush ? brushPaint2(rCtx, pen.brush) : pen.color;
-    if ((hasCustomCap(pen) || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
+    if ((hasCustomCap(pen) || nibDashed || nib && typeof paint !== "string") && fillPenOutline(rCtx, pen, nib, paint, buildPath, closedFigure)) {
       return;
     }
     ctx.strokeStyle = paint;
@@ -24725,7 +24926,9 @@ function resolvePenTransform(pen) {
     return { pen: { ...plain, width: pen.width === 0 ? 1 : pen.width }, nib: null };
   }
   if (Math.abs(sx - sy) <= 1e-6 * sx && Math.abs(dot) <= 1e-6 * sx * sy) {
-    return { pen: { ...plain, width: pen.width * sx }, nib: null };
+    const pattern = pen.dashStyle === 5 ? pen.dashPattern : DASH_PATTERNS[pen.dashStyle];
+    const dashed = pattern && pattern.length > 0 ? { dashStyle: 5, dashPattern: pattern.map((v) => v / sx), dashOffset: (pen.dashOffset ?? 0) / sx } : {};
+    return { pen: { ...plain, ...dashed, width: pen.width * sx }, nib: null };
   }
   return { pen: plain, nib: [a, b, c, d, 0, 0] };
 }
@@ -24750,7 +24953,7 @@ function penFrame(device, nib) {
     toDevice: mulMatrix(full, [1 / unit, 0, 0, 1 / unit, 0, 0])
   };
 }
-function framePen(pen, unit) {
+function framePen(pen, unit, nib = null) {
   const dash = penDashArray(pen).map((v) => v * unit);
   return {
     half: (pen.width || 1) * unit / 2,
@@ -24761,6 +24964,7 @@ function framePen(pen, unit) {
     dashCap: pen.dashCap ?? 0,
     dash: dash.length > 0 ? dash : null,
     dashOffset: (pen.dashOffset ?? 0) * (pen.width || 1) * unit,
+    dashMetric: nib ? [nib[0], nib[1], nib[2], nib[3]] : void 0,
     compound: pen.compound ?? null,
     inset: pen.alignment === 1
   };
@@ -24788,7 +24992,7 @@ function strokeGdiplus(rCtx, pen, nib, sampler, buildPath, device, size, mode, c
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
   const width = (pen.width || 1) * frame2.unit;
-  const devicePen = framePen(pen, frame2.unit);
+  const devicePen = framePen(pen, frame2.unit, nib);
   const antialias = mode === "gdiplus-aa";
   const toFix = (poly) => {
     const m = frame2.toDevice;
@@ -24880,7 +25084,7 @@ function penOutlineWorld(rCtx, pen, nib, buildPath, closedFigure) {
     figures = figures.map((f) => ({ ...f, closed: true }));
   }
   const width = (pen.width || 1) * frame2.unit;
-  const devicePen = framePen(pen, frame2.unit);
+  const devicePen = framePen(pen, frame2.unit, nib);
   const outline = hasCustomCap(pen) ? customCapOutline(figures, width, devicePen, pen) : widenFigures(figures, devicePen);
   const m = mulMatrix(deviceInv, frame2.toDevice);
   return outline.map((poly) => poly.map((p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] })));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "emf-converter",
-	"version": "4.3.2",
+	"version": "4.3.4",
 	"description": "Convert EMF/WMF metafile binaries to PNG data URLs or SVG (markup, data URL, React/JSX)",
 	"keywords": [
 		"canvas",