emf-converter 4.15.2 → 4.16.0

package/dist/index.js

@@ -21045,6 +21045,7 @@ function invert2(m) {
 }
 var COVERAGE_NUDGE_X = 1e-6;
 var COVERAGE_NUDGE_Y = 1e-9;
+var AXIS_ALIGNED_SHEAR = 5e-4;
 var SUBPIXEL_GRID = 16;
 function snapToDeviceGrid(spec) {
   const m = spec.toDevice;
@@ -21094,8 +21095,11 @@ function fadeAt(d, bilinear) {
   const i = Math.floor(x);
   return FAR_FADE[i] + (FAR_FADE[i + 1] - FAR_FADE[i]) * (x - i);
 }
+function ceilExtent(len) {
+  return Math.ceil(len * (1 - 15e-8));
+}
 function nearSourceExtent(deviceLen, srcLen) {
-  const d = Math.ceil(deviceLen - 1e-6) - srcLen;
+  const d = ceilExtent(deviceLen) - srcLen;
   return d >= -1 && d <= 1;
 }
 var BICUBIC_A = -0.5;
@@ -21124,7 +21128,7 @@ function axisFilter(kernel, scale, copy) {
       return { radius: 0.5, weight: (i, c) => Math.floor(c + 0.5) === i ? 1 : 0 };
   }
 }
-function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge = { wrap: void 0, clamp: null }, integerBicubic = false) {
+function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge = { wrap: void 0, clamp: null }, integerBicubic = false, premult = false) {
   const [outer0, outerW, inner0, innerW] = verticalFirst ? [iu0, wu, iv0, wv] : [iv0, wv, iu0, wu];
   const [oMin, oMax, iMin, iMax] = verticalFirst ? [box.x0, box.x1, box.y0, box.y1] : [box.y0, box.y1, box.x0, box.x1];
   let r = 0;
@@ -21165,9 +21169,9 @@ function blendSeparable(rgba, width, box, iu0, wu, iv0, wv, verticalFirst, edge
       }
       const alpha = px[s + 3];
       const wa = wi * alpha / 255;
-      lr += integerBicubic ? wi * Math.round(alpha * px[s] / 255) : wa * px[s];
-      lg += integerBicubic ? wi * Math.round(alpha * px[s + 1] / 255) : wa * px[s + 1];
-      lb += integerBicubic ? wi * Math.round(alpha * px[s + 2] / 255) : wa * px[s + 2];
+      lr += premult ? wi * px[s] : integerBicubic ? wi * Math.round(alpha * px[s] / 255) : wa * px[s];
+      lg += premult ? wi * px[s + 1] : integerBicubic ? wi * Math.round(alpha * px[s + 1] / 255) : wa * px[s + 1];
+      lb += premult ? wi * px[s + 2] : integerBicubic ? wi * Math.round(alpha * px[s + 2] / 255) : wa * px[s + 2];
       la += wi * alpha;
     }
     if (integerBicubic) {
@@ -21207,7 +21211,8 @@ function mirroredOrigin(o) {
   const f = o - Math.floor(o);
   return f === 0 ? o : Math.floor(o) + 1 - f;
 }
-function resampleImage(rgba, width, height, spec, surface) {
+function resampleImage(rgba, width, height, spec, surface, options2 = {}) {
+  const { plainRotated: plainRotatedPass = false, keepOrigin = false, premultSource = false, premultOut = false } = typeof options2 === "boolean" ? { plainRotated: options2 } : options2;
   if (spec.rightHalo && spec.rightHalo.length === height * 4) {
     const grown = new Uint8ClampedArray((width + 1) * height * 4);
     for (let y = 0; y < height; y++) {
@@ -21219,20 +21224,27 @@ function resampleImage(rgba, width, height, spec, surface) {
   if (spec.kernel === "nearest" && !spec.wrap) {
     return resampleNearest(rgba, width, height, spec, surface);
   }
-  let m = snapToDeviceGrid(spec);
+  let m = keepOrigin ? spec.toDevice : snapToDeviceGrid(spec);
   let kernel = spec.kernel;
   const hq = kernel === "hq-bilinear" || kernel === "hq-bicubic";
+  if (hq && (m[1] !== 0 || m[2] !== 0) && Math.abs(m[1]) <= AXIS_ALIGNED_SHEAR * Math.abs(m[0]) && Math.abs(m[2]) <= AXIS_ALIGNED_SHEAR * Math.abs(m[3])) {
+    m = [m[0], 0, 0, m[3], m[4], m[5]];
+  }
   const axisAligned = m[1] === 0 && m[2] === 0;
-  const integerBicubic = kernel === "bicubic" && axisAligned;
-  const unitBicubicCopy = integerBicubic && !spec.halfPixelOffset && m[0] === 1 && m[3] === 1 && m[4] - Math.round(m[4]) > -1 / 64 && m[4] - Math.round(m[4]) <= 1 / 64 && m[5] - Math.round(m[5]) > -1 / 64 && m[5] - Math.round(m[5]) <= 1 / 64;
+  let plainRotated = plainRotatedPass;
+  const unitBicubicCopy = kernel === "bicubic" && axisAligned && !spec.halfPixelOffset && m[0] === 1 && m[3] === 1 && m[4] - Math.round(m[4]) > -1 / 64 && m[4] - Math.round(m[4]) <= 1 / 64 && m[5] - Math.round(m[5]) > -1 / 64 && m[5] - Math.round(m[5]) <= 1 / 64;
   let farFade = false;
   let shiftX = 0;
   let shiftY = 0;
   if (hq && !axisAligned) {
     const extentU = Math.hypot(m[0], m[1]) * spec.srcW;
     const extentV = Math.hypot(m[2], m[3]) * spec.srcH;
-    if (nearSourceExtent(extentU, spec.srcW) || nearSourceExtent(extentV, spec.srcH)) {
+    const near = nearSourceExtent(extentU, spec.srcW) || nearSourceExtent(extentV, spec.srcH);
+    if (!spec.wrap) {
+      return resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel, near);
+    } else if (near) {
       kernel = kernel === "hq-bicubic" ? "bicubic" : "bilinear";
+      plainRotated = true;
     } else {
       farFade = true;
       if (spec.halfPixelOffset) {
@@ -21243,6 +21255,13 @@ function resampleImage(rgba, width, height, spec, surface) {
       }
     }
   }
+  const integerBicubic = kernel === "bicubic" && (axisAligned || plainRotated);
+  if (hq && axisAligned && !spec.wrap && !premultSource) {
+    const phased = resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut);
+    if (phased !== void 0) {
+      return phased;
+    }
+  }
   if (hq && axisAligned) {
     const ox = m[0] * spec.srcX + m[4];
     m = [m[0], 0, 0, m[3], m[4] + mirroredOrigin(ox) - ox, m[5]];
@@ -21352,7 +21371,7 @@ function resampleImage(rgba, width, height, spec, surface) {
         for (let t = iv0; t <= iv1; t++) {
           wv.push(integerBicubic ? Math.round(fv.weight(t, cv) * 65536) / 65536 : fv.weight(t, cv));
         }
-        return blendSeparable(rgba, width, box, iu0, wu, iv0, wv, kernel === "bicubic", edge, integerBicubic);
+        return blendSeparable(rgba, width, box, iu0, wu, iv0, wv, kernel === "bicubic", edge, integerBicubic, premultSource);
       };
       let [r, g, b, a] = sampleAt(u, v);
       if (farFade && !spec.wrap && a > 0) {
@@ -21376,6 +21395,12 @@ function resampleImage(rgba, width, height, spec, surface) {
         b = Math.trunc(b);
         a = Math.trunc(a);
         if (a <= 0) continue;
+      } else if (premultSource) {
+        r = Math.round(r);
+        g = Math.round(g);
+        b = Math.round(b);
+        a = Math.round(a);
+        if (a <= 0) continue;
       }
       const alpha = Math.min(255, a);
       const dst = (j * w + i) * 4;
@@ -21387,6 +21412,244 @@ function resampleImage(rgba, width, height, spec, surface) {
   }
   return { x: bx0, y: by0, w, h, rgba: out };
 }
+var HQ_PHASES = 128;
+function resampleHqAxisAligned(rgba, width, height, spec, surface, m, premultOut) {
+  const kernel = spec.kernel;
+  const scaleU = m[0];
+  const scaleV = m[3];
+  if (!(scaleU >= 1 && scaleV >= 1) || spec.rightHalo) {
+    return void 0;
+  }
+  const integral = (v) => Math.abs(v - Math.round(v)) < 1e-9;
+  if (scaleU === 1 && scaleV === 1 && integral(m[4]) && integral(m[5])) {
+    return void 0;
+  }
+  const shift = spec.halfPixelOffset ? 0.5 : 0;
+  const left = m[0] * spec.srcX + m[4] - shift;
+  const top = m[3] * spec.srcY + m[5] - shift;
+  const right = left + m[0] * spec.srcW;
+  const bottom = top + m[3] * spec.srcH;
+  const xFirst = Math.ceil(left - COVERAGE_NUDGE_X);
+  const xLast = Math.ceil(right - COVERAGE_NUDGE_X) - 1;
+  const yFirst = Math.ceil(top - COVERAGE_NUDGE_Y);
+  const yLast = Math.ceil(bottom - COVERAGE_NUDGE_Y) - 1;
+  const cx0 = Math.max(0, xFirst);
+  const cy0 = Math.max(0, yFirst);
+  const cx1 = Math.min(surface.w - 1, xLast);
+  const cy1 = Math.min(surface.h - 1, yLast);
+  if (cx1 < cx0 || cy1 < cy0) {
+    return null;
+  }
+  const w = cx1 - cx0 + 1;
+  const h = cy1 - cy0 + 1;
+  if (w * h > MAX_RESAMPLE_PIXELS) {
+    return null;
+  }
+  const cubic = kernel === "hq-bicubic";
+  const bin = cubic ? 0.5 : 1;
+  const stepU = Math.round(65536 / scaleU);
+  const stepV = Math.round(65536 / scaleV);
+  const dx = Math.max(0, xFirst - left);
+  const dy = Math.max(0, yFirst - top);
+  const offsetU = dx > 1e-9 ? Math.round((1 - dx) * stepU) : 0;
+  const offsetV = dy > 1e-9 ? Math.round(dy * stepV) : 0;
+  const filterU = axisFilter(kernel, scaleU, false);
+  const filterV = axisFilter(kernel, scaleV, false);
+  const tapsFor = (filter, step, offset, origin, from, to) => {
+    const taps = [];
+    for (let k = from; k <= to; k++) {
+      const phase = Math.floor((k * step + offset - 1) / (65536 / HQ_PHASES));
+      const c = origin + (phase + bin) / HQ_PHASES;
+      const first = Math.ceil(c - filter.radius);
+      const last = Math.floor(c + filter.radius);
+      const weights = [];
+      for (let t = first; t <= last; t++) {
+        weights.push(filter.weight(t, c));
+      }
+      taps.push({ first, weights });
+    }
+    return taps;
+  };
+  const colTaps = tapsFor(filterU, stepU, offsetU, spec.srcX, cx0 - xFirst, cx1 - xFirst);
+  const rowTaps = tapsFor(filterV, stepV, offsetV, spec.srcY, cy0 - yFirst, cy1 - yFirst);
+  let rowMin = Infinity;
+  let rowMax = -Infinity;
+  for (const t of rowTaps) {
+    rowMin = Math.min(rowMin, t.first);
+    rowMax = Math.max(rowMax, t.first + t.weights.length - 1);
+  }
+  rowMin = Math.max(0, rowMin);
+  rowMax = Math.min(height - 1, rowMax);
+  const rows = Math.max(0, rowMax - rowMin + 1);
+  const inter = new Uint8Array(rows * w * 4);
+  for (let r = 0; r < rows; r++) {
+    const srcRow = (rowMin + r) * width;
+    for (let i = 0; i < w; i++) {
+      const t = colTaps[i];
+      let pr = 0;
+      let pg = 0;
+      let pb = 0;
+      let pa = 0;
+      for (let q = 0; q < t.weights.length; q++) {
+        const tx = t.first + q;
+        if (tx < 0 || tx >= width) {
+          continue;
+        }
+        const o = (srcRow + tx) * 4;
+        const a = rgba[o + 3];
+        if (a === 0) {
+          continue;
+        }
+        const wq = t.weights[q];
+        pr += wq * Math.round(rgba[o] * a / 255);
+        pg += wq * Math.round(rgba[o + 1] * a / 255);
+        pb += wq * Math.round(rgba[o + 2] * a / 255);
+        pa += wq * a;
+      }
+      const alpha = Math.min(255, Math.max(0, Math.round(pa)));
+      const d = (r * w + i) * 4;
+      inter[d] = Math.min(alpha, Math.max(0, Math.round(pr)));
+      inter[d + 1] = Math.min(alpha, Math.max(0, Math.round(pg)));
+      inter[d + 2] = Math.min(alpha, Math.max(0, Math.round(pb)));
+      inter[d + 3] = alpha;
+    }
+  }
+  const out = new Uint8ClampedArray(w * h * 4);
+  for (let j = 0; j < h; j++) {
+    const t = rowTaps[j];
+    for (let i = 0; i < w; i++) {
+      let pr = 0;
+      let pg = 0;
+      let pb = 0;
+      let pa = 0;
+      for (let q = 0; q < t.weights.length; q++) {
+        const ty = t.first + q - rowMin;
+        if (ty < 0 || ty >= rows) {
+          continue;
+        }
+        const o = (ty * w + i) * 4;
+        const wq = t.weights[q];
+        pr += wq * inter[o];
+        pg += wq * inter[o + 1];
+        pb += wq * inter[o + 2];
+        pa += wq * inter[o + 3];
+      }
+      const alpha = Math.min(255, Math.max(0, Math.round(pa)));
+      if (alpha === 0) {
+        continue;
+      }
+      const d = (j * w + i) * 4;
+      const k = premultOut ? 1 : 255 / alpha;
+      out[d] = Math.min(alpha, Math.max(0, Math.round(pr))) * k;
+      out[d + 1] = Math.min(alpha, Math.max(0, Math.round(pg))) * k;
+      out[d + 2] = Math.min(alpha, Math.max(0, Math.round(pb))) * k;
+      out[d + 3] = alpha;
+    }
+  }
+  return { x: cx0, y: cy0, w, h, rgba: out, premultiplied: premultOut };
+}
+function resampleRotatedTwoStage(rgba, width, height, spec, surface, m, kernel, near) {
+  const pad = 2;
+  let img;
+  let pw;
+  let ph;
+  let a;
+  let b;
+  let c;
+  let d;
+  let ex;
+  let ey;
+  const half = spec.halfPixelOffset;
+  if (near) {
+    pw = width + 2 * pad;
+    ph = height + 2 * pad;
+    img = new Uint8ClampedArray(pw * ph * 4);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const s = (y * width + x) * 4;
+        const al = rgba[s + 3];
+        const o = ((y + pad) * pw + x + pad) * 4;
+        img[o] = Math.round(rgba[s] * al / 255);
+        img[o + 1] = Math.round(rgba[s + 1] * al / 255);
+        img[o + 2] = Math.round(rgba[s + 2] * al / 255);
+        img[o + 3] = al;
+      }
+    }
+    [a, b, c, d] = m;
+    ex = m[4] - (half ? 0.5 : 0);
+    ey = m[5] - (half ? 0.5 : 0);
+  } else {
+    const W = ceilExtent(Math.hypot(m[0], m[1]) * spec.srcW);
+    const H = ceilExtent(Math.hypot(m[2], m[3]) * spec.srcH);
+    const kx = W / spec.srcW;
+    const ky = H / spec.srcH;
+    const pre = resampleImage(rgba, width, height, {
+      srcX: spec.srcX,
+      srcY: spec.srcY,
+      srcW: spec.srcW,
+      srcH: spec.srcH,
+      toDevice: [kx, 0, 0, ky, -spec.srcX * kx, -spec.srcY * ky],
+      kernel,
+      halfPixelOffset: false
+    }, { w: W, h: H }, { premultOut: true });
+    if (!pre) {
+      return null;
+    }
+    if (!pre.premultiplied) {
+      for (let i = 0; i < pre.rgba.length; i += 4) {
+        const al = pre.rgba[i + 3];
+        pre.rgba[i] = Math.round(pre.rgba[i] * al / 255);
+        pre.rgba[i + 1] = Math.round(pre.rgba[i + 1] * al / 255);
+        pre.rgba[i + 2] = Math.round(pre.rgba[i + 2] * al / 255);
+      }
+    }
+    pw = W + 2 * pad;
+    ph = H + 2 * pad;
+    img = new Uint8ClampedArray(pw * ph * 4);
+    for (let y = 0; y < pre.h; y++) {
+      for (let x = 0; x < pre.w; x++) {
+        const dx = x + pre.x;
+        const dy = y + pre.y;
+        if (dx < W && dy < H) {
+          img.set(pre.rgba.subarray((y * pre.w + x) * 4, (y * pre.w + x) * 4 + 4), ((dy + pad) * pw + dx + pad) * 4);
+        }
+      }
+    }
+    a = m[0] / kx;
+    b = m[1] / kx;
+    c = m[2] / ky;
+    d = m[3] / ky;
+    const ox = m[0] * spec.srcX + m[2] * spec.srcY + m[4];
+    const oy = m[1] * spec.srcX + m[3] * spec.srcY + m[5];
+    ex = half ? ox - 0.5 + 0.5 * (a + c) : ox;
+    ey = half ? oy - 0.5 + 0.5 * (b + d) : oy;
+  }
+  const block = resampleImage(img, pw, ph, {
+    srcX: 0,
+    srcY: 0,
+    srcW: pw,
+    srcH: ph,
+    toDevice: [a, b, c, d, ex - a * pad - c * pad, ey - b * pad - d * pad],
+    kernel: kernel === "hq-bicubic" ? "bicubic" : "bilinear",
+    halfPixelOffset: false
+  }, surface, { plainRotated: true, keepOrigin: true, premultSource: true });
+  if (!block) {
+    return block;
+  }
+  const corners = [
+    [spec.srcX, spec.srcY],
+    [spec.srcX + spec.srcW, spec.srcY],
+    [spec.srcX + spec.srcW, spec.srcY + spec.srcH],
+    [spec.srcX, spec.srcY + spec.srcH]
+  ].flatMap(([u, v]) => [toPlusFix(m[0] * u + m[2] * v + m[4]), toPlusFix(m[1] * u + m[3] * v + m[5])]);
+  const coverage = rasterizePlusFill([corners], false, false, half, { x: block.x, y: block.y, w: block.w, h: block.h });
+  for (let i = 0; i < block.w * block.h; i++) {
+    if (!coverage[i]) {
+      block.rgba.fill(0, i * 4, i * 4 + 4);
+    }
+  }
+  return block;
+}
 var FIX16 = 65536;
 function resampleNearest(rgba, width, height, spec, surface) {
   const m = spec.toDevice;