@aui.io/apollo 0.1.4 → 0.1.6

package/node_modules/@aui.io/apollo-tui/node_modules/image-q/dist/esm/image-q.mjs

@@ -0,0 +1,2886 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/constants/index.ts
+var constants_exports = {};
+__export(constants_exports, {
+  bt709: () => bt709_exports
+});
+
+// src/constants/bt709.ts
+var bt709_exports = {};
+__export(bt709_exports, {
+  Y: () => Y,
+  x: () => x,
+  y: () => y
+});
+var Y = /* @__PURE__ */ ((Y2) => {
+  Y2[Y2["RED"] = 0.2126] = "RED";
+  Y2[Y2["GREEN"] = 0.7152] = "GREEN";
+  Y2[Y2["BLUE"] = 0.0722] = "BLUE";
+  Y2[Y2["WHITE"] = 1] = "WHITE";
+  return Y2;
+})(Y || {});
+var x = /* @__PURE__ */ ((x2) => {
+  x2[x2["RED"] = 0.64] = "RED";
+  x2[x2["GREEN"] = 0.3] = "GREEN";
+  x2[x2["BLUE"] = 0.15] = "BLUE";
+  x2[x2["WHITE"] = 0.3127] = "WHITE";
+  return x2;
+})(x || {});
+var y = /* @__PURE__ */ ((y2) => {
+  y2[y2["RED"] = 0.33] = "RED";
+  y2[y2["GREEN"] = 0.6] = "GREEN";
+  y2[y2["BLUE"] = 0.06] = "BLUE";
+  y2[y2["WHITE"] = 0.329] = "WHITE";
+  return y2;
+})(y || {});
+
+// src/conversion/index.ts
+var conversion_exports = {};
+__export(conversion_exports, {
+  lab2rgb: () => lab2rgb,
+  lab2xyz: () => lab2xyz,
+  rgb2hsl: () => rgb2hsl,
+  rgb2lab: () => rgb2lab,
+  rgb2xyz: () => rgb2xyz,
+  xyz2lab: () => xyz2lab,
+  xyz2rgb: () => xyz2rgb
+});
+
+// src/conversion/rgb2xyz.ts
+function correctGamma(n) {
+  return n > 0.04045 ? ((n + 0.055) / 1.055) ** 2.4 : n / 12.92;
+}
+function rgb2xyz(r, g, b) {
+  r = correctGamma(r / 255);
+  g = correctGamma(g / 255);
+  b = correctGamma(b / 255);
+  return {
+    x: r * 0.4124 + g * 0.3576 + b * 0.1805,
+    y: r * 0.2126 + g * 0.7152 + b * 0.0722,
+    z: r * 0.0193 + g * 0.1192 + b * 0.9505
+  };
+}
+
+// src/utils/arithmetic.ts
+var arithmetic_exports = {};
+__export(arithmetic_exports, {
+  degrees2radians: () => degrees2radians,
+  inRange0to255: () => inRange0to255,
+  inRange0to255Rounded: () => inRange0to255Rounded,
+  intInRange: () => intInRange,
+  max3: () => max3,
+  min3: () => min3,
+  stableSort: () => stableSort
+});
+function degrees2radians(n) {
+  return n * (Math.PI / 180);
+}
+function max3(a, b, c) {
+  let m = a;
+  if (m < b)
+    m = b;
+  if (m < c)
+    m = c;
+  return m;
+}
+function min3(a, b, c) {
+  let m = a;
+  if (m > b)
+    m = b;
+  if (m > c)
+    m = c;
+  return m;
+}
+function intInRange(value, low, high) {
+  if (value > high)
+    value = high;
+  if (value < low)
+    value = low;
+  return value | 0;
+}
+function inRange0to255Rounded(n) {
+  n = Math.round(n);
+  if (n > 255)
+    n = 255;
+  else if (n < 0)
+    n = 0;
+  return n;
+}
+function inRange0to255(n) {
+  if (n > 255)
+    n = 255;
+  else if (n < 0)
+    n = 0;
+  return n;
+}
+function stableSort(arrayToSort, callback) {
+  const type = typeof arrayToSort[0];
+  let sorted;
+  if (type === "number" || type === "string") {
+    const ord = /* @__PURE__ */ Object.create(null);
+    for (let i = 0, l = arrayToSort.length; i < l; i++) {
+      const val = arrayToSort[i];
+      if (ord[val] || ord[val] === 0)
+        continue;
+      ord[val] = i;
+    }
+    sorted = arrayToSort.sort((a, b) => callback(a, b) || ord[a] - ord[b]);
+  } else {
+    const ord2 = arrayToSort.slice(0);
+    sorted = arrayToSort.sort((a, b) => callback(a, b) || ord2.indexOf(a) - ord2.indexOf(b));
+  }
+  return sorted;
+}
+
+// src/conversion/rgb2hsl.ts
+function rgb2hsl(r, g, b) {
+  const min = min3(r, g, b);
+  const max = max3(r, g, b);
+  const delta = max - min;
+  const l = (min + max) / 510;
+  let s = 0;
+  if (l > 0 && l < 1)
+    s = delta / (l < 0.5 ? max + min : 510 - max - min);
+  let h = 0;
+  if (delta > 0) {
+    if (max === r) {
+      h = (g - b) / delta;
+    } else if (max === g) {
+      h = 2 + (b - r) / delta;
+    } else {
+      h = 4 + (r - g) / delta;
+    }
+    h *= 60;
+    if (h < 0)
+      h += 360;
+  }
+  return { h, s, l };
+}
+
+// src/conversion/xyz2lab.ts
+var refX = 0.95047;
+var refY = 1;
+var refZ = 1.08883;
+function pivot(n) {
+  return n > 8856e-6 ? n ** (1 / 3) : 7.787 * n + 16 / 116;
+}
+function xyz2lab(x2, y2, z) {
+  x2 = pivot(x2 / refX);
+  y2 = pivot(y2 / refY);
+  z = pivot(z / refZ);
+  if (116 * y2 - 16 < 0)
+    throw new Error("xxx");
+  return {
+    L: Math.max(0, 116 * y2 - 16),
+    a: 500 * (x2 - y2),
+    b: 200 * (y2 - z)
+  };
+}
+
+// src/conversion/rgb2lab.ts
+function rgb2lab(r, g, b) {
+  const xyz = rgb2xyz(r, g, b);
+  return xyz2lab(xyz.x, xyz.y, xyz.z);
+}
+
+// src/conversion/lab2xyz.ts
+var refX2 = 0.95047;
+var refY2 = 1;
+var refZ2 = 1.08883;
+function pivot2(n) {
+  return n > 0.206893034 ? n ** 3 : (n - 16 / 116) / 7.787;
+}
+function lab2xyz(L, a, b) {
+  const y2 = (L + 16) / 116;
+  const x2 = a / 500 + y2;
+  const z = y2 - b / 200;
+  return {
+    x: refX2 * pivot2(x2),
+    y: refY2 * pivot2(y2),
+    z: refZ2 * pivot2(z)
+  };
+}
+
+// src/conversion/xyz2rgb.ts
+function correctGamma2(n) {
+  return n > 31308e-7 ? 1.055 * n ** (1 / 2.4) - 0.055 : 12.92 * n;
+}
+function xyz2rgb(x2, y2, z) {
+  const r = correctGamma2(x2 * 3.2406 + y2 * -1.5372 + z * -0.4986);
+  const g = correctGamma2(x2 * -0.9689 + y2 * 1.8758 + z * 0.0415);
+  const b = correctGamma2(x2 * 0.0557 + y2 * -0.204 + z * 1.057);
+  return {
+    r: inRange0to255Rounded(r * 255),
+    g: inRange0to255Rounded(g * 255),
+    b: inRange0to255Rounded(b * 255)
+  };
+}
+
+// src/conversion/lab2rgb.ts
+function lab2rgb(L, a, b) {
+  const xyz = lab2xyz(L, a, b);
+  return xyz2rgb(xyz.x, xyz.y, xyz.z);
+}
+
+// src/distance/index.ts
+var distance_exports = {};
+__export(distance_exports, {
+  AbstractDistanceCalculator: () => AbstractDistanceCalculator,
+  AbstractEuclidean: () => AbstractEuclidean,
+  AbstractManhattan: () => AbstractManhattan,
+  CIE94GraphicArts: () => CIE94GraphicArts,
+  CIE94Textiles: () => CIE94Textiles,
+  CIEDE2000: () => CIEDE2000,
+  CMetric: () => CMetric,
+  Euclidean: () => Euclidean,
+  EuclideanBT709: () => EuclideanBT709,
+  EuclideanBT709NoAlpha: () => EuclideanBT709NoAlpha,
+  Manhattan: () => Manhattan,
+  ManhattanBT709: () => ManhattanBT709,
+  ManhattanNommyde: () => ManhattanNommyde,
+  PNGQuant: () => PNGQuant
+});
+
+// src/distance/distanceCalculator.ts
+var AbstractDistanceCalculator = class {
+  constructor() {
+    __publicField(this, "_maxDistance");
+    __publicField(this, "_whitePoint");
+    this._setDefaults();
+    this.setWhitePoint(255, 255, 255, 255);
+  }
+  setWhitePoint(r, g, b, a) {
+    this._whitePoint = {
+      r: r > 0 ? 255 / r : 0,
+      g: g > 0 ? 255 / g : 0,
+      b: b > 0 ? 255 / b : 0,
+      a: a > 0 ? 255 / a : 0
+    };
+    this._maxDistance = this.calculateRaw(r, g, b, a, 0, 0, 0, 0);
+  }
+  calculateNormalized(colorA, colorB) {
+    return this.calculateRaw(colorA.r, colorA.g, colorA.b, colorA.a, colorB.r, colorB.g, colorB.b, colorB.a) / this._maxDistance;
+  }
+};
+
+// src/distance/cie94.ts
+var AbstractCIE94 = class extends AbstractDistanceCalculator {
+  calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
+    const lab1 = rgb2lab(inRange0to255(r1 * this._whitePoint.r), inRange0to255(g1 * this._whitePoint.g), inRange0to255(b1 * this._whitePoint.b));
+    const lab2 = rgb2lab(inRange0to255(r2 * this._whitePoint.r), inRange0to255(g2 * this._whitePoint.g), inRange0to255(b2 * this._whitePoint.b));
+    const dL = lab1.L - lab2.L;
+    const dA = lab1.a - lab2.a;
+    const dB = lab1.b - lab2.b;
+    const c1 = Math.sqrt(lab1.a * lab1.a + lab1.b * lab1.b);
+    const c2 = Math.sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
+    const dC = c1 - c2;
+    let deltaH = dA * dA + dB * dB - dC * dC;
+    deltaH = deltaH < 0 ? 0 : Math.sqrt(deltaH);
+    const dAlpha = (a2 - a1) * this._whitePoint.a * this._kA;
+    return Math.sqrt((dL / this._Kl) ** 2 + (dC / (1 + this._K1 * c1)) ** 2 + (deltaH / (1 + this._K2 * c1)) ** 2 + dAlpha ** 2);
+  }
+};
+var CIE94Textiles = class extends AbstractCIE94 {
+  _setDefaults() {
+    this._Kl = 2;
+    this._K1 = 0.048;
+    this._K2 = 0.014;
+    this._kA = 0.25 * 50 / 255;
+  }
+};
+var CIE94GraphicArts = class extends AbstractCIE94 {
+  _setDefaults() {
+    this._Kl = 1;
+    this._K1 = 0.045;
+    this._K2 = 0.015;
+    this._kA = 0.25 * 100 / 255;
+  }
+};
+
+// src/distance/ciede2000.ts
+var _CIEDE2000 = class extends AbstractDistanceCalculator {
+  _setDefaults() {
+  }
+  static _calculatehp(b, ap) {
+    const hp = Math.atan2(b, ap);
+    if (hp >= 0)
+      return hp;
+    return hp + _CIEDE2000._deg360InRad;
+  }
+  static _calculateRT(ahp, aCp) {
+    const aCp_to_7 = aCp ** 7;
+    const R_C = 2 * Math.sqrt(aCp_to_7 / (aCp_to_7 + _CIEDE2000._pow25to7));
+    const delta_theta = _CIEDE2000._deg30InRad * Math.exp(-(((ahp - _CIEDE2000._deg275InRad) / _CIEDE2000._deg25InRad) ** 2));
+    return -Math.sin(2 * delta_theta) * R_C;
+  }
+  static _calculateT(ahp) {
+    return 1 - 0.17 * Math.cos(ahp - _CIEDE2000._deg30InRad) + 0.24 * Math.cos(ahp * 2) + 0.32 * Math.cos(ahp * 3 + _CIEDE2000._deg6InRad) - 0.2 * Math.cos(ahp * 4 - _CIEDE2000._deg63InRad);
+  }
+  static _calculate_ahp(C1pC2p, h_bar, h1p, h2p) {
+    const hpSum = h1p + h2p;
+    if (C1pC2p === 0)
+      return hpSum;
+    if (h_bar <= _CIEDE2000._deg180InRad)
+      return hpSum / 2;
+    if (hpSum < _CIEDE2000._deg360InRad) {
+      return (hpSum + _CIEDE2000._deg360InRad) / 2;
+    }
+    return (hpSum - _CIEDE2000._deg360InRad) / 2;
+  }
+  static _calculate_dHp(C1pC2p, h_bar, h2p, h1p) {
+    let dhp;
+    if (C1pC2p === 0) {
+      dhp = 0;
+    } else if (h_bar <= _CIEDE2000._deg180InRad) {
+      dhp = h2p - h1p;
+    } else if (h2p <= h1p) {
+      dhp = h2p - h1p + _CIEDE2000._deg360InRad;
+    } else {
+      dhp = h2p - h1p - _CIEDE2000._deg360InRad;
+    }
+    return 2 * Math.sqrt(C1pC2p) * Math.sin(dhp / 2);
+  }
+  calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
+    const lab1 = rgb2lab(inRange0to255(r1 * this._whitePoint.r), inRange0to255(g1 * this._whitePoint.g), inRange0to255(b1 * this._whitePoint.b));
+    const lab2 = rgb2lab(inRange0to255(r2 * this._whitePoint.r), inRange0to255(g2 * this._whitePoint.g), inRange0to255(b2 * this._whitePoint.b));
+    const dA = (a2 - a1) * this._whitePoint.a * _CIEDE2000._kA;
+    const dE2 = this.calculateRawInLab(lab1, lab2);
+    return Math.sqrt(dE2 + dA * dA);
+  }
+  calculateRawInLab(Lab1, Lab2) {
+    const L1 = Lab1.L;
+    const a1 = Lab1.a;
+    const b1 = Lab1.b;
+    const L2 = Lab2.L;
+    const a2 = Lab2.a;
+    const b2 = Lab2.b;
+    const C1 = Math.sqrt(a1 * a1 + b1 * b1);
+    const C2 = Math.sqrt(a2 * a2 + b2 * b2);
+    const pow_a_C1_C2_to_7 = ((C1 + C2) / 2) ** 7;
+    const G = 0.5 * (1 - Math.sqrt(pow_a_C1_C2_to_7 / (pow_a_C1_C2_to_7 + _CIEDE2000._pow25to7)));
+    const a1p = (1 + G) * a1;
+    const a2p = (1 + G) * a2;
+    const C1p = Math.sqrt(a1p * a1p + b1 * b1);
+    const C2p = Math.sqrt(a2p * a2p + b2 * b2);
+    const C1pC2p = C1p * C2p;
+    const h1p = _CIEDE2000._calculatehp(b1, a1p);
+    const h2p = _CIEDE2000._calculatehp(b2, a2p);
+    const h_bar = Math.abs(h1p - h2p);
+    const dLp = L2 - L1;
+    const dCp = C2p - C1p;
+    const dHp = _CIEDE2000._calculate_dHp(C1pC2p, h_bar, h2p, h1p);
+    const ahp = _CIEDE2000._calculate_ahp(C1pC2p, h_bar, h1p, h2p);
+    const T = _CIEDE2000._calculateT(ahp);
+    const aCp = (C1p + C2p) / 2;
+    const aLp_minus_50_square = ((L1 + L2) / 2 - 50) ** 2;
+    const S_L = 1 + 0.015 * aLp_minus_50_square / Math.sqrt(20 + aLp_minus_50_square);
+    const S_C = 1 + 0.045 * aCp;
+    const S_H = 1 + 0.015 * T * aCp;
+    const R_T = _CIEDE2000._calculateRT(ahp, aCp);
+    const dLpSL = dLp / S_L;
+    const dCpSC = dCp / S_C;
+    const dHpSH = dHp / S_H;
+    return dLpSL ** 2 + dCpSC ** 2 + dHpSH ** 2 + R_T * dCpSC * dHpSH;
+  }
+};
+var CIEDE2000 = _CIEDE2000;
+__publicField(CIEDE2000, "_kA", 0.25 * 100 / 255);
+__publicField(CIEDE2000, "_pow25to7", 25 ** 7);
+__publicField(CIEDE2000, "_deg360InRad", degrees2radians(360));
+__publicField(CIEDE2000, "_deg180InRad", degrees2radians(180));
+__publicField(CIEDE2000, "_deg30InRad", degrees2radians(30));
+__publicField(CIEDE2000, "_deg6InRad", degrees2radians(6));
+__publicField(CIEDE2000, "_deg63InRad", degrees2radians(63));
+__publicField(CIEDE2000, "_deg275InRad", degrees2radians(275));
+__publicField(CIEDE2000, "_deg25InRad", degrees2radians(25));
+
+// src/distance/cmetric.ts
+var CMetric = class extends AbstractDistanceCalculator {
+  calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
+    const rmean = (r1 + r2) / 2 * this._whitePoint.r;
+    const r = (r1 - r2) * this._whitePoint.r;
+    const g = (g1 - g2) * this._whitePoint.g;
+    const b = (b1 - b2) * this._whitePoint.b;
+    const dE = ((512 + rmean) * r * r >> 8) + 4 * g * g + ((767 - rmean) * b * b >> 8);
+    const dA = (a2 - a1) * this._whitePoint.a;
+    return Math.sqrt(dE + dA * dA);
+  }
+  _setDefaults() {
+  }
+};
+
+// src/distance/euclidean.ts
+var AbstractEuclidean = class extends AbstractDistanceCalculator {
+  calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
+    const dR = r2 - r1;
+    const dG = g2 - g1;
+    const dB = b2 - b1;
+    const dA = a2 - a1;
+    return Math.sqrt(this._kR * dR * dR + this._kG * dG * dG + this._kB * dB * dB + this._kA * dA * dA);
+  }
+};
+var Euclidean = class extends AbstractEuclidean {
+  _setDefaults() {
+    this._kR = 1;
+    this._kG = 1;
+    this._kB = 1;
+    this._kA = 1;
+  }
+};
+var EuclideanBT709 = class extends AbstractEuclidean {
+  _setDefaults() {
+    this._kR = 0.2126 /* RED */;
+    this._kG = 0.7152 /* GREEN */;
+    this._kB = 0.0722 /* BLUE */;
+    this._kA = 1;
+  }
+};
+var EuclideanBT709NoAlpha = class extends AbstractEuclidean {
+  _setDefaults() {
+    this._kR = 0.2126 /* RED */;
+    this._kG = 0.7152 /* GREEN */;
+    this._kB = 0.0722 /* BLUE */;
+    this._kA = 0;
+  }
+};
+
+// src/distance/manhattan.ts
+var AbstractManhattan = class extends AbstractDistanceCalculator {
+  calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
+    let dR = r2 - r1;
+    let dG = g2 - g1;
+    let dB = b2 - b1;
+    let dA = a2 - a1;
+    if (dR < 0)
+      dR = 0 - dR;
+    if (dG < 0)
+      dG = 0 - dG;
+    if (dB < 0)
+      dB = 0 - dB;
+    if (dA < 0)
+      dA = 0 - dA;
+    return this._kR * dR + this._kG * dG + this._kB * dB + this._kA * dA;
+  }
+};
+var Manhattan = class extends AbstractManhattan {
+  _setDefaults() {
+    this._kR = 1;
+    this._kG = 1;
+    this._kB = 1;
+    this._kA = 1;
+  }
+};
+var ManhattanNommyde = class extends AbstractManhattan {
+  _setDefaults() {
+    this._kR = 0.4984;
+    this._kG = 0.8625;
+    this._kB = 0.2979;
+    this._kA = 1;
+  }
+};
+var ManhattanBT709 = class extends AbstractManhattan {
+  _setDefaults() {
+    this._kR = 0.2126 /* RED */;
+    this._kG = 0.7152 /* GREEN */;
+    this._kB = 0.0722 /* BLUE */;
+    this._kA = 1;
+  }
+};
+
+// src/distance/pngQuant.ts
+var PNGQuant = class extends AbstractDistanceCalculator {
+  calculateRaw(r1, g1, b1, a1, r2, g2, b2, a2) {
+    const alphas = (a2 - a1) * this._whitePoint.a;
+    return this._colordifferenceCh(r1 * this._whitePoint.r, r2 * this._whitePoint.r, alphas) + this._colordifferenceCh(g1 * this._whitePoint.g, g2 * this._whitePoint.g, alphas) + this._colordifferenceCh(b1 * this._whitePoint.b, b2 * this._whitePoint.b, alphas);
+  }
+  _colordifferenceCh(x2, y2, alphas) {
+    const black = x2 - y2;
+    const white = black + alphas;
+    return black * black + white * white;
+  }
+  _setDefaults() {
+  }
+};
+
+// src/palette/index.ts
+var palette_exports = {};
+__export(palette_exports, {
+  AbstractPaletteQuantizer: () => AbstractPaletteQuantizer,
+  ColorHistogram: () => ColorHistogram,
+  NeuQuant: () => NeuQuant,
+  NeuQuantFloat: () => NeuQuantFloat,
+  RGBQuant: () => RGBQuant,
+  WuColorCube: () => WuColorCube,
+  WuQuant: () => WuQuant
+});
+
+// src/palette/paletteQuantizer.ts
+var AbstractPaletteQuantizer = class {
+  quantizeSync() {
+    for (const value of this.quantize()) {
+      if (value.palette) {
+        return value.palette;
+      }
+    }
+    throw new Error("unreachable");
+  }
+};
+
+// src/utils/point.ts
+var Point = class {
+  constructor() {
+    __publicField(this, "r");
+    __publicField(this, "g");
+    __publicField(this, "b");
+    __publicField(this, "a");
+    __publicField(this, "uint32");
+    __publicField(this, "rgba");
+    this.uint32 = -1 >>> 0;
+    this.r = this.g = this.b = this.a = 0;
+    this.rgba = new Array(4);
+    this.rgba[0] = 0;
+    this.rgba[1] = 0;
+    this.rgba[2] = 0;
+    this.rgba[3] = 0;
+  }
+  static createByQuadruplet(quadruplet) {
+    const point = new Point();
+    point.r = quadruplet[0] | 0;
+    point.g = quadruplet[1] | 0;
+    point.b = quadruplet[2] | 0;
+    point.a = quadruplet[3] | 0;
+    point._loadUINT32();
+    point._loadQuadruplet();
+    return point;
+  }
+  static createByRGBA(red, green, blue, alpha) {
+    const point = new Point();
+    point.r = red | 0;
+    point.g = green | 0;
+    point.b = blue | 0;
+    point.a = alpha | 0;
+    point._loadUINT32();
+    point._loadQuadruplet();
+    return point;
+  }
+  static createByUint32(uint32) {
+    const point = new Point();
+    point.uint32 = uint32 >>> 0;
+    point._loadRGBA();
+    point._loadQuadruplet();
+    return point;
+  }
+  from(point) {
+    this.r = point.r;
+    this.g = point.g;
+    this.b = point.b;
+    this.a = point.a;
+    this.uint32 = point.uint32;
+    this.rgba[0] = point.r;
+    this.rgba[1] = point.g;
+    this.rgba[2] = point.b;
+    this.rgba[3] = point.a;
+  }
+  getLuminosity(useAlphaChannel) {
+    let r = this.r;
+    let g = this.g;
+    let b = this.b;
+    if (useAlphaChannel) {
+      r = Math.min(255, 255 - this.a + this.a * r / 255);
+      g = Math.min(255, 255 - this.a + this.a * g / 255);
+      b = Math.min(255, 255 - this.a + this.a * b / 255);
+    }
+    return r * 0.2126 /* RED */ + g * 0.7152 /* GREEN */ + b * 0.0722 /* BLUE */;
+  }
+  _loadUINT32() {
+    this.uint32 = (this.a << 24 | this.b << 16 | this.g << 8 | this.r) >>> 0;
+  }
+  _loadRGBA() {
+    this.r = this.uint32 & 255;
+    this.g = this.uint32 >>> 8 & 255;
+    this.b = this.uint32 >>> 16 & 255;
+    this.a = this.uint32 >>> 24 & 255;
+  }
+  _loadQuadruplet() {
+    this.rgba[0] = this.r;
+    this.rgba[1] = this.g;
+    this.rgba[2] = this.b;
+    this.rgba[3] = this.a;
+  }
+};
+
+// src/utils/pointContainer.ts
+var PointContainer = class {
+  constructor() {
+    __publicField(this, "_pointArray");
+    __publicField(this, "_width");
+    __publicField(this, "_height");
+    this._width = 0;
+    this._height = 0;
+    this._pointArray = [];
+  }
+  getWidth() {
+    return this._width;
+  }
+  getHeight() {
+    return this._height;
+  }
+  setWidth(width) {
+    this._width = width;
+  }
+  setHeight(height) {
+    this._height = height;
+  }
+  getPointArray() {
+    return this._pointArray;
+  }
+  clone() {
+    const clone = new PointContainer();
+    clone._width = this._width;
+    clone._height = this._height;
+    for (let i = 0, l = this._pointArray.length; i < l; i++) {
+      clone._pointArray[i] = Point.createByUint32(this._pointArray[i].uint32 | 0);
+    }
+    return clone;
+  }
+  toUint32Array() {
+    const l = this._pointArray.length;
+    const uint32Array = new Uint32Array(l);
+    for (let i = 0; i < l; i++) {
+      uint32Array[i] = this._pointArray[i].uint32;
+    }
+    return uint32Array;
+  }
+  toUint8Array() {
+    return new Uint8Array(this.toUint32Array().buffer);
+  }
+  static fromHTMLImageElement(img) {
+    const width = img.naturalWidth;
+    const height = img.naturalHeight;
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0, width, height, 0, 0, width, height);
+    return PointContainer.fromHTMLCanvasElement(canvas);
+  }
+  static fromHTMLCanvasElement(canvas) {
+    const width = canvas.width;
+    const height = canvas.height;
+    const ctx = canvas.getContext("2d");
+    const imgData = ctx.getImageData(0, 0, width, height);
+    return PointContainer.fromImageData(imgData);
+  }
+  static fromImageData(imageData) {
+    const width = imageData.width;
+    const height = imageData.height;
+    return PointContainer.fromUint8Array(imageData.data, width, height);
+  }
+  static fromUint8Array(uint8Array, width, height) {
+    switch (Object.prototype.toString.call(uint8Array)) {
+      case "[object Uint8ClampedArray]":
+      case "[object Uint8Array]":
+        break;
+      default:
+        uint8Array = new Uint8Array(uint8Array);
+    }
+    const uint32Array = new Uint32Array(uint8Array.buffer);
+    return PointContainer.fromUint32Array(uint32Array, width, height);
+  }
+  static fromUint32Array(uint32Array, width, height) {
+    const container = new PointContainer();
+    container._width = width;
+    container._height = height;
+    for (let i = 0, l = uint32Array.length; i < l; i++) {
+      container._pointArray[i] = Point.createByUint32(uint32Array[i] | 0);
+    }
+    return container;
+  }
+  static fromBuffer(buffer, width, height) {
+    const uint32Array = new Uint32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Uint32Array.BYTES_PER_ELEMENT);
+    return PointContainer.fromUint32Array(uint32Array, width, height);
+  }
+};
+
+// src/utils/palette.ts
+var hueGroups = 10;
+function hueGroup(hue, segmentsNumber) {
+  const maxHue = 360;
+  const seg = maxHue / segmentsNumber;
+  const half = seg / 2;
+  for (let i = 1, mid = seg - half; i < segmentsNumber; i++, mid += seg) {
+    if (hue >= mid && hue < mid + seg)
+      return i;
+  }
+  return 0;
+}
+var Palette = class {
+  constructor() {
+    __publicField(this, "_pointContainer");
+    __publicField(this, "_pointArray", []);
+    __publicField(this, "_i32idx", {});
+    this._pointContainer = new PointContainer();
+    this._pointContainer.setHeight(1);
+    this._pointArray = this._pointContainer.getPointArray();
+  }
+  add(color) {
+    this._pointArray.push(color);
+    this._pointContainer.setWidth(this._pointArray.length);
+  }
+  has(color) {
+    for (let i = this._pointArray.length - 1; i >= 0; i--) {
+      if (color.uint32 === this._pointArray[i].uint32)
+        return true;
+    }
+    return false;
+  }
+  getNearestColor(colorDistanceCalculator, color) {
+    return this._pointArray[this._getNearestIndex(colorDistanceCalculator, color) | 0];
+  }
+  getPointContainer() {
+    return this._pointContainer;
+  }
+  _nearestPointFromCache(key) {
+    return typeof this._i32idx[key] === "number" ? this._i32idx[key] : -1;
+  }
+  _getNearestIndex(colorDistanceCalculator, point) {
+    let idx = this._nearestPointFromCache("" + point.uint32);
+    if (idx >= 0)
+      return idx;
+    let minimalDistance = Number.MAX_VALUE;
+    idx = 0;
+    for (let i = 0, l = this._pointArray.length; i < l; i++) {
+      const p = this._pointArray[i];
+      const distance = colorDistanceCalculator.calculateRaw(point.r, point.g, point.b, point.a, p.r, p.g, p.b, p.a);
+      if (distance < minimalDistance) {
+        minimalDistance = distance;
+        idx = i;
+      }
+    }
+    this._i32idx[point.uint32] = idx;
+    return idx;
+  }
+  sort() {
+    this._i32idx = {};
+    this._pointArray.sort((a, b) => {
+      const hslA = rgb2hsl(a.r, a.g, a.b);
+      const hslB = rgb2hsl(b.r, b.g, b.b);
+      const hueA = a.r === a.g && a.g === a.b ? 0 : 1 + hueGroup(hslA.h, hueGroups);
+      const hueB = b.r === b.g && b.g === b.b ? 0 : 1 + hueGroup(hslB.h, hueGroups);
+      const hueDiff = hueB - hueA;
+      if (hueDiff)
+        return -hueDiff;
+      const lA = a.getLuminosity(true);
+      const lB = b.getLuminosity(true);
+      if (lB - lA !== 0)
+        return lB - lA;
+      const satDiff = (hslB.s * 100 | 0) - (hslA.s * 100 | 0);
+      if (satDiff)
+        return -satDiff;
+      return 0;
+    });
+  }
+};
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  HueStatistics: () => HueStatistics,
+  Palette: () => Palette,
+  Point: () => Point,
+  PointContainer: () => PointContainer,
+  ProgressTracker: () => ProgressTracker,
+  arithmetic: () => arithmetic_exports
+});
+
+// src/utils/hueStatistics.ts
+var HueGroup = class {
+  constructor() {
+    __publicField(this, "num", 0);
+    __publicField(this, "cols", []);
+  }
+};
+var HueStatistics = class {
+  constructor(numGroups, minCols) {
+    __publicField(this, "_numGroups");
+    __publicField(this, "_minCols");
+    __publicField(this, "_stats");
+    __publicField(this, "_groupsFull");
+    this._numGroups = numGroups;
+    this._minCols = minCols;
+    this._stats = [];
+    for (let i = 0; i <= numGroups; i++) {
+      this._stats[i] = new HueGroup();
+    }
+    this._groupsFull = 0;
+  }
+  check(i32) {
+    if (this._groupsFull === this._numGroups + 1) {
+      this.check = () => {
+      };
+    }
+    const r = i32 & 255;
+    const g = i32 >>> 8 & 255;
+    const b = i32 >>> 16 & 255;
+    const hg = r === g && g === b ? 0 : 1 + hueGroup(rgb2hsl(r, g, b).h, this._numGroups);
+    const gr = this._stats[hg];
+    const min = this._minCols;
+    gr.num++;
+    if (gr.num > min) {
+      return;
+    }
+    if (gr.num === min) {
+      this._groupsFull++;
+    }
+    if (gr.num <= min) {
+      this._stats[hg].cols.push(i32);
+    }
+  }
+  injectIntoDictionary(histG) {
+    for (let i = 0; i <= this._numGroups; i++) {
+      if (this._stats[i].num <= this._minCols) {
+        this._stats[i].cols.forEach((col) => {
+          if (!histG[col]) {
+            histG[col] = 1;
+          } else {
+            histG[col]++;
+          }
+        });
+      }
+    }
+  }
+  injectIntoArray(histG) {
+    for (let i = 0; i <= this._numGroups; i++) {
+      if (this._stats[i].num <= this._minCols) {
+        this._stats[i].cols.forEach((col) => {
+          if (histG.indexOf(col) === -1) {
+            histG.push(col);
+          }
+        });
+      }
+    }
+  }
+};
+
+// src/utils/progressTracker.ts
+var _ProgressTracker = class {
+  constructor(valueRange, progressRange) {
+    __publicField(this, "progress");
+    __publicField(this, "_step");
+    __publicField(this, "_range");
+    __publicField(this, "_last");
+    __publicField(this, "_progressRange");
+    this._range = valueRange;
+    this._progressRange = progressRange;
+    this._step = Math.max(1, this._range / (_ProgressTracker.steps + 1) | 0);
+    this._last = -this._step;
+    this.progress = 0;
+  }
+  shouldNotify(current) {
+    if (current - this._last >= this._step) {
+      this._last = current;
+      this.progress = Math.min(this._progressRange * this._last / this._range, this._progressRange);
+      return true;
+    }
+    return false;
+  }
+};
+var ProgressTracker = _ProgressTracker;
+__publicField(ProgressTracker, "steps", 100);
+
+// src/palette/neuquant/neuquant.ts
+var networkBiasShift = 3;
+var Neuron = class {
+  constructor(defaultValue) {
+    __publicField(this, "r");
+    __publicField(this, "g");
+    __publicField(this, "b");
+    __publicField(this, "a");
+    this.r = this.g = this.b = this.a = defaultValue;
+  }
+  toPoint() {
+    return Point.createByRGBA(this.r >> networkBiasShift, this.g >> networkBiasShift, this.b >> networkBiasShift, this.a >> networkBiasShift);
+  }
+  subtract(r, g, b, a) {
+    this.r -= r | 0;
+    this.g -= g | 0;
+    this.b -= b | 0;
+    this.a -= a | 0;
+  }
+};
+var _NeuQuant = class extends AbstractPaletteQuantizer {
+  constructor(colorDistanceCalculator, colors = 256) {
+    super();
+    __publicField(this, "_pointArray");
+    __publicField(this, "_networkSize");
+    __publicField(this, "_network");
+    __publicField(this, "_sampleFactor");
+    __publicField(this, "_radPower");
+    __publicField(this, "_freq");
+    __publicField(this, "_bias");
+    __publicField(this, "_distance");
+    this._distance = colorDistanceCalculator;
+    this._pointArray = [];
+    this._sampleFactor = 1;
+    this._networkSize = colors;
+    this._distance.setWhitePoint(255 << networkBiasShift, 255 << networkBiasShift, 255 << networkBiasShift, 255 << networkBiasShift);
+  }
+  sample(pointContainer) {
+    this._pointArray = this._pointArray.concat(pointContainer.getPointArray());
+  }
+  *quantize() {
+    this._init();
+    yield* this._learn();
+    yield {
+      palette: this._buildPalette(),
+      progress: 100
+    };
+  }
+  _init() {
+    this._freq = [];
+    this._bias = [];
+    this._radPower = [];
+    this._network = [];
+    for (let i = 0; i < this._networkSize; i++) {
+      this._network[i] = new Neuron((i << networkBiasShift + 8) / this._networkSize | 0);
+      this._freq[i] = _NeuQuant._initialBias / this._networkSize | 0;
+      this._bias[i] = 0;
+    }
+  }
+  *_learn() {
+    let sampleFactor = this._sampleFactor;
+    const pointsNumber = this._pointArray.length;
+    if (pointsNumber < _NeuQuant._minpicturebytes)
+      sampleFactor = 1;
+    const alphadec = 30 + (sampleFactor - 1) / 3 | 0;
+    const pointsToSample = pointsNumber / sampleFactor | 0;
+    let delta = pointsToSample / _NeuQuant._nCycles | 0;
+    let alpha = _NeuQuant._initAlpha;
+    let radius = (this._networkSize >> 3) * _NeuQuant._radiusBias;
+    let rad = radius >> _NeuQuant._radiusBiasShift;
+    if (rad <= 1)
+      rad = 0;
+    for (let i = 0; i < rad; i++) {
+      this._radPower[i] = alpha * ((rad * rad - i * i) * _NeuQuant._radBias / (rad * rad)) >>> 0;
+    }
+    let step;
+    if (pointsNumber < _NeuQuant._minpicturebytes) {
+      step = 1;
+    } else if (pointsNumber % _NeuQuant._prime1 !== 0) {
+      step = _NeuQuant._prime1;
+    } else if (pointsNumber % _NeuQuant._prime2 !== 0) {
+      step = _NeuQuant._prime2;
+    } else if (pointsNumber % _NeuQuant._prime3 !== 0) {
+      step = _NeuQuant._prime3;
+    } else {
+      step = _NeuQuant._prime4;
+    }
+    const tracker = new ProgressTracker(pointsToSample, 99);
+    for (let i = 0, pointIndex = 0; i < pointsToSample; ) {
+      if (tracker.shouldNotify(i)) {
+        yield {
+          progress: tracker.progress
+        };
+      }
+      const point = this._pointArray[pointIndex];
+      const b = point.b << networkBiasShift;
+      const g = point.g << networkBiasShift;
+      const r = point.r << networkBiasShift;
+      const a = point.a << networkBiasShift;
+      const neuronIndex = this._contest(b, g, r, a);
+      this._alterSingle(alpha, neuronIndex, b, g, r, a);
+      if (rad !== 0)
+        this._alterNeighbour(rad, neuronIndex, b, g, r, a);
+      pointIndex += step;
+      if (pointIndex >= pointsNumber)
+        pointIndex -= pointsNumber;
+      i++;
+      if (delta === 0)
+        delta = 1;
+      if (i % delta === 0) {
+        alpha -= alpha / alphadec | 0;
+        radius -= radius / _NeuQuant._radiusDecrease | 0;
+        rad = radius >> _NeuQuant._radiusBiasShift;
+        if (rad <= 1)
+          rad = 0;
+        for (let j = 0; j < rad; j++) {
+          this._radPower[j] = alpha * ((rad * rad - j * j) * _NeuQuant._radBias / (rad * rad)) >>> 0;
+        }
+      }
+    }
+  }
+  _buildPalette() {
+    const palette = new Palette();
+    this._network.forEach((neuron) => {
+      palette.add(neuron.toPoint());
+    });
+    palette.sort();
+    return palette;
+  }
+  _alterNeighbour(rad, i, b, g, r, al) {
+    let lo = i - rad;
+    if (lo < -1)
+      lo = -1;
+    let hi = i + rad;
+    if (hi > this._networkSize)
+      hi = this._networkSize;
+    let j = i + 1;
+    let k = i - 1;
+    let m = 1;
+    while (j < hi || k > lo) {
+      const a = this._radPower[m++] / _NeuQuant._alphaRadBias;
+      if (j < hi) {
+        const p = this._network[j++];
+        p.subtract(a * (p.r - r), a * (p.g - g), a * (p.b - b), a * (p.a - al));
+      }
+      if (k > lo) {
+        const p = this._network[k--];
+        p.subtract(a * (p.r - r), a * (p.g - g), a * (p.b - b), a * (p.a - al));
+      }
+    }
+  }
+  _alterSingle(alpha, i, b, g, r, a) {
+    alpha /= _NeuQuant._initAlpha;
+    const n = this._network[i];
+    n.subtract(alpha * (n.r - r), alpha * (n.g - g), alpha * (n.b - b), alpha * (n.a - a));
+  }
+  _contest(b, g, r, a) {
+    const multiplier = 255 * 4 << networkBiasShift;
+    let bestd = ~(1 << 31);
+    let bestbiasd = bestd;
+    let bestpos = -1;
+    let bestbiaspos = bestpos;
+    for (let i = 0; i < this._networkSize; i++) {
+      const n = this._network[i];
+      const dist = this._distance.calculateNormalized(n, { r, g, b, a }) * multiplier | 0;
+      if (dist < bestd) {
+        bestd = dist;
+        bestpos = i;
+      }
+      const biasdist = dist - (this._bias[i] >> _NeuQuant._initialBiasShift - networkBiasShift);
+      if (biasdist < bestbiasd) {
+        bestbiasd = biasdist;
+        bestbiaspos = i;
+      }
+      const betafreq = this._freq[i] >> _NeuQuant._betaShift;
+      this._freq[i] -= betafreq;
+      this._bias[i] += betafreq << _NeuQuant._gammaShift;
+    }
+    this._freq[bestpos] += _NeuQuant._beta;
+    this._bias[bestpos] -= _NeuQuant._betaGamma;
+    return bestbiaspos;
+  }
+};
+var NeuQuant = _NeuQuant;
+__publicField(NeuQuant, "_prime1", 499);
+__publicField(NeuQuant, "_prime2", 491);
+__publicField(NeuQuant, "_prime3", 487);
+__publicField(NeuQuant, "_prime4", 503);
+__publicField(NeuQuant, "_minpicturebytes", _NeuQuant._prime4);
+__publicField(NeuQuant, "_nCycles", 100);
+__publicField(NeuQuant, "_initialBiasShift", 16);
+__publicField(NeuQuant, "_initialBias", 1 << _NeuQuant._initialBiasShift);
+__publicField(NeuQuant, "_gammaShift", 10);
+__publicField(NeuQuant, "_betaShift", 10);
+__publicField(NeuQuant, "_beta", _NeuQuant._initialBias >> _NeuQuant._betaShift);
+__publicField(NeuQuant, "_betaGamma", _NeuQuant._initialBias << _NeuQuant._gammaShift - _NeuQuant._betaShift);
+__publicField(NeuQuant, "_radiusBiasShift", 6);
+__publicField(NeuQuant, "_radiusBias", 1 << _NeuQuant._radiusBiasShift);
+__publicField(NeuQuant, "_radiusDecrease", 30);
+__publicField(NeuQuant, "_alphaBiasShift", 10);
+__publicField(NeuQuant, "_initAlpha", 1 << _NeuQuant._alphaBiasShift);
+__publicField(NeuQuant, "_radBiasShift", 8);
+__publicField(NeuQuant, "_radBias", 1 << _NeuQuant._radBiasShift);
+__publicField(NeuQuant, "_alphaRadBiasShift", _NeuQuant._alphaBiasShift + _NeuQuant._radBiasShift);
+__publicField(NeuQuant, "_alphaRadBias", 1 << _NeuQuant._alphaRadBiasShift);
+
+// src/palette/neuquant/neuquantFloat.ts
+var networkBiasShift2 = 3;
+var NeuronFloat = class {
+  constructor(defaultValue) {
+    __publicField(this, "r");
+    __publicField(this, "g");
+    __publicField(this, "b");
+    __publicField(this, "a");
+    this.r = this.g = this.b = this.a = defaultValue;
+  }
+  toPoint() {
+    return Point.createByRGBA(this.r >> networkBiasShift2, this.g >> networkBiasShift2, this.b >> networkBiasShift2, this.a >> networkBiasShift2);
+  }
+  subtract(r, g, b, a) {
+    this.r -= r;
+    this.g -= g;
+    this.b -= b;
+    this.a -= a;
+  }
+};
+var _NeuQuantFloat = class extends AbstractPaletteQuantizer {
+  constructor(colorDistanceCalculator, colors = 256) {
+    super();
+    __publicField(this, "_pointArray");
+    __publicField(this, "_networkSize");
+    __publicField(this, "_network");
+    __publicField(this, "_sampleFactor");
+    __publicField(this, "_radPower");
+    __publicField(this, "_freq");
+    __publicField(this, "_bias");
+    __publicField(this, "_distance");
+    this._distance = colorDistanceCalculator;
+    this._pointArray = [];
+    this._sampleFactor = 1;
+    this._networkSize = colors;
+    this._distance.setWhitePoint(255 << networkBiasShift2, 255 << networkBiasShift2, 255 << networkBiasShift2, 255 << networkBiasShift2);
+  }
+  sample(pointContainer) {
+    this._pointArray = this._pointArray.concat(pointContainer.getPointArray());
+  }
+  *quantize() {
+    this._init();
+    yield* this._learn();
+    yield {
+      palette: this._buildPalette(),
+      progress: 100
+    };
+  }
+  _init() {
+    this._freq = [];
+    this._bias = [];
+    this._radPower = [];
+    this._network = [];
+    for (let i = 0; i < this._networkSize; i++) {
+      this._network[i] = new NeuronFloat((i << networkBiasShift2 + 8) / this._networkSize);
+      this._freq[i] = _NeuQuantFloat._initialBias / this._networkSize;
+      this._bias[i] = 0;
+    }
+  }
+  *_learn() {
+    let sampleFactor = this._sampleFactor;
+    const pointsNumber = this._pointArray.length;
+    if (pointsNumber < _NeuQuantFloat._minpicturebytes)
+      sampleFactor = 1;
+    const alphadec = 30 + (sampleFactor - 1) / 3;
+    const pointsToSample = pointsNumber / sampleFactor;
+    let delta = pointsToSample / _NeuQuantFloat._nCycles | 0;
+    let alpha = _NeuQuantFloat._initAlpha;
+    let radius = (this._networkSize >> 3) * _NeuQuantFloat._radiusBias;
+    let rad = radius >> _NeuQuantFloat._radiusBiasShift;
+    if (rad <= 1)
+      rad = 0;
+    for (let i = 0; i < rad; i++) {
+      this._radPower[i] = alpha * ((rad * rad - i * i) * _NeuQuantFloat._radBias / (rad * rad));
+    }
+    let step;
+    if (pointsNumber < _NeuQuantFloat._minpicturebytes) {
+      step = 1;
+    } else if (pointsNumber % _NeuQuantFloat._prime1 !== 0) {
+      step = _NeuQuantFloat._prime1;
+    } else if (pointsNumber % _NeuQuantFloat._prime2 !== 0) {
+      step = _NeuQuantFloat._prime2;
+    } else if (pointsNumber % _NeuQuantFloat._prime3 !== 0) {
+      step = _NeuQuantFloat._prime3;
+    } else {
+      step = _NeuQuantFloat._prime4;
+    }
+    const tracker = new ProgressTracker(pointsToSample, 99);
+    for (let i = 0, pointIndex = 0; i < pointsToSample; ) {
+      if (tracker.shouldNotify(i)) {
+        yield {
+          progress: tracker.progress
+        };
+      }
+      const point = this._pointArray[pointIndex];
+      const b = point.b << networkBiasShift2;
+      const g = point.g << networkBiasShift2;
+      const r = point.r << networkBiasShift2;
+      const a = point.a << networkBiasShift2;
+      const neuronIndex = this._contest(b, g, r, a);
+      this._alterSingle(alpha, neuronIndex, b, g, r, a);
+      if (rad !== 0)
+        this._alterNeighbour(rad, neuronIndex, b, g, r, a);
+      pointIndex += step;
+      if (pointIndex >= pointsNumber)
+        pointIndex -= pointsNumber;
+      i++;
+      if (delta === 0)
+        delta = 1;
+      if (i % delta === 0) {
+        alpha -= alpha / alphadec;
+        radius -= radius / _NeuQuantFloat._radiusDecrease;
+        rad = radius >> _NeuQuantFloat._radiusBiasShift;
+        if (rad <= 1)
+          rad = 0;
+        for (let j = 0; j < rad; j++) {
+          this._radPower[j] = alpha * ((rad * rad - j * j) * _NeuQuantFloat._radBias / (rad * rad));
+        }
+      }
+    }
+  }
+  _buildPalette() {
+    const palette = new Palette();
+    this._network.forEach((neuron) => {
+      palette.add(neuron.toPoint());
+    });
+    palette.sort();
+    return palette;
+  }
+  _alterNeighbour(rad, i, b, g, r, al) {
+    let lo = i - rad;
+    if (lo < -1)
+      lo = -1;
+    let hi = i + rad;
+    if (hi > this._networkSize)
+      hi = this._networkSize;
+    let j = i + 1;
+    let k = i - 1;
+    let m = 1;
+    while (j < hi || k > lo) {
+      const a = this._radPower[m++] / _NeuQuantFloat._alphaRadBias;
+      if (j < hi) {
+        const p = this._network[j++];
+        p.subtract(a * (p.r - r), a * (p.g - g), a * (p.b - b), a * (p.a - al));
+      }
+      if (k > lo) {
+        const p = this._network[k--];
+        p.subtract(a * (p.r - r), a * (p.g - g), a * (p.b - b), a * (p.a - al));
+      }
+    }
+  }
+  _alterSingle(alpha, i, b, g, r, a) {
+    alpha /= _NeuQuantFloat._initAlpha;
+    const n = this._network[i];
+    n.subtract(alpha * (n.r - r), alpha * (n.g - g), alpha * (n.b - b), alpha * (n.a - a));
+  }
+  _contest(b, g, r, al) {
+    const multiplier = 255 * 4 << networkBiasShift2;
+    let bestd = ~(1 << 31);
+    let bestbiasd = bestd;
+    let bestpos = -1;
+    let bestbiaspos = bestpos;
+    for (let i = 0; i < this._networkSize; i++) {
+      const n = this._network[i];
+      const dist = this._distance.calculateNormalized(n, { r, g, b, a: al }) * multiplier;
+      if (dist < bestd) {
+        bestd = dist;
+        bestpos = i;
+      }
+      const biasdist = dist - (this._bias[i] >> _NeuQuantFloat._initialBiasShift - networkBiasShift2);
+      if (biasdist < bestbiasd) {
+        bestbiasd = biasdist;
+        bestbiaspos = i;
+      }
+      const betafreq = this._freq[i] >> _NeuQuantFloat._betaShift;
+      this._freq[i] -= betafreq;
+      this._bias[i] += betafreq << _NeuQuantFloat._gammaShift;
+    }
+    this._freq[bestpos] += _NeuQuantFloat._beta;
+    this._bias[bestpos] -= _NeuQuantFloat._betaGamma;
+    return bestbiaspos;
+  }
+};
+var NeuQuantFloat = _NeuQuantFloat;
+__publicField(NeuQuantFloat, "_prime1", 499);
+__publicField(NeuQuantFloat, "_prime2", 491);
+__publicField(NeuQuantFloat, "_prime3", 487);
+__publicField(NeuQuantFloat, "_prime4", 503);
+__publicField(NeuQuantFloat, "_minpicturebytes", _NeuQuantFloat._prime4);
+__publicField(NeuQuantFloat, "_nCycles", 100);
+__publicField(NeuQuantFloat, "_initialBiasShift", 16);
+__publicField(NeuQuantFloat, "_initialBias", 1 << _NeuQuantFloat._initialBiasShift);
+__publicField(NeuQuantFloat, "_gammaShift", 10);
+__publicField(NeuQuantFloat, "_betaShift", 10);
+__publicField(NeuQuantFloat, "_beta", _NeuQuantFloat._initialBias >> _NeuQuantFloat._betaShift);
+__publicField(NeuQuantFloat, "_betaGamma", _NeuQuantFloat._initialBias << _NeuQuantFloat._gammaShift - _NeuQuantFloat._betaShift);
+__publicField(NeuQuantFloat, "_radiusBiasShift", 6);
+__publicField(NeuQuantFloat, "_radiusBias", 1 << _NeuQuantFloat._radiusBiasShift);
+__publicField(NeuQuantFloat, "_radiusDecrease", 30);
+__publicField(NeuQuantFloat, "_alphaBiasShift", 10);
+__publicField(NeuQuantFloat, "_initAlpha", 1 << _NeuQuantFloat._alphaBiasShift);
+__publicField(NeuQuantFloat, "_radBiasShift", 8);
+__publicField(NeuQuantFloat, "_radBias", 1 << _NeuQuantFloat._radBiasShift);
+__publicField(NeuQuantFloat, "_alphaRadBiasShift", _NeuQuantFloat._alphaBiasShift + _NeuQuantFloat._radBiasShift);
+__publicField(NeuQuantFloat, "_alphaRadBias", 1 << _NeuQuantFloat._alphaRadBiasShift);
+
+// src/palette/rgbquant/colorHistogram.ts
+var _ColorHistogram = class {
+  constructor(method, colors) {
+    __publicField(this, "_method");
+    __publicField(this, "_hueStats");
+    __publicField(this, "_histogram");
+    __publicField(this, "_initColors");
+    __publicField(this, "_minHueCols");
+    this._method = method;
+    this._minHueCols = colors << 2;
+    this._initColors = colors << 2;
+    this._hueStats = new HueStatistics(_ColorHistogram._hueGroups, this._minHueCols);
+    this._histogram = /* @__PURE__ */ Object.create(null);
+  }
+  sample(pointContainer) {
+    switch (this._method) {
+      case 1:
+        this._colorStats1D(pointContainer);
+        break;
+      case 2:
+        this._colorStats2D(pointContainer);
+        break;
+    }
+  }
+  getImportanceSortedColorsIDXI32() {
+    const sorted = stableSort(Object.keys(this._histogram), (a, b) => this._histogram[b] - this._histogram[a]);
+    if (sorted.length === 0) {
+      return [];
+    }
+    let idxi32;
+    switch (this._method) {
+      case 1:
+        const initialColorsLimit = Math.min(sorted.length, this._initColors);
+        const last = sorted[initialColorsLimit - 1];
+        const freq = this._histogram[last];
+        idxi32 = sorted.slice(0, initialColorsLimit);
+        let pos = initialColorsLimit;
+        const len = sorted.length;
+        while (pos < len && this._histogram[sorted[pos]] === freq) {
+          idxi32.push(sorted[pos++]);
+        }
+        this._hueStats.injectIntoArray(idxi32);
+        break;
+      case 2:
+        idxi32 = sorted;
+        break;
+      default:
+        throw new Error("Incorrect method");
+    }
+    return idxi32.map((v) => +v);
+  }
+  _colorStats1D(pointContainer) {
+    const histG = this._histogram;
+    const pointArray = pointContainer.getPointArray();
+    const len = pointArray.length;
+    for (let i = 0; i < len; i++) {
+      const col = pointArray[i].uint32;
+      this._hueStats.check(col);
+      if (col in histG) {
+        histG[col]++;
+      } else {
+        histG[col] = 1;
+      }
+    }
+  }
+  _colorStats2D(pointContainer) {
+    const width = pointContainer.getWidth();
+    const height = pointContainer.getHeight();
+    const pointArray = pointContainer.getPointArray();
+    const boxW = _ColorHistogram._boxSize[0];
+    const boxH = _ColorHistogram._boxSize[1];
+    const area = boxW * boxH;
+    const boxes = this._makeBoxes(width, height, boxW, boxH);
+    const histG = this._histogram;
+    boxes.forEach((box) => {
+      let effc = Math.round(box.w * box.h / area) * _ColorHistogram._boxPixels;
+      if (effc < 2)
+        effc = 2;
+      const histL = {};
+      this._iterateBox(box, width, (i) => {
+        const col = pointArray[i].uint32;
+        this._hueStats.check(col);
+        if (col in histG) {
+          histG[col]++;
+        } else if (col in histL) {
+          if (++histL[col] >= effc) {
+            histG[col] = histL[col];
+          }
+        } else {
+          histL[col] = 1;
+        }
+      });
+    });
+    this._hueStats.injectIntoDictionary(histG);
+  }
+  _iterateBox(bbox, wid, fn) {
+    const b = bbox;
+    const i0 = b.y * wid + b.x;
+    const i1 = (b.y + b.h - 1) * wid + (b.x + b.w - 1);
+    const incr = wid - b.w + 1;
+    let cnt = 0;
+    let i = i0;
+    do {
+      fn.call(this, i);
+      i += ++cnt % b.w === 0 ? incr : 1;
+    } while (i <= i1);
+  }
+  _makeBoxes(width, height, stepX, stepY) {
+    const wrem = width % stepX;
+    const hrem = height % stepY;
+    const xend = width - wrem;
+    const yend = height - hrem;
+    const boxesArray = [];
+    for (let y2 = 0; y2 < height; y2 += stepY) {
+      for (let x2 = 0; x2 < width; x2 += stepX) {
+        boxesArray.push({
+          x: x2,
+          y: y2,
+          w: x2 === xend ? wrem : stepX,
+          h: y2 === yend ? hrem : stepY
+        });
+      }
+    }
+    return boxesArray;
+  }
+};
+var ColorHistogram = _ColorHistogram;
+__publicField(ColorHistogram, "_boxSize", [64, 64]);
+__publicField(ColorHistogram, "_boxPixels", 2);
+__publicField(ColorHistogram, "_hueGroups", 10);
+
+// src/palette/rgbquant/rgbquant.ts
+var RemovedColor = class {
+  constructor(index, color, distance) {
+    __publicField(this, "index");
+    __publicField(this, "color");
+    __publicField(this, "distance");
+    this.index = index;
+    this.color = color;
+    this.distance = distance;
+  }
+};
+var RGBQuant = class extends AbstractPaletteQuantizer {
+  constructor(colorDistanceCalculator, colors = 256, method = 2) {
+    super();
+    __publicField(this, "_colors");
+    __publicField(this, "_initialDistance");
+    __publicField(this, "_distanceIncrement");
+    __publicField(this, "_histogram");
+    __publicField(this, "_distance");
+    this._distance = colorDistanceCalculator;
+    this._colors = colors;
+    this._histogram = new ColorHistogram(method, colors);
+    this._initialDistance = 0.01;
+    this._distanceIncrement = 5e-3;
+  }
+  sample(image) {
+    this._histogram.sample(image);
+  }
+  *quantize() {
+    const idxi32 = this._histogram.getImportanceSortedColorsIDXI32();
+    if (idxi32.length === 0) {
+      throw new Error("No colors in image");
+    }
+    yield* this._buildPalette(idxi32);
+  }
+  *_buildPalette(idxi32) {
+    const palette = new Palette();
+    const colorArray = palette.getPointContainer().getPointArray();
+    const usageArray = new Array(idxi32.length);
+    for (let i = 0; i < idxi32.length; i++) {
+      colorArray.push(Point.createByUint32(idxi32[i]));
+      usageArray[i] = 1;
+    }
+    const len = colorArray.length;
+    const memDist = [];
+    let palLen = len;
+    let thold = this._initialDistance;
+    const tracker = new ProgressTracker(palLen - this._colors, 99);
+    while (palLen > this._colors) {
+      memDist.length = 0;
+      for (let i = 0; i < len; i++) {
+        if (tracker.shouldNotify(len - palLen)) {
+          yield {
+            progress: tracker.progress
+          };
+        }
+        if (usageArray[i] === 0)
+          continue;
+        const pxi = colorArray[i];
+        for (let j = i + 1; j < len; j++) {
+          if (usageArray[j] === 0)
+            continue;
+          const pxj = colorArray[j];
+          const dist = this._distance.calculateNormalized(pxi, pxj);
+          if (dist < thold) {
+            memDist.push(new RemovedColor(j, pxj, dist));
+            usageArray[j] = 0;
+            palLen--;
+          }
+        }
+      }
+      thold += palLen > this._colors * 3 ? this._initialDistance : this._distanceIncrement;
+    }
+    if (palLen < this._colors) {
+      stableSort(memDist, (a, b) => b.distance - a.distance);
+      let k = 0;
+      while (palLen < this._colors && k < memDist.length) {
+        const removedColor = memDist[k];
+        usageArray[removedColor.index] = 1;
+        palLen++;
+        k++;
+      }
+    }
+    let colors = colorArray.length;
+    for (let colorIndex = colors - 1; colorIndex >= 0; colorIndex--) {
+      if (usageArray[colorIndex] === 0) {
+        if (colorIndex !== colors - 1) {
+          colorArray[colorIndex] = colorArray[colors - 1];
+        }
+        --colors;
+      }
+    }
+    colorArray.length = colors;
+    palette.sort();
+    yield {
+      palette,
+      progress: 100
+    };
+  }
+};
+
+// src/palette/wu/wuQuant.ts
+function createArray1D(dimension1) {
+  const a = [];
+  for (let k = 0; k < dimension1; k++) {
+    a[k] = 0;
+  }
+  return a;
+}
+function createArray4D(dimension1, dimension2, dimension3, dimension4) {
+  const a = new Array(dimension1);
+  for (let i = 0; i < dimension1; i++) {
+    a[i] = new Array(dimension2);
+    for (let j = 0; j < dimension2; j++) {
+      a[i][j] = new Array(dimension3);
+      for (let k = 0; k < dimension3; k++) {
+        a[i][j][k] = new Array(dimension4);
+        for (let l = 0; l < dimension4; l++) {
+          a[i][j][k][l] = 0;
+        }
+      }
+    }
+  }
+  return a;
+}
+function createArray3D(dimension1, dimension2, dimension3) {
+  const a = new Array(dimension1);
+  for (let i = 0; i < dimension1; i++) {
+    a[i] = new Array(dimension2);
+    for (let j = 0; j < dimension2; j++) {
+      a[i][j] = new Array(dimension3);
+      for (let k = 0; k < dimension3; k++) {
+        a[i][j][k] = 0;
+      }
+    }
+  }
+  return a;
+}
+function fillArray3D(a, dimension1, dimension2, dimension3, value) {
+  for (let i = 0; i < dimension1; i++) {
+    a[i] = [];
+    for (let j = 0; j < dimension2; j++) {
+      a[i][j] = [];
+      for (let k = 0; k < dimension3; k++) {
+        a[i][j][k] = value;
+      }
+    }
+  }
+}
+function fillArray1D(a, dimension1, value) {
+  for (let i = 0; i < dimension1; i++) {
+    a[i] = value;
+  }
+}
+var WuColorCube = class {
+  constructor() {
+    __publicField(this, "redMinimum");
+    __publicField(this, "redMaximum");
+    __publicField(this, "greenMinimum");
+    __publicField(this, "greenMaximum");
+    __publicField(this, "blueMinimum");
+    __publicField(this, "blueMaximum");
+    __publicField(this, "volume");
+    __publicField(this, "alphaMinimum");
+    __publicField(this, "alphaMaximum");
+  }
+};
+var _WuQuant = class extends AbstractPaletteQuantizer {
+  constructor(colorDistanceCalculator, colors = 256, significantBitsPerChannel = 5) {
+    super();
+    __publicField(this, "_reds");
+    __publicField(this, "_greens");
+    __publicField(this, "_blues");
+    __publicField(this, "_alphas");
+    __publicField(this, "_sums");
+    __publicField(this, "_weights");
+    __publicField(this, "_momentsRed");
+    __publicField(this, "_momentsGreen");
+    __publicField(this, "_momentsBlue");
+    __publicField(this, "_momentsAlpha");
+    __publicField(this, "_moments");
+    __publicField(this, "_table");
+    __publicField(this, "_pixels");
+    __publicField(this, "_cubes");
+    __publicField(this, "_colors");
+    __publicField(this, "_significantBitsPerChannel");
+    __publicField(this, "_maxSideIndex");
+    __publicField(this, "_alphaMaxSideIndex");
+    __publicField(this, "_sideSize");
+    __publicField(this, "_alphaSideSize");
+    __publicField(this, "_distance");
+    this._distance = colorDistanceCalculator;
+    this._setQuality(significantBitsPerChannel);
+    this._initialize(colors);
+  }
+  sample(image) {
+    const pointArray = image.getPointArray();
+    for (let i = 0, l = pointArray.length; i < l; i++) {
+      this._addColor(pointArray[i]);
+    }
+    this._pixels = this._pixels.concat(pointArray);
+  }
+  *quantize() {
+    yield* this._preparePalette();
+    const palette = new Palette();
+    for (let paletteIndex = 0; paletteIndex < this._colors; paletteIndex++) {
+      if (this._sums[paletteIndex] > 0) {
+        const sum = this._sums[paletteIndex];
+        const r = this._reds[paletteIndex] / sum;
+        const g = this._greens[paletteIndex] / sum;
+        const b = this._blues[paletteIndex] / sum;
+        const a = this._alphas[paletteIndex] / sum;
+        const color = Point.createByRGBA(r | 0, g | 0, b | 0, a | 0);
+        palette.add(color);
+      }
+    }
+    palette.sort();
+    yield {
+      palette,
+      progress: 100
+    };
+  }
+  *_preparePalette() {
+    yield* this._calculateMoments();
+    let next = 0;
+    const volumeVariance = createArray1D(this._colors);
+    for (let cubeIndex = 1; cubeIndex < this._colors; ++cubeIndex) {
+      if (this._cut(this._cubes[next], this._cubes[cubeIndex])) {
+        volumeVariance[next] = this._cubes[next].volume > 1 ? this._calculateVariance(this._cubes[next]) : 0;
+        volumeVariance[cubeIndex] = this._cubes[cubeIndex].volume > 1 ? this._calculateVariance(this._cubes[cubeIndex]) : 0;
+      } else {
+        volumeVariance[next] = 0;
+        cubeIndex--;
+      }
+      next = 0;
+      let temp = volumeVariance[0];
+      for (let index = 1; index <= cubeIndex; ++index) {
+        if (volumeVariance[index] > temp) {
+          temp = volumeVariance[index];
+          next = index;
+        }
+      }
+      if (temp <= 0) {
+        this._colors = cubeIndex + 1;
+        break;
+      }
+    }
+    const lookupRed = [];
+    const lookupGreen = [];
+    const lookupBlue = [];
+    const lookupAlpha = [];
+    for (let k = 0; k < this._colors; ++k) {
+      const weight = _WuQuant._volume(this._cubes[k], this._weights);
+      if (weight > 0) {
+        lookupRed[k] = _WuQuant._volume(this._cubes[k], this._momentsRed) / weight | 0;
+        lookupGreen[k] = _WuQuant._volume(this._cubes[k], this._momentsGreen) / weight | 0;
+        lookupBlue[k] = _WuQuant._volume(this._cubes[k], this._momentsBlue) / weight | 0;
+        lookupAlpha[k] = _WuQuant._volume(this._cubes[k], this._momentsAlpha) / weight | 0;
+      } else {
+        lookupRed[k] = 0;
+        lookupGreen[k] = 0;
+        lookupBlue[k] = 0;
+        lookupAlpha[k] = 0;
+      }
+    }
+    this._reds = createArray1D(this._colors + 1);
+    this._greens = createArray1D(this._colors + 1);
+    this._blues = createArray1D(this._colors + 1);
+    this._alphas = createArray1D(this._colors + 1);
+    this._sums = createArray1D(this._colors + 1);
+    for (let index = 0, l = this._pixels.length; index < l; index++) {
+      const color = this._pixels[index];
+      const match = -1;
+      let bestMatch = match;
+      let bestDistance = Number.MAX_VALUE;
+      for (let lookup = 0; lookup < this._colors; lookup++) {
+        const foundRed = lookupRed[lookup];
+        const foundGreen = lookupGreen[lookup];
+        const foundBlue = lookupBlue[lookup];
+        const foundAlpha = lookupAlpha[lookup];
+        const distance = this._distance.calculateRaw(foundRed, foundGreen, foundBlue, foundAlpha, color.r, color.g, color.b, color.a);
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          bestMatch = lookup;
+        }
+      }
+      this._reds[bestMatch] += color.r;
+      this._greens[bestMatch] += color.g;
+      this._blues[bestMatch] += color.b;
+      this._alphas[bestMatch] += color.a;
+      this._sums[bestMatch]++;
+    }
+  }
+  _addColor(color) {
+    const bitsToRemove = 8 - this._significantBitsPerChannel;
+    const indexRed = (color.r >> bitsToRemove) + 1;
+    const indexGreen = (color.g >> bitsToRemove) + 1;
+    const indexBlue = (color.b >> bitsToRemove) + 1;
+    const indexAlpha = (color.a >> bitsToRemove) + 1;
+    this._weights[indexAlpha][indexRed][indexGreen][indexBlue]++;
+    this._momentsRed[indexAlpha][indexRed][indexGreen][indexBlue] += color.r;
+    this._momentsGreen[indexAlpha][indexRed][indexGreen][indexBlue] += color.g;
+    this._momentsBlue[indexAlpha][indexRed][indexGreen][indexBlue] += color.b;
+    this._momentsAlpha[indexAlpha][indexRed][indexGreen][indexBlue] += color.a;
+    this._moments[indexAlpha][indexRed][indexGreen][indexBlue] += this._table[color.r] + this._table[color.g] + this._table[color.b] + this._table[color.a];
+  }
+  *_calculateMoments() {
+    const area = [];
+    const areaRed = [];
+    const areaGreen = [];
+    const areaBlue = [];
+    const areaAlpha = [];
+    const area2 = [];
+    const xarea = createArray3D(this._sideSize, this._sideSize, this._sideSize);
+    const xareaRed = createArray3D(this._sideSize, this._sideSize, this._sideSize);
+    const xareaGreen = createArray3D(this._sideSize, this._sideSize, this._sideSize);
+    const xareaBlue = createArray3D(this._sideSize, this._sideSize, this._sideSize);
+    const xareaAlpha = createArray3D(this._sideSize, this._sideSize, this._sideSize);
+    const xarea2 = createArray3D(this._sideSize, this._sideSize, this._sideSize);
+    let trackerProgress = 0;
+    const tracker = new ProgressTracker(this._alphaMaxSideIndex * this._maxSideIndex, 99);
+    for (let alphaIndex = 1; alphaIndex <= this._alphaMaxSideIndex; ++alphaIndex) {
+      fillArray3D(xarea, this._sideSize, this._sideSize, this._sideSize, 0);
+      fillArray3D(xareaRed, this._sideSize, this._sideSize, this._sideSize, 0);
+      fillArray3D(xareaGreen, this._sideSize, this._sideSize, this._sideSize, 0);
+      fillArray3D(xareaBlue, this._sideSize, this._sideSize, this._sideSize, 0);
+      fillArray3D(xareaAlpha, this._sideSize, this._sideSize, this._sideSize, 0);
+      fillArray3D(xarea2, this._sideSize, this._sideSize, this._sideSize, 0);
+      for (let redIndex = 1; redIndex <= this._maxSideIndex; ++redIndex, ++trackerProgress) {
+        if (tracker.shouldNotify(trackerProgress)) {
+          yield {
+            progress: tracker.progress
+          };
+        }
+        fillArray1D(area, this._sideSize, 0);
+        fillArray1D(areaRed, this._sideSize, 0);
+        fillArray1D(areaGreen, this._sideSize, 0);
+        fillArray1D(areaBlue, this._sideSize, 0);
+        fillArray1D(areaAlpha, this._sideSize, 0);
+        fillArray1D(area2, this._sideSize, 0);
+        for (let greenIndex = 1; greenIndex <= this._maxSideIndex; ++greenIndex) {
+          let line = 0;
+          let lineRed = 0;
+          let lineGreen = 0;
+          let lineBlue = 0;
+          let lineAlpha = 0;
+          let line2 = 0;
+          for (let blueIndex = 1; blueIndex <= this._maxSideIndex; ++blueIndex) {
+            line += this._weights[alphaIndex][redIndex][greenIndex][blueIndex];
+            lineRed += this._momentsRed[alphaIndex][redIndex][greenIndex][blueIndex];
+            lineGreen += this._momentsGreen[alphaIndex][redIndex][greenIndex][blueIndex];
+            lineBlue += this._momentsBlue[alphaIndex][redIndex][greenIndex][blueIndex];
+            lineAlpha += this._momentsAlpha[alphaIndex][redIndex][greenIndex][blueIndex];
+            line2 += this._moments[alphaIndex][redIndex][greenIndex][blueIndex];
+            area[blueIndex] += line;
+            areaRed[blueIndex] += lineRed;
+            areaGreen[blueIndex] += lineGreen;
+            areaBlue[blueIndex] += lineBlue;
+            areaAlpha[blueIndex] += lineAlpha;
+            area2[blueIndex] += line2;
+            xarea[redIndex][greenIndex][blueIndex] = xarea[redIndex - 1][greenIndex][blueIndex] + area[blueIndex];
+            xareaRed[redIndex][greenIndex][blueIndex] = xareaRed[redIndex - 1][greenIndex][blueIndex] + areaRed[blueIndex];
+            xareaGreen[redIndex][greenIndex][blueIndex] = xareaGreen[redIndex - 1][greenIndex][blueIndex] + areaGreen[blueIndex];
+            xareaBlue[redIndex][greenIndex][blueIndex] = xareaBlue[redIndex - 1][greenIndex][blueIndex] + areaBlue[blueIndex];
+            xareaAlpha[redIndex][greenIndex][blueIndex] = xareaAlpha[redIndex - 1][greenIndex][blueIndex] + areaAlpha[blueIndex];
+            xarea2[redIndex][greenIndex][blueIndex] = xarea2[redIndex - 1][greenIndex][blueIndex] + area2[blueIndex];
+            this._weights[alphaIndex][redIndex][greenIndex][blueIndex] = this._weights[alphaIndex - 1][redIndex][greenIndex][blueIndex] + xarea[redIndex][greenIndex][blueIndex];
+            this._momentsRed[alphaIndex][redIndex][greenIndex][blueIndex] = this._momentsRed[alphaIndex - 1][redIndex][greenIndex][blueIndex] + xareaRed[redIndex][greenIndex][blueIndex];
+            this._momentsGreen[alphaIndex][redIndex][greenIndex][blueIndex] = this._momentsGreen[alphaIndex - 1][redIndex][greenIndex][blueIndex] + xareaGreen[redIndex][greenIndex][blueIndex];
+            this._momentsBlue[alphaIndex][redIndex][greenIndex][blueIndex] = this._momentsBlue[alphaIndex - 1][redIndex][greenIndex][blueIndex] + xareaBlue[redIndex][greenIndex][blueIndex];
+            this._momentsAlpha[alphaIndex][redIndex][greenIndex][blueIndex] = this._momentsAlpha[alphaIndex - 1][redIndex][greenIndex][blueIndex] + xareaAlpha[redIndex][greenIndex][blueIndex];
+            this._moments[alphaIndex][redIndex][greenIndex][blueIndex] = this._moments[alphaIndex - 1][redIndex][greenIndex][blueIndex] + xarea2[redIndex][greenIndex][blueIndex];
+          }
+        }
+      }
+    }
+  }
+  static _volumeFloat(cube, moment) {
+    return moment[cube.alphaMaximum][cube.redMaximum][cube.greenMaximum][cube.blueMaximum] - moment[cube.alphaMaximum][cube.redMaximum][cube.greenMinimum][cube.blueMaximum] - moment[cube.alphaMaximum][cube.redMinimum][cube.greenMaximum][cube.blueMaximum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] - moment[cube.alphaMinimum][cube.redMaximum][cube.greenMaximum][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMaximum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] - (moment[cube.alphaMaximum][cube.redMaximum][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMaximum][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMaximum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] - moment[cube.alphaMaximum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum]);
+  }
+  static _volume(cube, moment) {
+    return _WuQuant._volumeFloat(cube, moment) | 0;
+  }
+  static _top(cube, direction, position, moment) {
+    let result;
+    switch (direction) {
+      case _WuQuant._alpha:
+        result = moment[position][cube.redMaximum][cube.greenMaximum][cube.blueMaximum] - moment[position][cube.redMaximum][cube.greenMinimum][cube.blueMaximum] - moment[position][cube.redMinimum][cube.greenMaximum][cube.blueMaximum] + moment[position][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] - (moment[position][cube.redMaximum][cube.greenMaximum][cube.blueMinimum] - moment[position][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] - moment[position][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] + moment[position][cube.redMinimum][cube.greenMinimum][cube.blueMinimum]);
+        break;
+      case _WuQuant._red:
+        result = moment[cube.alphaMaximum][position][cube.greenMaximum][cube.blueMaximum] - moment[cube.alphaMaximum][position][cube.greenMinimum][cube.blueMaximum] - moment[cube.alphaMinimum][position][cube.greenMaximum][cube.blueMaximum] + moment[cube.alphaMinimum][position][cube.greenMinimum][cube.blueMaximum] - (moment[cube.alphaMaximum][position][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMaximum][position][cube.greenMinimum][cube.blueMinimum] - moment[cube.alphaMinimum][position][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMinimum][position][cube.greenMinimum][cube.blueMinimum]);
+        break;
+      case _WuQuant._green:
+        result = moment[cube.alphaMaximum][cube.redMaximum][position][cube.blueMaximum] - moment[cube.alphaMaximum][cube.redMinimum][position][cube.blueMaximum] - moment[cube.alphaMinimum][cube.redMaximum][position][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMinimum][position][cube.blueMaximum] - (moment[cube.alphaMaximum][cube.redMaximum][position][cube.blueMinimum] - moment[cube.alphaMaximum][cube.redMinimum][position][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMaximum][position][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMinimum][position][cube.blueMinimum]);
+        break;
+      case _WuQuant._blue:
+        result = moment[cube.alphaMaximum][cube.redMaximum][cube.greenMaximum][position] - moment[cube.alphaMaximum][cube.redMaximum][cube.greenMinimum][position] - moment[cube.alphaMaximum][cube.redMinimum][cube.greenMaximum][position] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][position] - (moment[cube.alphaMinimum][cube.redMaximum][cube.greenMaximum][position] - moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][position] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][position] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][position]);
+        break;
+      default:
+        throw new Error("impossible");
+    }
+    return result | 0;
+  }
+  static _bottom(cube, direction, moment) {
+    switch (direction) {
+      case _WuQuant._alpha:
+        return -moment[cube.alphaMinimum][cube.redMaximum][cube.greenMaximum][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMaximum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] - (-moment[cube.alphaMinimum][cube.redMaximum][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum]);
+      case _WuQuant._red:
+        return -moment[cube.alphaMaximum][cube.redMinimum][cube.greenMaximum][cube.blueMaximum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMaximum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] - (-moment[cube.alphaMaximum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum]);
+      case _WuQuant._green:
+        return -moment[cube.alphaMaximum][cube.redMaximum][cube.greenMinimum][cube.blueMaximum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMaximum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMaximum] - (-moment[cube.alphaMaximum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum]);
+      case _WuQuant._blue:
+        return -moment[cube.alphaMaximum][cube.redMaximum][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMaximum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMaximum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMaximum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum] - (-moment[cube.alphaMinimum][cube.redMaximum][cube.greenMaximum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMaximum][cube.greenMinimum][cube.blueMinimum] + moment[cube.alphaMinimum][cube.redMinimum][cube.greenMaximum][cube.blueMinimum] - moment[cube.alphaMinimum][cube.redMinimum][cube.greenMinimum][cube.blueMinimum]);
+      default:
+        return 0;
+    }
+  }
+  _calculateVariance(cube) {
+    const volumeRed = _WuQuant._volume(cube, this._momentsRed);
+    const volumeGreen = _WuQuant._volume(cube, this._momentsGreen);
+    const volumeBlue = _WuQuant._volume(cube, this._momentsBlue);
+    const volumeAlpha = _WuQuant._volume(cube, this._momentsAlpha);
+    const volumeMoment = _WuQuant._volumeFloat(cube, this._moments);
+    const volumeWeight = _WuQuant._volume(cube, this._weights);
+    const distance = volumeRed * volumeRed + volumeGreen * volumeGreen + volumeBlue * volumeBlue + volumeAlpha * volumeAlpha;
+    return volumeMoment - distance / volumeWeight;
+  }
+  _maximize(cube, direction, first, last, wholeRed, wholeGreen, wholeBlue, wholeAlpha, wholeWeight) {
+    const bottomRed = _WuQuant._bottom(cube, direction, this._momentsRed) | 0;
+    const bottomGreen = _WuQuant._bottom(cube, direction, this._momentsGreen) | 0;
+    const bottomBlue = _WuQuant._bottom(cube, direction, this._momentsBlue) | 0;
+    const bottomAlpha = _WuQuant._bottom(cube, direction, this._momentsAlpha) | 0;
+    const bottomWeight = _WuQuant._bottom(cube, direction, this._weights) | 0;
+    let result = 0;
+    let cutPosition = -1;
+    for (let position = first; position < last; ++position) {
+      let halfRed = bottomRed + _WuQuant._top(cube, direction, position, this._momentsRed);
+      let halfGreen = bottomGreen + _WuQuant._top(cube, direction, position, this._momentsGreen);
+      let halfBlue = bottomBlue + _WuQuant._top(cube, direction, position, this._momentsBlue);
+      let halfAlpha = bottomAlpha + _WuQuant._top(cube, direction, position, this._momentsAlpha);
+      let halfWeight = bottomWeight + _WuQuant._top(cube, direction, position, this._weights);
+      if (halfWeight !== 0) {
+        let halfDistance = halfRed * halfRed + halfGreen * halfGreen + halfBlue * halfBlue + halfAlpha * halfAlpha;
+        let temp = halfDistance / halfWeight;
+        halfRed = wholeRed - halfRed;
+        halfGreen = wholeGreen - halfGreen;
+        halfBlue = wholeBlue - halfBlue;
+        halfAlpha = wholeAlpha - halfAlpha;
+        halfWeight = wholeWeight - halfWeight;
+        if (halfWeight !== 0) {
+          halfDistance = halfRed * halfRed + halfGreen * halfGreen + halfBlue * halfBlue + halfAlpha * halfAlpha;
+          temp += halfDistance / halfWeight;
+          if (temp > result) {
+            result = temp;
+            cutPosition = position;
+          }
+        }
+      }
+    }
+    return { max: result, position: cutPosition };
+  }
+  _cut(first, second) {
+    let direction;
+    const wholeRed = _WuQuant._volume(first, this._momentsRed);
+    const wholeGreen = _WuQuant._volume(first, this._momentsGreen);
+    const wholeBlue = _WuQuant._volume(first, this._momentsBlue);
+    const wholeAlpha = _WuQuant._volume(first, this._momentsAlpha);
+    const wholeWeight = _WuQuant._volume(first, this._weights);
+    const red = this._maximize(first, _WuQuant._red, first.redMinimum + 1, first.redMaximum, wholeRed, wholeGreen, wholeBlue, wholeAlpha, wholeWeight);
+    const green = this._maximize(first, _WuQuant._green, first.greenMinimum + 1, first.greenMaximum, wholeRed, wholeGreen, wholeBlue, wholeAlpha, wholeWeight);
+    const blue = this._maximize(first, _WuQuant._blue, first.blueMinimum + 1, first.blueMaximum, wholeRed, wholeGreen, wholeBlue, wholeAlpha, wholeWeight);
+    const alpha = this._maximize(first, _WuQuant._alpha, first.alphaMinimum + 1, first.alphaMaximum, wholeRed, wholeGreen, wholeBlue, wholeAlpha, wholeWeight);
+    if (alpha.max >= red.max && alpha.max >= green.max && alpha.max >= blue.max) {
+      direction = _WuQuant._alpha;
+      if (alpha.position < 0)
+        return false;
+    } else if (red.max >= alpha.max && red.max >= green.max && red.max >= blue.max) {
+      direction = _WuQuant._red;
+    } else if (green.max >= alpha.max && green.max >= red.max && green.max >= blue.max) {
+      direction = _WuQuant._green;
+    } else {
+      direction = _WuQuant._blue;
+    }
+    second.redMaximum = first.redMaximum;
+    second.greenMaximum = first.greenMaximum;
+    second.blueMaximum = first.blueMaximum;
+    second.alphaMaximum = first.alphaMaximum;
+    switch (direction) {
+      case _WuQuant._red:
+        second.redMinimum = first.redMaximum = red.position;
+        second.greenMinimum = first.greenMinimum;
+        second.blueMinimum = first.blueMinimum;
+        second.alphaMinimum = first.alphaMinimum;
+        break;
+      case _WuQuant._green:
+        second.greenMinimum = first.greenMaximum = green.position;
+        second.redMinimum = first.redMinimum;
+        second.blueMinimum = first.blueMinimum;
+        second.alphaMinimum = first.alphaMinimum;
+        break;
+      case _WuQuant._blue:
+        second.blueMinimum = first.blueMaximum = blue.position;
+        second.redMinimum = first.redMinimum;
+        second.greenMinimum = first.greenMinimum;
+        second.alphaMinimum = first.alphaMinimum;
+        break;
+      case _WuQuant._alpha:
+        second.alphaMinimum = first.alphaMaximum = alpha.position;
+        second.blueMinimum = first.blueMinimum;
+        second.redMinimum = first.redMinimum;
+        second.greenMinimum = first.greenMinimum;
+        break;
+    }
+    first.volume = (first.redMaximum - first.redMinimum) * (first.greenMaximum - first.greenMinimum) * (first.blueMaximum - first.blueMinimum) * (first.alphaMaximum - first.alphaMinimum);
+    second.volume = (second.redMaximum - second.redMinimum) * (second.greenMaximum - second.greenMinimum) * (second.blueMaximum - second.blueMinimum) * (second.alphaMaximum - second.alphaMinimum);
+    return true;
+  }
+  _initialize(colors) {
+    this._colors = colors;
+    this._cubes = [];
+    for (let cubeIndex = 0; cubeIndex < colors; cubeIndex++) {
+      this._cubes[cubeIndex] = new WuColorCube();
+    }
+    this._cubes[0].redMinimum = 0;
+    this._cubes[0].greenMinimum = 0;
+    this._cubes[0].blueMinimum = 0;
+    this._cubes[0].alphaMinimum = 0;
+    this._cubes[0].redMaximum = this._maxSideIndex;
+    this._cubes[0].greenMaximum = this._maxSideIndex;
+    this._cubes[0].blueMaximum = this._maxSideIndex;
+    this._cubes[0].alphaMaximum = this._alphaMaxSideIndex;
+    this._weights = createArray4D(this._alphaSideSize, this._sideSize, this._sideSize, this._sideSize);
+    this._momentsRed = createArray4D(this._alphaSideSize, this._sideSize, this._sideSize, this._sideSize);
+    this._momentsGreen = createArray4D(this._alphaSideSize, this._sideSize, this._sideSize, this._sideSize);
+    this._momentsBlue = createArray4D(this._alphaSideSize, this._sideSize, this._sideSize, this._sideSize);
+    this._momentsAlpha = createArray4D(this._alphaSideSize, this._sideSize, this._sideSize, this._sideSize);
+    this._moments = createArray4D(this._alphaSideSize, this._sideSize, this._sideSize, this._sideSize);
+    this._table = [];
+    for (let tableIndex = 0; tableIndex < 256; ++tableIndex) {
+      this._table[tableIndex] = tableIndex * tableIndex;
+    }
+    this._pixels = [];
+  }
+  _setQuality(significantBitsPerChannel = 5) {
+    this._significantBitsPerChannel = significantBitsPerChannel;
+    this._maxSideIndex = 1 << this._significantBitsPerChannel;
+    this._alphaMaxSideIndex = this._maxSideIndex;
+    this._sideSize = this._maxSideIndex + 1;
+    this._alphaSideSize = this._alphaMaxSideIndex + 1;
+  }
+};
+var WuQuant = _WuQuant;
+__publicField(WuQuant, "_alpha", 3);
+__publicField(WuQuant, "_red", 2);
+__publicField(WuQuant, "_green", 1);
+__publicField(WuQuant, "_blue", 0);
+
+// src/image/index.ts
+var image_exports = {};
+__export(image_exports, {
+  AbstractImageQuantizer: () => AbstractImageQuantizer,
+  ErrorDiffusionArray: () => ErrorDiffusionArray,
+  ErrorDiffusionArrayKernel: () => ErrorDiffusionArrayKernel,
+  ErrorDiffusionRiemersma: () => ErrorDiffusionRiemersma,
+  NearestColor: () => NearestColor
+});
+
+// src/image/imageQuantizer.ts
+var AbstractImageQuantizer = class {
+  quantizeSync(pointContainer, palette) {
+    for (const value of this.quantize(pointContainer, palette)) {
+      if (value.pointContainer) {
+        return value.pointContainer;
+      }
+    }
+    throw new Error("unreachable");
+  }
+};
+
+// src/image/nearestColor.ts
+var NearestColor = class extends AbstractImageQuantizer {
+  constructor(colorDistanceCalculator) {
+    super();
+    __publicField(this, "_distance");
+    this._distance = colorDistanceCalculator;
+  }
+  *quantize(pointContainer, palette) {
+    const pointArray = pointContainer.getPointArray();
+    const width = pointContainer.getWidth();
+    const height = pointContainer.getHeight();
+    const tracker = new ProgressTracker(height, 99);
+    for (let y2 = 0; y2 < height; y2++) {
+      if (tracker.shouldNotify(y2)) {
+        yield {
+          progress: tracker.progress
+        };
+      }
+      for (let x2 = 0, idx = y2 * width; x2 < width; x2++, idx++) {
+        const point = pointArray[idx];
+        point.from(palette.getNearestColor(this._distance, point));
+      }
+    }
+    yield {
+      pointContainer,
+      progress: 100
+    };
+  }
+};
+
+// src/image/array.ts
+var ErrorDiffusionArrayKernel = /* @__PURE__ */ ((ErrorDiffusionArrayKernel2) => {
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["FloydSteinberg"] = 0] = "FloydSteinberg";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["FalseFloydSteinberg"] = 1] = "FalseFloydSteinberg";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["Stucki"] = 2] = "Stucki";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["Atkinson"] = 3] = "Atkinson";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["Jarvis"] = 4] = "Jarvis";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["Burkes"] = 5] = "Burkes";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["Sierra"] = 6] = "Sierra";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["TwoSierra"] = 7] = "TwoSierra";
+  ErrorDiffusionArrayKernel2[ErrorDiffusionArrayKernel2["SierraLite"] = 8] = "SierraLite";
+  return ErrorDiffusionArrayKernel2;
+})(ErrorDiffusionArrayKernel || {});
+var ErrorDiffusionArray = class extends AbstractImageQuantizer {
+  constructor(colorDistanceCalculator, kernel, serpentine = true, minimumColorDistanceToDither = 0, calculateErrorLikeGIMP = false) {
+    super();
+    __publicField(this, "_minColorDistance");
+    __publicField(this, "_serpentine");
+    __publicField(this, "_kernel");
+    __publicField(this, "_calculateErrorLikeGIMP");
+    __publicField(this, "_distance");
+    this._setKernel(kernel);
+    this._distance = colorDistanceCalculator;
+    this._minColorDistance = minimumColorDistanceToDither;
+    this._serpentine = serpentine;
+    this._calculateErrorLikeGIMP = calculateErrorLikeGIMP;
+  }
+  *quantize(pointContainer, palette) {
+    const pointArray = pointContainer.getPointArray();
+    const originalPoint = new Point();
+    const width = pointContainer.getWidth();
+    const height = pointContainer.getHeight();
+    const errorLines = [];
+    let dir = 1;
+    let maxErrorLines = 1;
+    for (const kernel of this._kernel) {
+      const kernelErrorLines = kernel[2] + 1;
+      if (maxErrorLines < kernelErrorLines)
+        maxErrorLines = kernelErrorLines;
+    }
+    for (let i = 0; i < maxErrorLines; i++) {
+      this._fillErrorLine(errorLines[i] = [], width);
+    }
+    const tracker = new ProgressTracker(height, 99);
+    for (let y2 = 0; y2 < height; y2++) {
+      if (tracker.shouldNotify(y2)) {
+        yield {
+          progress: tracker.progress
+        };
+      }
+      if (this._serpentine)
+        dir *= -1;
+      const lni = y2 * width;
+      const xStart = dir === 1 ? 0 : width - 1;
+      const xEnd = dir === 1 ? width : -1;
+      this._fillErrorLine(errorLines[0], width);
+      errorLines.push(errorLines.shift());
+      const errorLine = errorLines[0];
+      for (let x2 = xStart, idx = lni + xStart; x2 !== xEnd; x2 += dir, idx += dir) {
+        const point = pointArray[idx];
+        const error = errorLine[x2];
+        originalPoint.from(point);
+        const correctedPoint = Point.createByRGBA(inRange0to255Rounded(point.r + error[0]), inRange0to255Rounded(point.g + error[1]), inRange0to255Rounded(point.b + error[2]), inRange0to255Rounded(point.a + error[3]));
+        const palettePoint = palette.getNearestColor(this._distance, correctedPoint);
+        point.from(palettePoint);
+        if (this._minColorDistance) {
+          const dist = this._distance.calculateNormalized(originalPoint, palettePoint);
+          if (dist < this._minColorDistance)
+            continue;
+        }
+        let er;
+        let eg;
+        let eb;
+        let ea;
+        if (this._calculateErrorLikeGIMP) {
+          er = correctedPoint.r - palettePoint.r;
+          eg = correctedPoint.g - palettePoint.g;
+          eb = correctedPoint.b - palettePoint.b;
+          ea = correctedPoint.a - palettePoint.a;
+        } else {
+          er = originalPoint.r - palettePoint.r;
+          eg = originalPoint.g - palettePoint.g;
+          eb = originalPoint.b - palettePoint.b;
+          ea = originalPoint.a - palettePoint.a;
+        }
+        const dStart = dir === 1 ? 0 : this._kernel.length - 1;
+        const dEnd = dir === 1 ? this._kernel.length : -1;
+        for (let i = dStart; i !== dEnd; i += dir) {
+          const x1 = this._kernel[i][1] * dir;
+          const y1 = this._kernel[i][2];
+          if (x1 + x2 >= 0 && x1 + x2 < width && y1 + y2 >= 0 && y1 + y2 < height) {
+            const d = this._kernel[i][0];
+            const e = errorLines[y1][x1 + x2];
+            e[0] += er * d;
+            e[1] += eg * d;
+            e[2] += eb * d;
+            e[3] += ea * d;
+          }
+        }
+      }
+    }
+    yield {
+      pointContainer,
+      progress: 100
+    };
+  }
+  _fillErrorLine(errorLine, width) {
+    if (errorLine.length > width) {
+      errorLine.length = width;
+    }
+    const l = errorLine.length;
+    for (let i = 0; i < l; i++) {
+      const error = errorLine[i];
+      error[0] = error[1] = error[2] = error[3] = 0;
+    }
+    for (let i = l; i < width; i++) {
+      errorLine[i] = [0, 0, 0, 0];
+    }
+  }
+  _setKernel(kernel) {
+    switch (kernel) {
+      case 0 /* FloydSteinberg */:
+        this._kernel = [
+          [7 / 16, 1, 0],
+          [3 / 16, -1, 1],
+          [5 / 16, 0, 1],
+          [1 / 16, 1, 1]
+        ];
+        break;
+      case 1 /* FalseFloydSteinberg */:
+        this._kernel = [
+          [3 / 8, 1, 0],
+          [3 / 8, 0, 1],
+          [2 / 8, 1, 1]
+        ];
+        break;
+      case 2 /* Stucki */:
+        this._kernel = [
+          [8 / 42, 1, 0],
+          [4 / 42, 2, 0],
+          [2 / 42, -2, 1],
+          [4 / 42, -1, 1],
+          [8 / 42, 0, 1],
+          [4 / 42, 1, 1],
+          [2 / 42, 2, 1],
+          [1 / 42, -2, 2],
+          [2 / 42, -1, 2],
+          [4 / 42, 0, 2],
+          [2 / 42, 1, 2],
+          [1 / 42, 2, 2]
+        ];
+        break;
+      case 3 /* Atkinson */:
+        this._kernel = [
+          [1 / 8, 1, 0],
+          [1 / 8, 2, 0],
+          [1 / 8, -1, 1],
+          [1 / 8, 0, 1],
+          [1 / 8, 1, 1],
+          [1 / 8, 0, 2]
+        ];
+        break;
+      case 4 /* Jarvis */:
+        this._kernel = [
+          [7 / 48, 1, 0],
+          [5 / 48, 2, 0],
+          [3 / 48, -2, 1],
+          [5 / 48, -1, 1],
+          [7 / 48, 0, 1],
+          [5 / 48, 1, 1],
+          [3 / 48, 2, 1],
+          [1 / 48, -2, 2],
+          [3 / 48, -1, 2],
+          [5 / 48, 0, 2],
+          [3 / 48, 1, 2],
+          [1 / 48, 2, 2]
+        ];
+        break;
+      case 5 /* Burkes */:
+        this._kernel = [
+          [8 / 32, 1, 0],
+          [4 / 32, 2, 0],
+          [2 / 32, -2, 1],
+          [4 / 32, -1, 1],
+          [8 / 32, 0, 1],
+          [4 / 32, 1, 1],
+          [2 / 32, 2, 1]
+        ];
+        break;
+      case 6 /* Sierra */:
+        this._kernel = [
+          [5 / 32, 1, 0],
+          [3 / 32, 2, 0],
+          [2 / 32, -2, 1],
+          [4 / 32, -1, 1],
+          [5 / 32, 0, 1],
+          [4 / 32, 1, 1],
+          [2 / 32, 2, 1],
+          [2 / 32, -1, 2],
+          [3 / 32, 0, 2],
+          [2 / 32, 1, 2]
+        ];
+        break;
+      case 7 /* TwoSierra */:
+        this._kernel = [
+          [4 / 16, 1, 0],
+          [3 / 16, 2, 0],
+          [1 / 16, -2, 1],
+          [2 / 16, -1, 1],
+          [3 / 16, 0, 1],
+          [2 / 16, 1, 1],
+          [1 / 16, 2, 1]
+        ];
+        break;
+      case 8 /* SierraLite */:
+        this._kernel = [
+          [2 / 4, 1, 0],
+          [1 / 4, -1, 1],
+          [1 / 4, 0, 1]
+        ];
+        break;
+      default:
+        throw new Error(`ErrorDiffusionArray: unknown kernel = ${kernel}`);
+    }
+  }
+};
+
+// src/image/spaceFillingCurves/hilbertCurve.ts
+function* hilbertCurve(width, height, callback) {
+  const maxBound = Math.max(width, height);
+  const level = Math.floor(Math.log(maxBound) / Math.log(2) + 1);
+  const tracker = new ProgressTracker(width * height, 99);
+  const data = {
+    width,
+    height,
+    level,
+    callback,
+    tracker,
+    index: 0,
+    x: 0,
+    y: 0
+  };
+  yield* walkHilbert(data, 1 /* UP */);
+  visit(data, 0 /* NONE */);
+}
+function* walkHilbert(data, direction) {
+  if (data.level < 1)
+    return;
+  if (data.tracker.shouldNotify(data.index)) {
+    yield { progress: data.tracker.progress };
+  }
+  data.level--;
+  switch (direction) {
+    case 2 /* LEFT */:
+      yield* walkHilbert(data, 1 /* UP */);
+      visit(data, 3 /* RIGHT */);
+      yield* walkHilbert(data, 2 /* LEFT */);
+      visit(data, 4 /* DOWN */);
+      yield* walkHilbert(data, 2 /* LEFT */);
+      visit(data, 2 /* LEFT */);
+      yield* walkHilbert(data, 4 /* DOWN */);
+      break;
+    case 3 /* RIGHT */:
+      yield* walkHilbert(data, 4 /* DOWN */);
+      visit(data, 2 /* LEFT */);
+      yield* walkHilbert(data, 3 /* RIGHT */);
+      visit(data, 1 /* UP */);
+      yield* walkHilbert(data, 3 /* RIGHT */);
+      visit(data, 3 /* RIGHT */);
+      yield* walkHilbert(data, 1 /* UP */);
+      break;
+    case 1 /* UP */:
+      yield* walkHilbert(data, 2 /* LEFT */);
+      visit(data, 4 /* DOWN */);
+      yield* walkHilbert(data, 1 /* UP */);
+      visit(data, 3 /* RIGHT */);
+      yield* walkHilbert(data, 1 /* UP */);
+      visit(data, 1 /* UP */);
+      yield* walkHilbert(data, 3 /* RIGHT */);
+      break;
+    case 4 /* DOWN */:
+      yield* walkHilbert(data, 3 /* RIGHT */);
+      visit(data, 1 /* UP */);
+      yield* walkHilbert(data, 4 /* DOWN */);
+      visit(data, 2 /* LEFT */);
+      yield* walkHilbert(data, 4 /* DOWN */);
+      visit(data, 4 /* DOWN */);
+      yield* walkHilbert(data, 2 /* LEFT */);
+      break;
+    default:
+      break;
+  }
+  data.level++;
+}
+function visit(data, direction) {
+  if (data.x >= 0 && data.x < data.width && data.y >= 0 && data.y < data.height) {
+    data.callback(data.x, data.y);
+    data.index++;
+  }
+  switch (direction) {
+    case 2 /* LEFT */:
+      data.x--;
+      break;
+    case 3 /* RIGHT */:
+      data.x++;
+      break;
+    case 1 /* UP */:
+      data.y--;
+      break;
+    case 4 /* DOWN */:
+      data.y++;
+      break;
+  }
+}
+
+// src/image/riemersma.ts
+var ErrorDiffusionRiemersma = class extends AbstractImageQuantizer {
+  constructor(colorDistanceCalculator, errorQueueSize = 16, errorPropagation = 1) {
+    super();
+    __publicField(this, "_distance");
+    __publicField(this, "_weights");
+    __publicField(this, "_errorQueueSize");
+    this._distance = colorDistanceCalculator;
+    this._errorQueueSize = errorQueueSize;
+    this._weights = ErrorDiffusionRiemersma._createWeights(errorPropagation, errorQueueSize);
+  }
+  *quantize(pointContainer, palette) {
+    const pointArray = pointContainer.getPointArray();
+    const width = pointContainer.getWidth();
+    const height = pointContainer.getHeight();
+    const errorQueue = [];
+    let head = 0;
+    for (let i = 0; i < this._errorQueueSize; i++) {
+      errorQueue[i] = { r: 0, g: 0, b: 0, a: 0 };
+    }
+    yield* hilbertCurve(width, height, (x2, y2) => {
+      const p = pointArray[x2 + y2 * width];
+      let { r, g, b, a } = p;
+      for (let i = 0; i < this._errorQueueSize; i++) {
+        const weight = this._weights[i];
+        const e = errorQueue[(i + head) % this._errorQueueSize];
+        r += e.r * weight;
+        g += e.g * weight;
+        b += e.b * weight;
+        a += e.a * weight;
+      }
+      const correctedPoint = Point.createByRGBA(inRange0to255Rounded(r), inRange0to255Rounded(g), inRange0to255Rounded(b), inRange0to255Rounded(a));
+      const quantizedPoint = palette.getNearestColor(this._distance, correctedPoint);
+      head = (head + 1) % this._errorQueueSize;
+      const tail = (head + this._errorQueueSize - 1) % this._errorQueueSize;
+      errorQueue[tail].r = p.r - quantizedPoint.r;
+      errorQueue[tail].g = p.g - quantizedPoint.g;
+      errorQueue[tail].b = p.b - quantizedPoint.b;
+      errorQueue[tail].a = p.a - quantizedPoint.a;
+      p.from(quantizedPoint);
+    });
+    yield {
+      pointContainer,
+      progress: 100
+    };
+  }
+  static _createWeights(errorPropagation, errorQueueSize) {
+    const weights = [];
+    const multiplier = Math.exp(Math.log(errorQueueSize) / (errorQueueSize - 1));
+    for (let i = 0, next = 1; i < errorQueueSize; i++) {
+      weights[i] = (next + 0.5 | 0) / errorQueueSize * errorPropagation;
+      next *= multiplier;
+    }
+    return weights;
+  }
+};
+
+// src/quality/index.ts
+var quality_exports = {};
+__export(quality_exports, {
+  ssim: () => ssim
+});
+
+// src/quality/ssim.ts
+var K1 = 0.01;
+var K2 = 0.03;
+function ssim(image1, image2) {
+  if (image1.getHeight() !== image2.getHeight() || image1.getWidth() !== image2.getWidth()) {
+    throw new Error("Images have different sizes!");
+  }
+  const bitsPerComponent = 8;
+  const L = (1 << bitsPerComponent) - 1;
+  const c1 = (K1 * L) ** 2;
+  const c2 = (K2 * L) ** 2;
+  let numWindows = 0;
+  let mssim = 0;
+  iterate(image1, image2, (lumaValues1, lumaValues2, averageLumaValue1, averageLumaValue2) => {
+    let sigxy = 0;
+    let sigsqx = 0;
+    let sigsqy = 0;
+    for (let i = 0; i < lumaValues1.length; i++) {
+      sigsqx += (lumaValues1[i] - averageLumaValue1) ** 2;
+      sigsqy += (lumaValues2[i] - averageLumaValue2) ** 2;
+      sigxy += (lumaValues1[i] - averageLumaValue1) * (lumaValues2[i] - averageLumaValue2);
+    }
+    const numPixelsInWin = lumaValues1.length - 1;
+    sigsqx /= numPixelsInWin;
+    sigsqy /= numPixelsInWin;
+    sigxy /= numPixelsInWin;
+    const numerator = (2 * averageLumaValue1 * averageLumaValue2 + c1) * (2 * sigxy + c2);
+    const denominator = (averageLumaValue1 ** 2 + averageLumaValue2 ** 2 + c1) * (sigsqx + sigsqy + c2);
+    const ssim2 = numerator / denominator;
+    mssim += ssim2;
+    numWindows++;
+  });
+  return mssim / numWindows;
+}
+function iterate(image1, image2, callback) {
+  const windowSize = 8;
+  const width = image1.getWidth();
+  const height = image1.getHeight();
+  for (let y2 = 0; y2 < height; y2 += windowSize) {
+    for (let x2 = 0; x2 < width; x2 += windowSize) {
+      const windowWidth = Math.min(windowSize, width - x2);
+      const windowHeight = Math.min(windowSize, height - y2);
+      const lumaValues1 = calculateLumaValuesForWindow(image1, x2, y2, windowWidth, windowHeight);
+      const lumaValues2 = calculateLumaValuesForWindow(image2, x2, y2, windowWidth, windowHeight);
+      const averageLuma1 = calculateAverageLuma(lumaValues1);
+      const averageLuma2 = calculateAverageLuma(lumaValues2);
+      callback(lumaValues1, lumaValues2, averageLuma1, averageLuma2);
+    }
+  }
+}
+function calculateLumaValuesForWindow(image, x2, y2, width, height) {
+  const pointArray = image.getPointArray();
+  const lumaValues = [];
+  let counter = 0;
+  for (let j = y2; j < y2 + height; j++) {
+    const offset = j * image.getWidth();
+    for (let i = x2; i < x2 + width; i++) {
+      const point = pointArray[offset + i];
+      lumaValues[counter] = point.r * 0.2126 /* RED */ + point.g * 0.7152 /* GREEN */ + point.b * 0.0722 /* BLUE */;
+      counter++;
+    }
+  }
+  return lumaValues;
+}
+function calculateAverageLuma(lumaValues) {
+  let sumLuma = 0;
+  for (const luma of lumaValues) {
+    sumLuma += luma;
+  }
+  return sumLuma / lumaValues.length;
+}
+
+// src/basicAPI.ts
+var setImmediateImpl = typeof setImmediate === "function" ? setImmediate : typeof process !== "undefined" && typeof (process == null ? void 0 : process.nextTick) === "function" ? (callback) => process.nextTick(callback) : (callback) => setTimeout(callback, 0);
+function buildPaletteSync(images, {
+  colorDistanceFormula,
+  paletteQuantization,
+  colors
+} = {}) {
+  const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
+  const paletteQuantizer = paletteQuantizationToPaletteQuantizer(distanceCalculator, paletteQuantization, colors);
+  images.forEach((image) => paletteQuantizer.sample(image));
+  return paletteQuantizer.quantizeSync();
+}
+async function buildPalette(images, {
+  colorDistanceFormula,
+  paletteQuantization,
+  colors,
+  onProgress
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
+    const paletteQuantizer = paletteQuantizationToPaletteQuantizer(distanceCalculator, paletteQuantization, colors);
+    images.forEach((image) => paletteQuantizer.sample(image));
+    let palette;
+    const iterator = paletteQuantizer.quantize();
+    const next = () => {
+      try {
+        const result = iterator.next();
+        if (result.done) {
+          resolve(palette);
+        } else {
+          if (result.value.palette)
+            palette = result.value.palette;
+          if (onProgress)
+            onProgress(result.value.progress);
+          setImmediateImpl(next);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    };
+    setImmediateImpl(next);
+  });
+}
+function applyPaletteSync(image, palette, { colorDistanceFormula, imageQuantization } = {}) {
+  const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
+  const imageQuantizer = imageQuantizationToImageQuantizer(distanceCalculator, imageQuantization);
+  return imageQuantizer.quantizeSync(image, palette);
+}
+async function applyPalette(image, palette, {
+  colorDistanceFormula,
+  imageQuantization,
+  onProgress
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const distanceCalculator = colorDistanceFormulaToColorDistance(colorDistanceFormula);
+    const imageQuantizer = imageQuantizationToImageQuantizer(distanceCalculator, imageQuantization);
+    let outPointContainer;
+    const iterator = imageQuantizer.quantize(image, palette);
+    const next = () => {
+      try {
+        const result = iterator.next();
+        if (result.done) {
+          resolve(outPointContainer);
+        } else {
+          if (result.value.pointContainer) {
+            outPointContainer = result.value.pointContainer;
+          }
+          if (onProgress)
+            onProgress(result.value.progress);
+          setImmediateImpl(next);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    };
+    setImmediateImpl(next);
+  });
+}
+function colorDistanceFormulaToColorDistance(colorDistanceFormula = "euclidean-bt709") {
+  switch (colorDistanceFormula) {
+    case "cie94-graphic-arts":
+      return new CIE94GraphicArts();
+    case "cie94-textiles":
+      return new CIE94Textiles();
+    case "ciede2000":
+      return new CIEDE2000();
+    case "color-metric":
+      return new CMetric();
+    case "euclidean":
+      return new Euclidean();
+    case "euclidean-bt709":
+      return new EuclideanBT709();
+    case "euclidean-bt709-noalpha":
+      return new EuclideanBT709NoAlpha();
+    case "manhattan":
+      return new Manhattan();
+    case "manhattan-bt709":
+      return new ManhattanBT709();
+    case "manhattan-nommyde":
+      return new ManhattanNommyde();
+    case "pngquant":
+      return new PNGQuant();
+    default:
+      throw new Error(`Unknown colorDistanceFormula ${colorDistanceFormula}`);
+  }
+}
+function imageQuantizationToImageQuantizer(distanceCalculator, imageQuantization = "floyd-steinberg") {
+  switch (imageQuantization) {
+    case "nearest":
+      return new NearestColor(distanceCalculator);
+    case "riemersma":
+      return new ErrorDiffusionRiemersma(distanceCalculator);
+    case "floyd-steinberg":
+      return new ErrorDiffusionArray(distanceCalculator, 0 /* FloydSteinberg */);
+    case "false-floyd-steinberg":
+      return new ErrorDiffusionArray(distanceCalculator, 1 /* FalseFloydSteinberg */);
+    case "stucki":
+      return new ErrorDiffusionArray(distanceCalculator, 2 /* Stucki */);
+    case "atkinson":
+      return new ErrorDiffusionArray(distanceCalculator, 3 /* Atkinson */);
+    case "jarvis":
+      return new ErrorDiffusionArray(distanceCalculator, 4 /* Jarvis */);
+    case "burkes":
+      return new ErrorDiffusionArray(distanceCalculator, 5 /* Burkes */);
+    case "sierra":
+      return new ErrorDiffusionArray(distanceCalculator, 6 /* Sierra */);
+    case "two-sierra":
+      return new ErrorDiffusionArray(distanceCalculator, 7 /* TwoSierra */);
+    case "sierra-lite":
+      return new ErrorDiffusionArray(distanceCalculator, 8 /* SierraLite */);
+    default:
+      throw new Error(`Unknown imageQuantization ${imageQuantization}`);
+  }
+}
+function paletteQuantizationToPaletteQuantizer(distanceCalculator, paletteQuantization = "wuquant", colors = 256) {
+  switch (paletteQuantization) {
+    case "neuquant":
+      return new NeuQuant(distanceCalculator, colors);
+    case "rgbquant":
+      return new RGBQuant(distanceCalculator, colors);
+    case "wuquant":
+      return new WuQuant(distanceCalculator, colors);
+    case "neuquant-float":
+      return new NeuQuantFloat(distanceCalculator, colors);
+    default:
+      throw new Error(`Unknown paletteQuantization ${paletteQuantization}`);
+  }
+}
+export {
+  applyPalette,
+  applyPaletteSync,
+  buildPalette,
+  buildPaletteSync,
+  constants_exports as constants,
+  conversion_exports as conversion,
+  distance_exports as distance,
+  image_exports as image,
+  palette_exports as palette,
+  quality_exports as quality,
+  utils_exports as utils
+};
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * cie94.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * ciede2000.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * cmetric.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * common.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * constants.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * ditherErrorDiffusionArray.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * euclidean.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * helper.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * hueStatistics.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * iq.ts - Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * lab2rgb.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * lab2xyz.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * manhattanNeuQuant.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * nearestColor.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * palette.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * pngQuant.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * point.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * pointContainer.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgb2hsl.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgb2lab.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgb2xyz.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * ssim.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * wuQuant.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * xyz2lab.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * xyz2rgb.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve
+ * MIT License
+ *
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * riemersma.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve TypeScript port:
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * colorHistogram.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve TypeScript port:
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * neuquant.ts - part of Image Quantization Library
+ */
+/**
+ * @preserve TypeScript port:
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgbquant.ts - part of Image Quantization Library
+ */
+//# sourceMappingURL=image-q.mjs.map