@opendisplay/epaper-dithering 2.1.4 → 2.2.1

package/dist/index.cjs

@@ -14,6 +14,159 @@ var DitherMode = /* @__PURE__ */ ((DitherMode2) => {
   return DitherMode2;
 })(DitherMode || {});
 
+// src/color_space.ts
+var SRGB_TO_LINEAR_LUT = (() => {
+  const lut = new Float64Array(256);
+  for (let i = 0; i < 256; i++) {
+    const s = i / 255;
+    lut[i] = s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  }
+  return lut;
+})();
+
+// src/color_space_lab.ts
+var M00 = 0.4124564;
+var M01 = 0.3575761;
+var M02 = 0.1804375;
+var M10 = 0.2126729;
+var M11 = 0.7151522;
+var M12 = 0.072175;
+var M20 = 0.0193339;
+var M21 = 0.119192;
+var M22 = 0.9503041;
+var XN = 0.95047;
+var YN = 1;
+var ZN = 1.08883;
+var EPSILON = 216 / 24389;
+var KAPPA = 24389 / 27;
+var WL2 = 0.25;
+var WC2 = 1;
+var WH2 = 4;
+function labF(t) {
+  return t > EPSILON ? Math.cbrt(t) : (KAPPA * t + 16) / 116;
+}
+function rgbToLabScalar(r, g, b) {
+  const x = M00 * r + M01 * g + M02 * b;
+  const y = M10 * r + M11 * g + M12 * b;
+  const z = M20 * r + M21 * g + M22 * b;
+  const fx = labF(x / XN);
+  const fy = labF(y / YN);
+  const fz = labF(z / ZN);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+function precomputePaletteLab(paletteLinear) {
+  const n = paletteLinear.length;
+  const L = new Float64Array(n);
+  const a = new Float64Array(n);
+  const b = new Float64Array(n);
+  const C = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const [pl, pa, pb] = rgbToLabScalar(paletteLinear[i][0], paletteLinear[i][1], paletteLinear[i][2]);
+    L[i] = pl;
+    a[i] = pa;
+    b[i] = pb;
+    C[i] = Math.sqrt(pa * pa + pb * pb);
+  }
+  return { L, a, b, C };
+}
+function matchPixelLch(r, g, b, paletteL, paletteA, paletteB, paletteC) {
+  const [pL, pa, pb] = rgbToLabScalar(r, g, b);
+  const pC = Math.sqrt(pa * pa + pb * pb);
+  let bestIdx = 0;
+  let bestDist = Infinity;
+  const n = paletteL.length;
+  for (let i = 0; i < n; i++) {
+    const dL = pL - paletteL[i];
+    const da = pa - paletteA[i];
+    const db = pb - paletteB[i];
+    const dC = pC - paletteC[i];
+    let dHsq = da * da + db * db - dC * dC;
+    if (dHsq < 0) dHsq = 0;
+    const dist = WL2 * dL * dL + WC2 * dC * dC + WH2 * dHsq;
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestIdx = i;
+    }
+  }
+  return bestIdx;
+}
+
+// src/tone_map.ts
+var LUM_R = 0.2126729;
+var LUM_G = 0.7151522;
+var LUM_B = 0.072175;
+function compressDynamicRange(pixels, width, height, paletteLinear, strength = 1) {
+  if (strength <= 0) return;
+  const [br, bg, bb] = paletteLinear[0];
+  const [wr, wg, wb] = paletteLinear[1];
+  const blackY = LUM_R * br + LUM_G * bg + LUM_B * bb;
+  const whiteY = LUM_R * wr + LUM_G * wg + LUM_B * wb;
+  const displayRange = whiteY - blackY;
+  if (displayRange <= 0) return;
+  const n = width * height;
+  const blackLevel = blackY * strength;
+  for (let i = 0; i < n; i++) {
+    const base = i * 3;
+    const r = pixels[base];
+    const g = pixels[base + 1];
+    const b = pixels[base + 2];
+    const Y = LUM_R * r + LUM_G * g + LUM_B * b;
+    if (Y > 1e-6) {
+      const compressedY = blackY + Y * displayRange;
+      const targetY = strength < 1 ? Y + strength * (compressedY - Y) : compressedY;
+      const scale = targetY / Y;
+      pixels[base] = Math.max(0, Math.min(1, r * scale));
+      pixels[base + 1] = Math.max(0, Math.min(1, g * scale));
+      pixels[base + 2] = Math.max(0, Math.min(1, b * scale));
+    } else {
+      pixels[base] = blackLevel;
+      pixels[base + 1] = blackLevel;
+      pixels[base + 2] = blackLevel;
+    }
+  }
+}
+function autoCompressDynamicRange(pixels, width, height, paletteLinear) {
+  const [br, bg, bb] = paletteLinear[0];
+  const [wr, wg, wb] = paletteLinear[1];
+  const blackY = LUM_R * br + LUM_G * bg + LUM_B * bb;
+  const whiteY = LUM_R * wr + LUM_G * wg + LUM_B * wb;
+  const displayRange = whiteY - blackY;
+  if (displayRange <= 0) return;
+  const n = width * height;
+  const luminances = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const base = i * 3;
+    luminances[i] = LUM_R * pixels[base] + LUM_G * pixels[base + 1] + LUM_B * pixels[base + 2];
+  }
+  luminances.sort();
+  const pLow = luminances[Math.floor(n * 0.02)];
+  const pHigh = luminances[Math.floor(n * 0.98)];
+  const imageRange = pHigh - pLow;
+  if (imageRange < 1e-6) {
+    compressDynamicRange(pixels, width, height, paletteLinear, 1);
+    return;
+  }
+  for (let i = 0; i < n; i++) {
+    const base = i * 3;
+    const r = pixels[base];
+    const g = pixels[base + 1];
+    const b = pixels[base + 2];
+    const Y = LUM_R * r + LUM_G * g + LUM_B * b;
+    if (Y > 1e-6) {
+      const normalizedY = (Y - pLow) / imageRange;
+      const targetY = blackY + normalizedY * displayRange;
+      const scale = targetY / Y;
+      pixels[base] = Math.max(0, Math.min(1, r * scale));
+      pixels[base + 1] = Math.max(0, Math.min(1, g * scale));
+      pixels[base + 2] = Math.max(0, Math.min(1, b * scale));
+    } else {
+      pixels[base] = blackY;
+      pixels[base + 1] = blackY;
+      pixels[base + 2] = blackY;
+    }
+  }
+}
+
 // src/palettes.ts
 var ColorScheme = /* @__PURE__ */ ((ColorScheme3) => {
   ColorScheme3[ColorScheme3["MONO"] = 0] = "MONO";
@@ -22,6 +175,8 @@ var ColorScheme = /* @__PURE__ */ ((ColorScheme3) => {
   ColorScheme3[ColorScheme3["BWRY"] = 3] = "BWRY";
   ColorScheme3[ColorScheme3["BWGBRY"] = 4] = "BWGBRY";
   ColorScheme3[ColorScheme3["GRAYSCALE_4"] = 5] = "GRAYSCALE_4";
+  ColorScheme3[ColorScheme3["GRAYSCALE_8"] = 6] = "GRAYSCALE_8";
+  ColorScheme3[ColorScheme3["GRAYSCALE_16"] = 7] = "GRAYSCALE_16";
   return ColorScheme3;
 })(ColorScheme || {});
 var PALETTES = {
@@ -76,6 +231,40 @@ var PALETTES = {
       white: { r: 255, g: 255, b: 255 }
     },
     accent: "black"
+  },
+  [6 /* GRAYSCALE_8 */]: {
+    colors: {
+      black: { r: 0, g: 0, b: 0 },
+      gray1: { r: 36, g: 36, b: 36 },
+      gray2: { r: 73, g: 73, b: 73 },
+      gray3: { r: 109, g: 109, b: 109 },
+      gray4: { r: 146, g: 146, b: 146 },
+      gray5: { r: 182, g: 182, b: 182 },
+      gray6: { r: 219, g: 219, b: 219 },
+      white: { r: 255, g: 255, b: 255 }
+    },
+    accent: "black"
+  },
+  [7 /* GRAYSCALE_16 */]: {
+    colors: {
+      black: { r: 0, g: 0, b: 0 },
+      gray1: { r: 17, g: 17, b: 17 },
+      gray2: { r: 34, g: 34, b: 34 },
+      gray3: { r: 51, g: 51, b: 51 },
+      gray4: { r: 68, g: 68, b: 68 },
+      gray5: { r: 85, g: 85, b: 85 },
+      gray6: { r: 102, g: 102, b: 102 },
+      gray7: { r: 119, g: 119, b: 119 },
+      gray8: { r: 136, g: 136, b: 136 },
+      gray9: { r: 153, g: 153, b: 153 },
+      gray10: { r: 170, g: 170, b: 170 },
+      gray11: { r: 187, g: 187, b: 187 },
+      gray12: { r: 204, g: 204, b: 204 },
+      gray13: { r: 221, g: 221, b: 221 },
+      gray14: { r: 238, g: 238, b: 238 },
+      white: { r: 255, g: 255, b: 255 }
+    },
+    accent: "black"
   }
 };
 function getPalette(scheme) {
@@ -85,143 +274,230 @@ function getColorCount(scheme) {
   return Object.keys(PALETTES[scheme].colors).length;
 }
 function fromValue(value) {
-  if (value < 0 || value > 5) {
+  if (value < 0 || value > 7) {
     throw new Error(`Invalid color scheme value: ${value}`);
   }
   return value;
 }
+var SPECTRA_7_3_6COLOR = {
+  colors: {
+    black: { r: 26, g: 13, b: 35 },
+    white: { r: 185, g: 202, b: 205 },
+    yellow: { r: 202, g: 184, b: 0 },
+    red: { r: 121, g: 9, b: 0 },
+    blue: { r: 0, g: 69, b: 139 },
+    green: { r: 40, g: 82, b: 57 }
+  },
+  accent: "red"
+};
+var MONO_4_26 = {
+  colors: {
+    black: { r: 5, g: 5, b: 5 },
+    white: { r: 220, g: 220, b: 220 }
+  },
+  accent: "black"
+};
+var BWRY_4_2 = {
+  colors: {
+    black: { r: 5, g: 5, b: 5 },
+    white: { r: 200, g: 200, b: 200 },
+    yellow: { r: 200, g: 180, b: 0 },
+    red: { r: 120, g: 15, b: 5 }
+  },
+  accent: "red"
+};
+var SOLUM_BWR = {
+  colors: {
+    black: { r: 5, g: 5, b: 5 },
+    white: { r: 200, g: 200, b: 200 },
+    red: { r: 120, g: 15, b: 5 }
+  },
+  accent: "red"
+};
+var HANSHOW_BWR = {
+  colors: {
+    black: { r: 5, g: 5, b: 5 },
+    white: { r: 200, g: 200, b: 200 },
+    red: { r: 120, g: 15, b: 5 }
+  },
+  accent: "red"
+};
+var HANSHOW_BWY = {
+  colors: {
+    black: { r: 5, g: 5, b: 5 },
+    white: { r: 200, g: 200, b: 200 },
+    yellow: { r: 200, g: 180, b: 0 }
+  },
+  accent: "yellow"
+};
+var BWRY_3_97 = {
+  colors: {
+    black: { r: 10, g: 7, b: 14 },
+    white: { r: 173, g: 178, b: 174 },
+    yellow: { r: 172, g: 128, b: 0 },
+    red: { r: 85, g: 24, b: 14 }
+  },
+  accent: "red"
+};
 
 // src/algorithms.ts
-function getPaletteColors(scheme) {
-  const palette = getPalette(scheme);
-  return Object.values(palette.colors);
+var BAYER_4X4 = new Float32Array([
+  0,
+  8,
+  2,
+  10,
+  12,
+  4,
+  14,
+  6,
+  3,
+  11,
+  1,
+  9,
+  15,
+  7,
+  13,
+  5
+].map((v) => v / 16 - 0.5));
+function resolvePalette(scheme) {
+  return typeof scheme === "number" ? getPalette(scheme) : scheme;
 }
-function findClosestPaletteColor(rgb, palette) {
-  let minDistance = Infinity;
-  let closestIdx = 0;
-  for (let i = 0; i < palette.length; i++) {
-    const pal = palette[i];
-    const distance = (rgb.r - pal.r) ** 2 + (rgb.g - pal.g) ** 2 + (rgb.b - pal.b) ** 2;
-    if (distance < minDistance) {
-      minDistance = distance;
-      closestIdx = i;
-    }
+function paletteToLinear(palette) {
+  const paletteRgb = Object.values(palette.colors);
+  const paletteLinear = paletteRgb.map((c) => [
+    SRGB_TO_LINEAR_LUT[c.r],
+    SRGB_TO_LINEAR_LUT[c.g],
+    SRGB_TO_LINEAR_LUT[c.b]
+  ]);
+  return { paletteRgb, paletteLinear };
+}
+function buildLinearBuffer(image) {
+  const n = image.width * image.height;
+  const pixels = new Float32Array(n * 3);
+  const { data } = image;
+  for (let i = 0; i < n; i++) {
+    const base4 = i * 4;
+    const base3 = i * 3;
+    const alpha = data[base4 + 3] / 255;
+    const inv = 1 - alpha;
+    pixels[base3] = SRGB_TO_LINEAR_LUT[data[base4]] * alpha + inv;
+    pixels[base3 + 1] = SRGB_TO_LINEAR_LUT[data[base4 + 1]] * alpha + inv;
+    pixels[base3 + 2] = SRGB_TO_LINEAR_LUT[data[base4 + 2]] * alpha + inv;
   }
-  return closestIdx;
+  return pixels;
 }
-function errorDiffusionDither(image, colorScheme, kernel) {
+function errorDiffusionDither(image, scheme, kernel, serpentine) {
   const { width, height } = image;
-  const palette = getPaletteColors(colorScheme);
-  const pixels = new Float32Array(width * height * 3);
-  for (let i = 0; i < width * height; i++) {
-    pixels[i * 3] = image.data[i * 4];
-    pixels[i * 3 + 1] = image.data[i * 4 + 1];
-    pixels[i * 3 + 2] = image.data[i * 4 + 2];
+  const palette = resolvePalette(scheme);
+  const { paletteRgb, paletteLinear } = paletteToLinear(palette);
+  const numColors = paletteRgb.length;
+  const pixels = buildLinearBuffer(image);
+  if (typeof scheme !== "number") {
+    autoCompressDynamicRange(pixels, width, height, paletteLinear);
+  }
+  const { L: palL, a: palA, b: palB, C: palC } = precomputePaletteLab(paletteLinear);
+  const palR = new Float64Array(numColors);
+  const palG = new Float64Array(numColors);
+  const palBl = new Float64Array(numColors);
+  for (let i = 0; i < numColors; i++) {
+    palR[i] = paletteLinear[i][0];
+    palG[i] = paletteLinear[i][1];
+    palBl[i] = paletteLinear[i][2];
   }
   const indices = new Uint8Array(width * height);
   for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const idx = y * width + x;
-      const pixelIdx = idx * 3;
-      const oldPixel = {
-        r: Math.trunc(pixels[pixelIdx]),
-        g: Math.trunc(pixels[pixelIdx + 1]),
-        b: Math.trunc(pixels[pixelIdx + 2])
-      };
-      const newIdx = findClosestPaletteColor(oldPixel, palette);
-      const newPixel = palette[newIdx];
-      indices[idx] = newIdx;
-      const errorR = oldPixel.r - newPixel.r;
-      const errorG = oldPixel.g - newPixel.g;
-      const errorB = oldPixel.b - newPixel.b;
-      for (const { dx, dy, weight } of kernel) {
-        const nx = x + dx;
-        const ny = y + dy;
+    const leftToRight = !serpentine || y % 2 === 0;
+    const xStart = leftToRight ? 0 : width - 1;
+    const xEnd = leftToRight ? width : -1;
+    const xStep = leftToRight ? 1 : -1;
+    for (let x = xStart; x !== xEnd; x += xStep) {
+      const pixIdx = (y * width + x) * 3;
+      const r = Math.max(0, Math.min(1, pixels[pixIdx]));
+      const g = Math.max(0, Math.min(1, pixels[pixIdx + 1]));
+      const b = Math.max(0, Math.min(1, pixels[pixIdx + 2]));
+      const newIdx = matchPixelLch(r, g, b, palL, palA, palB, palC);
+      indices[y * width + x] = newIdx;
+      const errR = r - palR[newIdx];
+      const errG = g - palG[newIdx];
+      const errB = b - palBl[newIdx];
+      for (let k = 0; k < kernel.length; k++) {
+        const kEntry = kernel[k];
+        const nx = x + (leftToRight ? kEntry.dx : -kEntry.dx);
+        const ny = y + kEntry.dy;
         if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
-          const neighborIdx = (ny * width + nx) * 3;
-          pixels[neighborIdx] += errorR * weight;
-          pixels[neighborIdx + 1] += errorG * weight;
-          pixels[neighborIdx + 2] += errorB * weight;
+          const nIdx = (ny * width + nx) * 3;
+          pixels[nIdx] += errR * kEntry.weight;
+          pixels[nIdx + 1] += errG * kEntry.weight;
+          pixels[nIdx + 2] += errB * kEntry.weight;
         }
       }
     }
   }
-  return { width, height, indices, palette };
+  return { width, height, indices, palette: paletteRgb };
 }
-function directPaletteMap(image, colorScheme) {
+function directPaletteMap(image, scheme) {
   const { width, height } = image;
-  const palette = getPaletteColors(colorScheme);
+  const palette = resolvePalette(scheme);
+  const { paletteRgb, paletteLinear } = paletteToLinear(palette);
+  const pixels = buildLinearBuffer(image);
+  if (typeof scheme !== "number") {
+    autoCompressDynamicRange(pixels, width, height, paletteLinear);
+  }
+  const { L: palL, a: palA, b: palB, C: palC } = precomputePaletteLab(paletteLinear);
   const indices = new Uint8Array(width * height);
-  for (let i = 0; i < width * height; i++) {
-    const rgb = {
-      r: image.data[i * 4],
-      g: image.data[i * 4 + 1],
-      b: image.data[i * 4 + 2]
-    };
-    indices[i] = findClosestPaletteColor(rgb, palette);
+  const n = width * height;
+  for (let i = 0; i < n; i++) {
+    const base = i * 3;
+    const r = Math.max(0, Math.min(1, pixels[base]));
+    const g = Math.max(0, Math.min(1, pixels[base + 1]));
+    const b = Math.max(0, Math.min(1, pixels[base + 2]));
+    indices[i] = matchPixelLch(r, g, b, palL, palA, palB, palC);
   }
-  return { width, height, indices, palette };
+  return { width, height, indices, palette: paletteRgb };
 }
-function orderedDither(image, colorScheme) {
-  const bayerMatrix = new Uint8Array([
-    0,
-    8,
-    2,
-    10,
-    12,
-    4,
-    14,
-    6,
-    3,
-    11,
-    1,
-    9,
-    15,
-    7,
-    13,
-    5
-  ]).map((v) => v * 16);
+function orderedDither(image, scheme) {
   const { width, height } = image;
-  const palette = getPaletteColors(colorScheme);
+  const palette = resolvePalette(scheme);
+  const { paletteRgb, paletteLinear } = paletteToLinear(palette);
+  const pixels = buildLinearBuffer(image);
+  if (typeof scheme !== "number") {
+    autoCompressDynamicRange(pixels, width, height, paletteLinear);
+  }
+  const { L: palL, a: palA, b: palB, C: palC } = precomputePaletteLab(paletteLinear);
   const indices = new Uint8Array(width * height);
   for (let y = 0; y < height; y++) {
     for (let x = 0; x < width; x++) {
-      const idx = y * width + x;
-      const dataIdx = idx * 4;
-      const threshold = bayerMatrix[y % 4 * 4 + x % 4];
-      const rgb = {
-        r: Math.max(0, Math.min(255, Math.trunc(image.data[dataIdx] + threshold))),
-        g: Math.max(0, Math.min(255, Math.trunc(image.data[dataIdx + 1] + threshold))),
-        b: Math.max(0, Math.min(255, Math.trunc(image.data[dataIdx + 2] + threshold)))
-      };
-      indices[idx] = findClosestPaletteColor(rgb, palette);
+      const base = (y * width + x) * 3;
+      const threshold = BAYER_4X4[y % 4 * 4 + x % 4];
+      const r = Math.max(0, Math.min(1, pixels[base] + threshold));
+      const g = Math.max(0, Math.min(1, pixels[base + 1] + threshold));
+      const b = Math.max(0, Math.min(1, pixels[base + 2] + threshold));
+      indices[y * width + x] = matchPixelLch(r, g, b, palL, palA, palB, palC);
     }
   }
-  return { width, height, indices, palette };
+  return { width, height, indices, palette: paletteRgb };
 }
-function burkesDither(image, colorScheme) {
-  const kernel = [
-    { dx: 1, dy: 0, weight: 32 / 200 },
-    { dx: 2, dy: 0, weight: 12 / 200 },
-    { dx: -2, dy: 1, weight: 5 / 200 },
-    { dx: -1, dy: 1, weight: 12 / 200 },
-    { dx: 0, dy: 1, weight: 26 / 200 },
-    { dx: 1, dy: 1, weight: 12 / 200 },
-    { dx: 2, dy: 1, weight: 5 / 200 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
-}
-function floydSteinbergDither(image, colorScheme) {
-  const kernel = [
+function floydSteinbergDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
     { dx: 1, dy: 0, weight: 7 / 16 },
     { dx: -1, dy: 1, weight: 3 / 16 },
     { dx: 0, dy: 1, weight: 5 / 16 },
     { dx: 1, dy: 1, weight: 1 / 16 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
+  ], serpentine);
+}
+function burkesDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
+    { dx: 1, dy: 0, weight: 8 / 32 },
+    { dx: 2, dy: 0, weight: 4 / 32 },
+    { dx: -2, dy: 1, weight: 2 / 32 },
+    { dx: -1, dy: 1, weight: 4 / 32 },
+    { dx: 0, dy: 1, weight: 8 / 32 },
+    { dx: 1, dy: 1, weight: 4 / 32 },
+    { dx: 2, dy: 1, weight: 2 / 32 }
+  ], serpentine);
 }
-function sierraDither(image, colorScheme) {
-  const kernel = [
+function sierraDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
     { dx: 1, dy: 0, weight: 5 / 32 },
     { dx: 2, dy: 0, weight: 3 / 32 },
     { dx: -2, dy: 1, weight: 2 / 32 },
@@ -232,30 +508,27 @@ function sierraDither(image, colorScheme) {
     { dx: -1, dy: 2, weight: 2 / 32 },
     { dx: 0, dy: 2, weight: 3 / 32 },
     { dx: 1, dy: 2, weight: 2 / 32 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
+  ], serpentine);
 }
-function sierraLiteDither(image, colorScheme) {
-  const kernel = [
+function sierraLiteDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
     { dx: 1, dy: 0, weight: 2 / 4 },
     { dx: -1, dy: 1, weight: 1 / 4 },
     { dx: 0, dy: 1, weight: 1 / 4 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
+  ], serpentine);
 }
-function atkinsonDither(image, colorScheme) {
-  const kernel = [
+function atkinsonDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
     { dx: 1, dy: 0, weight: 1 / 8 },
     { dx: 2, dy: 0, weight: 1 / 8 },
     { dx: -1, dy: 1, weight: 1 / 8 },
     { dx: 0, dy: 1, weight: 1 / 8 },
     { dx: 1, dy: 1, weight: 1 / 8 },
     { dx: 0, dy: 2, weight: 1 / 8 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
+  ], serpentine);
 }
-function stuckiDither(image, colorScheme) {
-  const kernel = [
+function stuckiDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
     { dx: 1, dy: 0, weight: 8 / 42 },
     { dx: 2, dy: 0, weight: 4 / 42 },
     { dx: -2, dy: 1, weight: 2 / 42 },
@@ -268,11 +541,10 @@ function stuckiDither(image, colorScheme) {
     { dx: 0, dy: 2, weight: 4 / 42 },
     { dx: 1, dy: 2, weight: 2 / 42 },
     { dx: 2, dy: 2, weight: 1 / 42 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
+  ], serpentine);
 }
-function jarvisJudiceNinkeDither(image, colorScheme) {
-  const kernel = [
+function jarvisJudiceNinkeDither(image, scheme, serpentine = true) {
+  return errorDiffusionDither(image, scheme, [
     { dx: 1, dy: 0, weight: 7 / 48 },
     { dx: 2, dy: 0, weight: 5 / 48 },
     { dx: -2, dy: 1, weight: 3 / 48 },
@@ -285,40 +557,46 @@ function jarvisJudiceNinkeDither(image, colorScheme) {
     { dx: 0, dy: 2, weight: 5 / 48 },
     { dx: 1, dy: 2, weight: 3 / 48 },
     { dx: 2, dy: 2, weight: 1 / 48 }
-  ];
-  return errorDiffusionDither(image, colorScheme, kernel);
+  ], serpentine);
 }
 
 // src/core.ts
-function ditherImage(image, colorScheme, mode = 1 /* BURKES */) {
+function ditherImage(image, colorScheme, mode = 1 /* BURKES */, serpentine = true) {
   switch (mode) {
     case 0 /* NONE */:
       return directPaletteMap(image, colorScheme);
     case 2 /* ORDERED */:
       return orderedDither(image, colorScheme);
     case 3 /* FLOYD_STEINBERG */:
-      return floydSteinbergDither(image, colorScheme);
+      return floydSteinbergDither(image, colorScheme, serpentine);
     case 4 /* ATKINSON */:
-      return atkinsonDither(image, colorScheme);
+      return atkinsonDither(image, colorScheme, serpentine);
     case 5 /* STUCKI */:
-      return stuckiDither(image, colorScheme);
+      return stuckiDither(image, colorScheme, serpentine);
     case 6 /* SIERRA */:
-      return sierraDither(image, colorScheme);
+      return sierraDither(image, colorScheme, serpentine);
     case 7 /* SIERRA_LITE */:
-      return sierraLiteDither(image, colorScheme);
+      return sierraLiteDither(image, colorScheme, serpentine);
     case 8 /* JARVIS_JUDICE_NINKE */:
-      return jarvisJudiceNinkeDither(image, colorScheme);
+      return jarvisJudiceNinkeDither(image, colorScheme, serpentine);
     case 1 /* BURKES */:
     default:
-      return burkesDither(image, colorScheme);
+      return burkesDither(image, colorScheme, serpentine);
   }
 }
 
 // src/index.ts
 var VERSION = "0.1.0";
 
+exports.BWRY_3_97 = BWRY_3_97;
+exports.BWRY_4_2 = BWRY_4_2;
 exports.ColorScheme = ColorScheme;
 exports.DitherMode = DitherMode;
+exports.HANSHOW_BWR = HANSHOW_BWR;
+exports.HANSHOW_BWY = HANSHOW_BWY;
+exports.MONO_4_26 = MONO_4_26;
+exports.SOLUM_BWR = SOLUM_BWR;
+exports.SPECTRA_7_3_6COLOR = SPECTRA_7_3_6COLOR;
 exports.VERSION = VERSION;
 exports.ditherImage = ditherImage;
 exports.fromValue = fromValue;