@pixerate/editor 0.94.0 → 0.96.0

package/dist/{chunk-ISDCJHTO.js → chunk-IB53LVGV.js}

@@ -1,9 +1,14 @@
 import {
   TILE,
   blendPixel,
+  createPigment,
+  lerpPigmentInto,
+  mixPigment8,
+  mixPigments,
+  setPigmentColor,
   tileCoord,
   tileKey
-} from "./chunk-D4ZCU72J.js";
+} from "./chunk-HEW6KDNI.js";
 
 // src/paint/brush.ts
 var DEFAULT_BRUSH = {
@@ -381,6 +386,18 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
       }
       if (s.lockTransparency && out[i + 3] === 0) continue;
       const src = s.mode === "erase" ? bg : cs;
+      if (s.blend === "pigment") {
+        const bytes = s.mode === "erase" ? s.background : s.color;
+        const as = src[3] * k;
+        if (!(as > 0)) continue;
+        const ao = as + out[i + 3] / 255 * (1 - as);
+        mixPigment8(out[i], out[i + 1], out[i + 2], bytes[0], bytes[1], bytes[2], as / ao, cb);
+        out[i] = Math.round(cb[0] * 255);
+        out[i + 1] = Math.round(cb[1] * 255);
+        out[i + 2] = Math.round(cb[2] * 255);
+        if (!s.lockTransparency) out[i + 3] = Math.round(ao * 255);
+        continue;
+      }
       for (let ch = 0; ch < 4; ch++) cb[ch] = out[i + ch] / 255;
       const o = blendPixel(s.blend, cb, src, k);
       out[i] = Math.round(o[0] * 255);
@@ -395,293 +412,231 @@ function coverageTileCoord(key) {
   return tileCoord(key);
 }
 
-// src/paint/pigment.ts
-var PIGMENT_BANDS = 36;
-var PIGMENT_LAMBDA_MIN = 380;
-var PIGMENT_LAMBDA_STEP = 10;
-var PIGMENT_WAVELENGTHS = Float32Array.from({ length: PIGMENT_BANDS }, (_, i) => PIGMENT_LAMBDA_MIN + i * PIGMENT_LAMBDA_STEP);
-var N = PIGMENT_BANDS;
-var LUT_NODES = 17;
-var R_MIN = 1e-4;
-var SCATTER_MIN = 0.01;
-function toLinear(v) {
-  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
-}
-function toEncoded(v) {
-  if (!(v > 0)) return 0;
-  if (v >= 1) return 1;
-  return v <= 31308e-7 ? 12.92 * v : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
-}
-function clamp01(v) {
-  return v > 0 ? v < 1 ? v : 1 : 0;
+// src/paint/mixer.ts
+var MIXING_MODELS = ["rgb", "pigment"];
+var DEFAULT_MIXER = {
+  wet: 0.5,
+  load: 0.5,
+  mix: 0.5,
+  loadEachStroke: true,
+  cleanEachStroke: true,
+  mixing: "rgb"
+};
+var MIXER_PICKUP_RATE = 0.25;
+var MIXER_DRAIN = 0.08;
+function normalizeMixer(raw = {}) {
+  const unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
+  const bool = (v, d) => typeof v === "boolean" ? v : d;
+  return {
+    wet: unit(raw.wet, DEFAULT_MIXER.wet),
+    load: unit(raw.load, DEFAULT_MIXER.load),
+    mix: unit(raw.mix, DEFAULT_MIXER.mix),
+    loadEachStroke: bool(raw.loadEachStroke, DEFAULT_MIXER.loadEachStroke),
+    cleanEachStroke: bool(raw.cleanEachStroke, DEFAULT_MIXER.cleanEachStroke),
+    mixing: raw.mixing === "pigment" ? "pigment" : "rgb"
+  };
 }
-function lobe(l, mu, s1, s2) {
-  const t = (l - mu) / (l < mu ? s1 : s2);
-  return Math.exp(-0.5 * t * t);
+var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
+function loadMixer(load, color) {
+  const c = (v) => Math.min(1, Math.max(0, Number.isFinite(v) ? v : 0));
+  return { reservoir: [c(color[0]), c(color[1]), c(color[2])], amount: 1, pickup: load.pickup };
 }
-function planck(nm, kelvin) {
-  const m = nm * 1e-9;
-  return 1 / (m ** 5 * (Math.exp(0.01438776877 / (m * kelvin)) - 1));
+function cleanMixer(load) {
+  return { reservoir: load.reservoir, amount: load.amount, pickup: null };
 }
-var weights = null;
-function rgbWeights() {
-  if (weights) return weights;
-  const w = new Float64Array(3 * N);
-  const m = [3.2404542, -1.5371385, -0.4985314, -0.969266, 1.8760108, 0.041556, 0.0556434, -0.2040259, 1.0572252];
-  for (let b = 0; b < N; b++) {
-    const l = PIGMENT_LAMBDA_MIN + b * PIGMENT_LAMBDA_STEP;
-    const e = planck(l, 6504);
-    const x = e * (1.056 * lobe(l, 599.8, 37.9, 31) + 0.362 * lobe(l, 442, 16, 26.7) - 0.065 * lobe(l, 501.1, 20.4, 26.2));
-    const y = e * (0.821 * lobe(l, 568.8, 46.9, 40.5) + 0.286 * lobe(l, 530.9, 16.3, 31.1));
-    const z = e * (1.217 * lobe(l, 437, 11.8, 36) + 0.681 * lobe(l, 459, 26, 13.8));
-    for (let c = 0; c < 3; c++) w[c * N + b] = m[c * 3] * x + m[c * 3 + 1] * y + m[c * 3 + 2] * z;
+var MixerStroke = class {
+  constructor(brush, settings, load, target) {
+    this.brush = brush;
+    this.target = target;
+    this.settings = normalizeMixer(settings);
+    this.walker = new DabWalker(brush);
+    this.reservoir = load.reservoir ? [load.reservoir[0], load.reservoir[1], load.reservoir[2]] : null;
+    this.amount = this.reservoir ? Math.min(1, Math.max(0, load.amount)) : 0;
+    this.pickup = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
+    this.pig = this.settings.mixing === "pigment" ? { res: createPigment(this.reservoir ?? [0, 0, 0]), pick: createPigment(this.pickup ?? [0, 0, 0]), paint: createPigment([0, 0, 0]), canvas: createPigment([0, 0, 0]) } : null;
   }
-  for (let c = 0; c < 3; c++) {
-    let sum = 0;
-    for (let b = 0; b < N; b++) sum += w[c * N + b];
-    for (let b = 0; b < N; b++) w[c * N + b] /= sum;
+  brush;
+  target;
+  dabCount = 0;
+  bounds = null;
+  walker;
+  smoothPos = null;
+  buf = new Float32Array(0);
+  settings;
+  reservoir;
+  amount;
+  pickup;
+  pig;
+  out = [0, 0, 0];
+  /** The brush load after the dabs so far. */
+  get load() {
+    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.pickup ? [...this.pickup] : null };
   }
-  return weights = w;
-}
-function fitCoefficients(r, g, b, coeffs) {
-  const w = rgbWeights();
-  const target = [r, g, b];
-  const res = new Float64Array(3);
-  const jac = new Float64Array(9);
-  const trial = new Float64Array(3);
-  let err = residual(coeffs, target, w, res, jac);
-  for (let it = 0; it < 60 && err > 1e-10; it++) {
-    const step = solve3(jac, res);
-    if (!step) break;
-    let scale = 1;
-    let next = Infinity;
-    for (let k = 0; k < 12; k++) {
-      for (let i = 0; i < 3; i++) trial[i] = coeffs[i] - scale * step[i];
-      next = residual(trial, target, w, null, null);
-      if (next < err) break;
-      scale *= 0.5;
-    }
-    if (!(next < err)) break;
-    coeffs.set(trial);
-    err = residual(coeffs, target, w, res, jac);
+  push(points) {
+    const dabs = [];
+    for (const p of points) this.walker.push(this.smooth(p), dabs);
+    return this.paint(dabs);
   }
-  return err;
-}
-function residual(c, target, w, res, jac) {
-  let r0 = -target[0];
-  let r1 = -target[1];
-  let r2 = -target[2];
-  if (jac) jac.fill(0);
-  for (let b = 0; b < N; b++) {
-    const x = b / (N - 1);
-    const z = (c[0] * x + c[1]) * x + c[2];
-    const q = 1 + z * z;
-    const sq = Math.sqrt(q);
-    const s = 0.5 + z / (2 * sq);
-    r0 += w[b] * s;
-    r1 += w[N + b] * s;
-    r2 += w[2 * N + b] * s;
-    if (jac) {
-      const ds = 1 / (2 * q * sq);
-      for (let k = 0; k < 3; k++) {
-        const wd = w[k * N + b] * ds;
-        jac[k * 3] += wd * x * x;
-        jac[k * 3 + 1] += wd * x;
-        jac[k * 3 + 2] += wd;
-      }
-    }
+  finish(last) {
+    const dabs = [];
+    if (last && this.smoothPos && (this.smoothPos.x !== last.x || this.smoothPos.y !== last.y)) this.walker.push(last, dabs);
+    this.walker.finish(dabs);
+    return this.paint(dabs);
   }
-  if (res) {
-    res[0] = r0;
-    res[1] = r1;
-    res[2] = r2;
+  smooth(p) {
+    const a = 1 - Math.min(0.95, Math.max(0, this.brush.smoothing));
+    const cur = this.smoothPos;
+    const n = cur && a < 1 ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
+    this.smoothPos = n;
+    return n;
   }
-  return r0 * r0 + r1 * r1 + r2 * r2;
-}
-function solve3(a, v) {
-  const [a0, a1, a2, a3, a4, a5, a6, a7, a8] = a;
-  const c0 = a4 * a8 - a5 * a7;
-  const c1 = a5 * a6 - a3 * a8;
-  const c2 = a3 * a7 - a4 * a6;
-  const det = a0 * c0 + a1 * c1 + a2 * c2;
-  if (!(Math.abs(det) > 1e-300)) return null;
-  const [v0, v1, v2] = v;
-  return [
-    (v0 * c0 + a1 * (a5 * v2 - v1 * a8) + a2 * (v1 * a7 - a4 * v2)) / det,
-    (a0 * (v1 * a8 - a5 * v2) + v0 * c1 + a2 * (a3 * v2 - v1 * a6)) / det,
-    (a0 * (a4 * v2 - v1 * a7) + a1 * (v1 * a6 - a3 * v2) + v0 * c2) / det
-  ];
-}
-var candidate = new Float64Array(3);
-function fitNode(r, g, b, coeffs) {
-  let best = fitCoefficients(r, g, b, coeffs);
-  if (best <= 1e-12) return;
-  candidate.fill(0);
-  let err = fitCoefficients(r, g, b, candidate);
-  if (err < best) {
-    best = err;
-    coeffs.set(candidate);
+  /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
+  mix(a, pa, b, pb, t) {
+    const o = this.out;
+    if (pa && pb) lerpPigmentInto(pa, pb, t, o, 0);
+    else for (let c = 0; c < 3; c++) o[c] = a[c] + (b[c] - a[c]) * t;
+    return o;
   }
-  if (best <= 1e-12) return;
-  const max = Math.max(r, g, b);
-  if (!(max > 0) || max >= 0.5) return;
-  candidate.fill(0);
-  const steps = 32;
-  for (let i = 0; i <= steps; i++) {
-    const scale = 0.5 * Math.pow(max / 0.5, i / steps) / max;
-    err = fitCoefficients(r * scale, g * scale, b * scale, candidate);
+  paint(dabs) {
+    const rects = [];
+    for (const d of dabs) {
+      const rect = dabRect(d, this.brush.hardness);
+      const n = rect.width * rect.height;
+      if (this.buf.length < n) this.buf = new Float32Array(n);
+      const cov = this.buf.subarray(0, n);
+      rasterizeDab({ ...d, alpha: 1 }, this.brush.hardness, rect, cov);
+      this.dab(d, rect, cov);
+      rects.push(rect);
+      this.bounds = union(this.bounds, rect);
+      this.dabCount++;
+    }
+    return rects;
   }
-  if (err < best) coeffs.set(candidate);
-}
-function sigmoidSpectrum(c, out, offset) {
-  for (let b = 0; b < N; b++) {
-    const x = b / (N - 1);
-    const z = (c[0] * x + c[1]) * x + c[2];
-    out[offset + b] = 0.5 + z / (2 * Math.sqrt(1 + z * z));
+  // The tile last looked up by `locate` (and whether it came from `writeTile`).
+  tx = NaN;
+  ty = NaN;
+  tile = null;
+  writable = false;
+  /** Index of document pixel (dx, dy) in `this.tile`, or -1 when reading an empty tile. */
+  locate(dx, dy, write) {
+    const t = this.target;
+    const lx = dx - t.offset.x;
+    const ly = dy - t.offset.y;
+    const tx = Math.floor(lx / TILE);
+    const ty = Math.floor(ly / TILE);
+    if (tx !== this.tx || ty !== this.ty || write && !this.writable) {
+      this.tx = tx;
+      this.ty = ty;
+      this.tile = write ? t.writeTile(tx, ty) : t.readTile(tx, ty);
+      this.writable = write;
+    }
+    return this.tile ? ((ly - ty * TILE) * TILE + (lx - tx * TILE)) * 4 : -1;
   }
-}
-var NODES = Float64Array.from({ length: LUT_NODES }, (_, i) => toLinear(i / (LUT_NODES - 1)));
-var table = null;
-function spectrumTable() {
-  if (table) return table;
-  const n = LUT_NODES;
-  const t = new Float32Array(n * n * n * N);
-  const row = new Float64Array(3);
-  const coeffs = new Float64Array(3);
-  for (let r = 0; r < n; r++) {
-    for (let g = 0; g < n; g++) {
-      coeffs.set(row);
-      for (let b = 0; b < n; b++) {
-        fitNode(NODES[r], NODES[g], NODES[b], coeffs);
-        if (b === 0) row.set(coeffs);
-        sigmoidSpectrum(coeffs, t, ((r * n + g) * n + b) * N);
+  dab(d, rect, cov) {
+    const { wet, mix, load } = this.settings;
+    const pig = this.pig;
+    const w = rect.width;
+    this.tx = NaN;
+    let ar = 0;
+    let ag = 0;
+    let ab = 0;
+    let wsum = 0;
+    let asum = 0;
+    for (let yy = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < w; xx++) {
+        const k = cov[yy * w + xx];
+        if (k <= 0) continue;
+        wsum += k;
+        const i = this.locate(rect.x + xx, rect.y + yy, false);
+        if (i < 0) continue;
+        const px = this.tile;
+        const al = px[i + 3] / 255;
+        if (al <= 0) continue;
+        const ka = k * al;
+        ar += px[i] / 255 * ka;
+        ag += px[i + 1] / 255 * ka;
+        ab += px[i + 2] / 255 * ka;
+        asum += ka;
       }
     }
+    if (asum > 1e-6 && wet > 0) {
+      const canvas = [ar / asum, ag / asum, ab / asum];
+      if (!this.pickup) this.pickup = canvas;
+      else {
+        if (pig) setPigmentColor(pig.canvas, canvas[0], canvas[1], canvas[2]);
+        const o = this.mix(this.pickup, pig?.pick ?? null, canvas, pig?.canvas ?? null, MIXER_PICKUP_RATE * wet * (asum / Math.max(1e-6, wsum)));
+        this.pickup = [o[0], o[1], o[2]];
+      }
+      if (pig) setPigmentColor(pig.pick, this.pickup[0], this.pickup[1], this.pickup[2]);
+    }
+    const res = this.reservoir;
+    const wr = res ? this.amount * (1 - mix * wet) : 0;
+    const wp = this.pickup ? mix * wet : 0;
+    const total = wr + wp;
+    if (total > 1e-6) {
+      const paint = res && this.pickup ? [...this.mix(res, pig?.res ?? null, this.pickup, pig?.pick ?? null, wp / total)] : [...res ?? this.pickup];
+      if (pig) setPigmentColor(pig.paint, paint[0], paint[1], paint[2]);
+      const dep = Math.min(1, total) * this.brush.flow * this.brush.opacity * d.opacity;
+      if (dep > 0) this.deposit(rect, cov, paint, dep);
+    }
+    this.amount *= 1 - MIXER_DRAIN * (1 - load);
   }
-  return table = t;
-}
-var cell = new Int32Array(3);
-var frac = new Float64Array(3);
-var linear = new Float64Array(3);
-function locate(channel, encoded) {
-  const v = clamp01(encoded);
-  const i = Math.min(LUT_NODES - 2, Math.floor(v * (LUT_NODES - 1)));
-  const lo = NODES[i];
-  const lin = toLinear(v);
-  const f = (lin - lo) / (NODES[i + 1] - lo);
-  cell[channel] = i;
-  frac[channel] = f < 0 ? 0 : f > 1 ? 1 : f;
-  linear[channel] = lin;
-}
-function rgbToReflectance(r, g, b, out = new Float32Array(N)) {
-  const t = spectrumTable();
-  const n = LUT_NODES;
-  locate(0, r);
-  locate(1, g);
-  locate(2, b);
-  const [ri, gi, bi] = cell;
-  const [rf, gf, bf] = frac;
-  out.fill(0);
-  for (let corner = 0; corner < 8; corner++) {
-    const dr = corner >> 2;
-    const dg = corner >> 1 & 1;
-    const db = corner & 1;
-    const weight = (dr ? rf : 1 - rf) * (dg ? gf : 1 - gf) * (db ? bf : 1 - bf);
-    if (weight === 0) continue;
-    const base = (((ri + dr) * n + gi + dg) * n + bi + db) * N;
-    for (let k = 0; k < N; k++) out[k] += weight * t[base + k];
-  }
-  return out;
-}
-function reflectanceToRgb(reflectance, out = [0, 0, 0]) {
-  const w = rgbWeights();
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  for (let k = 0; k < N; k++) {
-    const v = reflectance[k];
-    r += w[k] * v;
-    g += w[N + k] * v;
-    b += w[2 * N + k] * v;
-  }
-  out[0] = toEncoded(r);
-  out[1] = toEncoded(g);
-  out[2] = toEncoded(b);
-  return out;
-}
-var spectrumScratch = new Float32Array(N);
-function createPigment(color, options = {}) {
-  const pigment = { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(N), scatter: 1 };
-  return setPigmentColor(pigment, color[0], color[1], color[2], options.strength);
-}
-function setPigmentColor(pigment, r, g, b, strength = pigment.strength) {
-  const R = rgbToReflectance(r, g, b, spectrumScratch);
-  const ks = pigment.ks;
-  for (let k = 0; k < N; k++) {
-    const v = R[k] > R_MIN ? R[k] : R_MIN;
-    ks[k] = (1 - v) * (1 - v) / (2 * v);
-  }
-  pigment.rgb[0] = clamp01(r);
-  pigment.rgb[1] = clamp01(g);
-  pigment.rgb[2] = clamp01(b);
-  pigment.strength = Number.isFinite(strength) && strength > 0 ? strength : 1;
-  const y = 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2];
-  pigment.scatter = y > SCATTER_MIN ? y : SCATTER_MIN;
-  return pigment;
-}
-function ksToRgb(ks, out, offset) {
-  const w = rgbWeights();
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  for (let k = 0; k < N; k++) {
-    const q = ks[k];
-    const v = 1 + q - Math.sqrt(q * q + 2 * q);
-    r += w[k] * v;
-    g += w[N + k] * v;
-    b += w[2 * N + k] * v;
-  }
-  out[offset] = toEncoded(r);
-  out[offset + 1] = toEncoded(g);
-  out[offset + 2] = toEncoded(b);
-}
-var mixScratch = new Float64Array(N);
-function mixPigments(colors, weights2) {
-  if (colors.length === 0) throw new Error("mixPigments needs at least one colour.");
-  if (weights2.length !== colors.length) throw new Error(`mixPigments got ${colors.length} colours but ${weights2.length} weights; pass one weight per colour.`);
-  const pigments = colors.map((c) => "ks" in c ? c : createPigment(c));
-  let total = 0;
-  for (let i = 0; i < pigments.length; i++) {
-    const w = weights2[i];
-    if (!(Number.isFinite(w) && w >= 0)) throw new Error(`Weight ${i} is ${w}; weights must be finite and \u2265 0.`);
-    total += w * pigments[i].strength * pigments[i].scatter;
-  }
-  if (!(total > 0)) throw new Error("mixPigments needs at least one positive weight.");
-  mixScratch.fill(0);
-  for (let i = 0; i < pigments.length; i++) {
-    const p = pigments[i];
-    const c = weights2[i] * p.strength * p.scatter / total;
-    if (c === 0) continue;
-    for (let k = 0; k < N; k++) mixScratch[k] += c * p.ks[k];
+  /** Lays `paint` over the pixels under the dab at `dep` × coverage (× selection). */
+  deposit(rect, cov, paint, dep) {
+    const t = this.target;
+    const sel = t.selection;
+    const pig = this.pig;
+    const w = rect.width;
+    const o = this.out;
+    let lastKey = -1;
+    for (let yy = 0; yy < rect.height; yy++) {
+      const dy = rect.y + yy;
+      for (let xx = 0; xx < w; xx++) {
+        let k = cov[yy * w + xx] * dep;
+        if (k <= 0) continue;
+        const dx = rect.x + xx;
+        if (sel) {
+          if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
+          k *= sel.data[dy * sel.width + dx] / 255;
+          if (k <= 0) continue;
+        }
+        if (k > 1) k = 1;
+        if (t.lockTransparency) {
+          const ri = this.locate(dx, dy, false);
+          if (ri < 0 || this.tile[ri + 3] === 0) continue;
+        }
+        const i = this.locate(dx, dy, true);
+        const px = this.tile;
+        const a = px[i + 3] / 255;
+        const na = t.lockTransparency ? a : a + (1 - a) * k;
+        const share = t.lockTransparency ? k : na > 0 ? k / na : 1;
+        if (a <= 0 || share >= 1) {
+          o[0] = paint[0];
+          o[1] = paint[1];
+          o[2] = paint[2];
+        } else if (pig) {
+          const key = px[i] << 16 | px[i + 1] << 8 | px[i + 2];
+          if (key !== lastKey) {
+            setPigmentColor(pig.canvas, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
+            lastKey = key;
+          }
+          lerpPigmentInto(pig.canvas, pig.paint, share, o, 0);
+        } else {
+          for (let c = 0; c < 3; c++) o[c] = px[i + c] / 255 + (paint[c] - px[i + c] / 255) * share;
+        }
+        px[i] = Math.round(o[0] * 255);
+        px[i + 1] = Math.round(o[1] * 255);
+        px[i + 2] = Math.round(o[2] * 255);
+        px[i + 3] = Math.round(na * 255);
+      }
+    }
   }
-  const out = [0, 0, 0];
-  ksToRgb(mixScratch, out, 0);
-  return out;
-}
-function lerpPigment(a, b, t) {
-  const u = clamp01(t);
-  return mixPigments([a, b], [1 - u, u]);
-}
-function lerpPigmentInto(a, b, t, out, offset = 0) {
-  const u = t > 0 ? t < 1 ? t : 1 : 0;
-  const wa = (1 - u) * a.strength * a.scatter;
-  const wb = u * b.strength * b.scatter;
-  const ca = wa / (wa + wb);
-  const cb = 1 - ca;
-  const ka = a.ks;
-  const kb = b.ks;
-  for (let k = 0; k < N; k++) mixScratch[k] = ca * ka[k] + cb * kb[k];
-  ksToRgb(mixScratch, out, offset);
+};
+function union(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
 
 // src/paint/pigment-tools.ts
@@ -765,17 +720,15 @@ export {
   StrokeCoverage,
   applyStrokeToTile,
   coverageTileCoord,
-  PIGMENT_BANDS,
-  PIGMENT_LAMBDA_MIN,
-  PIGMENT_LAMBDA_STEP,
-  PIGMENT_WAVELENGTHS,
-  rgbToReflectance,
-  reflectanceToRgb,
-  createPigment,
-  setPigmentColor,
-  mixPigments,
-  lerpPigment,
-  lerpPigmentInto,
+  MIXING_MODELS,
+  DEFAULT_MIXER,
+  MIXER_PICKUP_RATE,
+  MIXER_DRAIN,
+  normalizeMixer,
+  EMPTY_MIXER_LOAD,
+  loadMixer,
+  cleanMixer,
+  MixerStroke,
   createPigmentTools
 };
-//# sourceMappingURL=chunk-ISDCJHTO.js.map
+//# sourceMappingURL=chunk-IB53LVGV.js.map