@pixerate/editor 0.94.0 → 0.96.0

package/dist/{chunk-4F3YDIWW.cjs → chunk-ZZOTHJ4K.cjs}

@@ -1,9 +1,14 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2; var _class3;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4;
 
 
 
 
-var _chunkZOOEX3WTcjs = require('./chunk-ZOOEX3WT.cjs');
+
+
+
+
+
+var _chunkCRMAXIUVcjs = require('./chunk-CRMAXIUV.cjs');
 
 // src/paint/brush.ts
 var DEFAULT_BRUSH = {
@@ -216,41 +221,41 @@ function rasterizeDab(d, hardness, rect, out) {
     }
   }
 }
-var TILE_PIXELS = _chunkZOOEX3WTcjs.TILE * _chunkZOOEX3WTcjs.TILE;
+var TILE_PIXELS = _chunkCRMAXIUVcjs.TILE * _chunkCRMAXIUVcjs.TILE;
 var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this); }
   __init4() {this.tiles = /* @__PURE__ */ new Map()}
   __init5() {this.bounds = null}
   __init6() {this.dirty = /* @__PURE__ */ new Set()}
   get(x, y) {
-    const tx = Math.floor(x / _chunkZOOEX3WTcjs.TILE);
-    const ty = Math.floor(y / _chunkZOOEX3WTcjs.TILE);
-    const t = this.tiles.get(_chunkZOOEX3WTcjs.tileKey.call(void 0, tx, ty));
-    return t ? t[(y - ty * _chunkZOOEX3WTcjs.TILE) * _chunkZOOEX3WTcjs.TILE + (x - tx * _chunkZOOEX3WTcjs.TILE)] : 0;
+    const tx = Math.floor(x / _chunkCRMAXIUVcjs.TILE);
+    const ty = Math.floor(y / _chunkCRMAXIUVcjs.TILE);
+    const t = this.tiles.get(_chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty));
+    return t ? t[(y - ty * _chunkCRMAXIUVcjs.TILE) * _chunkCRMAXIUVcjs.TILE + (x - tx * _chunkCRMAXIUVcjs.TILE)] : 0;
   }
   /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */
   accumulate(rect, vals, ceil) {
     if (rect.width <= 0 || rect.height <= 0) return;
     const w = rect.width;
-    const tx0 = Math.floor(rect.x / _chunkZOOEX3WTcjs.TILE);
-    const ty0 = Math.floor(rect.y / _chunkZOOEX3WTcjs.TILE);
-    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkZOOEX3WTcjs.TILE);
-    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkZOOEX3WTcjs.TILE);
+    const tx0 = Math.floor(rect.x / _chunkCRMAXIUVcjs.TILE);
+    const ty0 = Math.floor(rect.y / _chunkCRMAXIUVcjs.TILE);
+    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkCRMAXIUVcjs.TILE);
+    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkCRMAXIUVcjs.TILE);
     let touched = false;
     for (let ty = ty0; ty <= ty1; ty++) {
       for (let tx = tx0; tx <= tx1; tx++) {
-        const x0 = Math.max(rect.x, tx * _chunkZOOEX3WTcjs.TILE);
-        const y0 = Math.max(rect.y, ty * _chunkZOOEX3WTcjs.TILE);
-        const x1 = Math.min(rect.x + rect.width, tx * _chunkZOOEX3WTcjs.TILE + _chunkZOOEX3WTcjs.TILE);
-        const y1 = Math.min(rect.y + rect.height, ty * _chunkZOOEX3WTcjs.TILE + _chunkZOOEX3WTcjs.TILE);
+        const x0 = Math.max(rect.x, tx * _chunkCRMAXIUVcjs.TILE);
+        const y0 = Math.max(rect.y, ty * _chunkCRMAXIUVcjs.TILE);
+        const x1 = Math.min(rect.x + rect.width, tx * _chunkCRMAXIUVcjs.TILE + _chunkCRMAXIUVcjs.TILE);
+        const y1 = Math.min(rect.y + rect.height, ty * _chunkCRMAXIUVcjs.TILE + _chunkCRMAXIUVcjs.TILE);
         let tile;
         for (let y = y0; y < y1; y++) {
           const row = (y - rect.y) * w;
-          const trow = (y - ty * _chunkZOOEX3WTcjs.TILE) * _chunkZOOEX3WTcjs.TILE;
+          const trow = (y - ty * _chunkCRMAXIUVcjs.TILE) * _chunkCRMAXIUVcjs.TILE;
           for (let x = x0; x < x1; x++) {
             const v = vals[row + (x - rect.x)];
             if (v <= 0) continue;
             if (!tile) {
-              const key = _chunkZOOEX3WTcjs.tileKey.call(void 0, tx, ty);
+              const key = _chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty);
               tile = this.tiles.get(key);
               if (!tile) {
                 tile = new Float32Array(TILE_PIXELS);
@@ -259,7 +264,7 @@ var CoverageMap = (_class2 = class {constructor() { _class2.prototype.__init4.ca
               this.dirty.add(key);
               touched = true;
             }
-            const ti = trow + (x - tx * _chunkZOOEX3WTcjs.TILE);
+            const ti = trow + (x - tx * _chunkCRMAXIUVcjs.TILE);
             const c = tile[ti];
             if (ceil > c) tile[ti] = c + v * (ceil - c);
           }
@@ -331,35 +336,35 @@ var StrokeCoverage = (_class3 = class {
 }, _class3);
 function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}) {
   const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
-  const ox = tx * _chunkZOOEX3WTcjs.TILE + s.offset.x;
-  const oy = ty * _chunkZOOEX3WTcjs.TILE + s.offset.y;
+  const ox = tx * _chunkCRMAXIUVcjs.TILE + s.offset.x;
+  const oy = ty * _chunkCRMAXIUVcjs.TILE + s.offset.y;
   let x0 = 0;
   let y0 = 0;
-  let x1 = _chunkZOOEX3WTcjs.TILE;
-  let y1 = _chunkZOOEX3WTcjs.TILE;
+  let x1 = _chunkCRMAXIUVcjs.TILE;
+  let y1 = _chunkCRMAXIUVcjs.TILE;
   if (options.region) {
     const r = options.region;
     x0 = Math.max(0, Math.floor(r.x) - ox);
     y0 = Math.max(0, Math.floor(r.y) - oy);
-    x1 = Math.min(_chunkZOOEX3WTcjs.TILE, Math.ceil(r.x + r.width) - ox);
-    y1 = Math.min(_chunkZOOEX3WTcjs.TILE, Math.ceil(r.y + r.height) - oy);
+    x1 = Math.min(_chunkCRMAXIUVcjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunkCRMAXIUVcjs.TILE, Math.ceil(r.y + r.height) - oy);
     if (x1 <= x0 || y1 <= y0) return out;
     if (options.into) {
-      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * _chunkZOOEX3WTcjs.TILE + x0) * channels, (y * _chunkZOOEX3WTcjs.TILE + x1) * channels), (y * _chunkZOOEX3WTcjs.TILE + x0) * channels);
+      for (let y = y0; y < y1; y++) out.set(tileData.subarray((y * _chunkCRMAXIUVcjs.TILE + x0) * channels, (y * _chunkCRMAXIUVcjs.TILE + x1) * channels), (y * _chunkCRMAXIUVcjs.TILE + x0) * channels);
     }
   }
   const sel = s.selection;
   const cb = [0, 0, 0, 0];
   const cs = [s.color[0] / 255, s.color[1] / 255, s.color[2] / 255, s.color[3] / 255];
   const bg = [s.background[0] / 255, s.background[1] / 255, s.background[2] / 255, s.background[3] / 255];
-  const aligned = s.offset.x % _chunkZOOEX3WTcjs.TILE === 0 && s.offset.y % _chunkZOOEX3WTcjs.TILE === 0;
-  const covTile = aligned ? coverage.tiles.get(_chunkZOOEX3WTcjs.tileKey.call(void 0, Math.floor(ox / _chunkZOOEX3WTcjs.TILE), Math.floor(oy / _chunkZOOEX3WTcjs.TILE))) : void 0;
+  const aligned = s.offset.x % _chunkCRMAXIUVcjs.TILE === 0 && s.offset.y % _chunkCRMAXIUVcjs.TILE === 0;
+  const covTile = aligned ? coverage.tiles.get(_chunkCRMAXIUVcjs.tileKey.call(void 0, Math.floor(ox / _chunkCRMAXIUVcjs.TILE), Math.floor(oy / _chunkCRMAXIUVcjs.TILE))) : void 0;
   if (aligned && !covTile) return out;
   for (let y = y0; y < y1; y++) {
     const dy = oy + y;
     for (let x = x0; x < x1; x++) {
       const dx = ox + x;
-      const c = covTile ? covTile[y * _chunkZOOEX3WTcjs.TILE + x] : coverage.get(dx, dy);
+      const c = covTile ? covTile[y * _chunkCRMAXIUVcjs.TILE + x] : coverage.get(dx, dy);
       if (c <= 0) continue;
       let k = c * s.opacity;
       if (sel) {
@@ -368,7 +373,7 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
       }
       if (k > 1) k = 1;
       if (k <= 0) continue;
-      const p = y * _chunkZOOEX3WTcjs.TILE + x;
+      const p = y * _chunkCRMAXIUVcjs.TILE + x;
       if (channels === 1) {
         const target = s.mode === "erase" ? s.background[0] : s.color[0];
         out[p] = Math.round(out[p] + (target - out[p]) * k);
@@ -381,8 +386,20 @@ 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);
+        _chunkCRMAXIUVcjs.mixPigment8.call(void 0, 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 = _chunkZOOEX3WTcjs.blendPixel.call(void 0, s.blend, cb, src, k);
+      const o = _chunkCRMAXIUVcjs.blendPixel.call(void 0, s.blend, cb, src, k);
       out[i] = Math.round(o[0] * 255);
       out[i + 1] = Math.round(o[1] * 255);
       out[i + 2] = Math.round(o[2] * 255);
@@ -392,296 +409,234 @@ function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}
   return out;
 }
 function coverageTileCoord(key) {
-  return _chunkZOOEX3WTcjs.tileCoord.call(void 0, 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;
+  return _chunkCRMAXIUVcjs.tileCoord.call(void 0, key);
+}
+
+// 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 = (_class4 = class {
+  constructor(brush, settings, load, target) {;_class4.prototype.__init11.call(this);_class4.prototype.__init12.call(this);_class4.prototype.__init13.call(this);_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);_class4.prototype.__init17.call(this);_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);
+    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: _chunkCRMAXIUVcjs.createPigment.call(void 0, _nullishCoalesce(this.reservoir, () => ( [0, 0, 0]))), pick: _chunkCRMAXIUVcjs.createPigment.call(void 0, _nullishCoalesce(this.pickup, () => ( [0, 0, 0]))), paint: _chunkCRMAXIUVcjs.createPigment.call(void 0, [0, 0, 0]), canvas: _chunkCRMAXIUVcjs.createPigment.call(void 0, [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;
+  
+  
+  __init11() {this.dabCount = 0}
+  __init12() {this.bounds = null}
+  
+  __init13() {this.smoothPos = null}
+  __init14() {this.buf = new Float32Array(0)}
+  
+  
+  
+  
+  
+  __init15() {this.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) _chunkCRMAXIUVcjs.lerpPigmentInto.call(void 0, 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`).
+  __init16() {this.tx = NaN}
+  __init17() {this.ty = NaN}
+  __init18() {this.tile = null}
+  __init19() {this.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 / _chunkCRMAXIUVcjs.TILE);
+    const ty = Math.floor(ly / _chunkCRMAXIUVcjs.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 * _chunkCRMAXIUVcjs.TILE) * _chunkCRMAXIUVcjs.TILE + (lx - tx * _chunkCRMAXIUVcjs.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) _chunkCRMAXIUVcjs.setPigmentColor.call(void 0, pig.canvas, canvas[0], canvas[1], canvas[2]);
+        const o = this.mix(this.pickup, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _ => _.pick]), () => ( null)), canvas, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _2 => _2.canvas]), () => ( null)), MIXER_PICKUP_RATE * wet * (asum / Math.max(1e-6, wsum)));
+        this.pickup = [o[0], o[1], o[2]];
+      }
+      if (pig) _chunkCRMAXIUVcjs.setPigmentColor.call(void 0, 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, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _3 => _3.res]), () => ( null)), this.pickup, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _4 => _4.pick]), () => ( null)), wp / total)] : [..._nullishCoalesce(res, () => ( this.pickup))];
+      if (pig) _chunkCRMAXIUVcjs.setPigmentColor.call(void 0, 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) {
+            _chunkCRMAXIUVcjs.setPigmentColor.call(void 0, pig.canvas, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
+            lastKey = key;
+          }
+          _chunkCRMAXIUVcjs.lerpPigmentInto.call(void 0, 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);
+}, _class4);
+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
@@ -734,8 +689,8 @@ function createPigmentTools() {
       const rgbs = items.map((item, i) => parseHex(item.color, i));
       const total = items.reduce((sum, item) => sum + item.weight, 0);
       if (!(total > 0)) throw new Error("Every weight is 0; give at least one colour a weight above 0.");
-      const pigments = rgbs.map((rgb, i) => createPigment(rgb, { strength: items[i].strength }));
-      const mixed = mixPigments(pigments, items.map((item) => item.weight));
+      const pigments = rgbs.map((rgb, i) => _chunkCRMAXIUVcjs.createPigment.call(void 0, rgb, { strength: items[i].strength }));
+      const mixed = _chunkCRMAXIUVcjs.mixPigments.call(void 0, pigments, items.map((item) => item.weight));
       const lerp = [0, 1, 2].map((c) => rgbs.reduce((sum, rgb, i) => sum + rgb[c] * items[i].weight, 0) / total);
       return {
         mixed: toHex(mixed),
@@ -775,7 +730,5 @@ function createPigmentTools() {
 
 
 
-
-
-exports.DEFAULT_BRUSH = DEFAULT_BRUSH; exports.MAX_BRUSH_SIZE = MAX_BRUSH_SIZE; exports.normalizeBrush = normalizeBrush; exports.tipShape = tipShape; exports.tipFalloff = tipFalloff; exports.tipReach = tipReach; exports.dabCoverage = dabCoverage; exports.smoothPoints = smoothPoints; exports.DabWalker = DabWalker; exports.walkDabs = walkDabs; exports.dabRect = dabRect; exports.rasterizeDab = rasterizeDab; exports.CoverageMap = CoverageMap; exports.StrokeCoverage = StrokeCoverage; exports.applyStrokeToTile = applyStrokeToTile; exports.coverageTileCoord = coverageTileCoord; exports.PIGMENT_BANDS = PIGMENT_BANDS; exports.PIGMENT_LAMBDA_MIN = PIGMENT_LAMBDA_MIN; exports.PIGMENT_LAMBDA_STEP = PIGMENT_LAMBDA_STEP; exports.PIGMENT_WAVELENGTHS = PIGMENT_WAVELENGTHS; exports.rgbToReflectance = rgbToReflectance; exports.reflectanceToRgb = reflectanceToRgb; exports.createPigment = createPigment; exports.setPigmentColor = setPigmentColor; exports.mixPigments = mixPigments; exports.lerpPigment = lerpPigment; exports.lerpPigmentInto = lerpPigmentInto; exports.createPigmentTools = createPigmentTools;
-//# sourceMappingURL=chunk-4F3YDIWW.cjs.map
+exports.DEFAULT_BRUSH = DEFAULT_BRUSH; exports.MAX_BRUSH_SIZE = MAX_BRUSH_SIZE; exports.normalizeBrush = normalizeBrush; exports.tipShape = tipShape; exports.tipFalloff = tipFalloff; exports.tipReach = tipReach; exports.dabCoverage = dabCoverage; exports.smoothPoints = smoothPoints; exports.DabWalker = DabWalker; exports.walkDabs = walkDabs; exports.dabRect = dabRect; exports.rasterizeDab = rasterizeDab; exports.CoverageMap = CoverageMap; exports.StrokeCoverage = StrokeCoverage; exports.applyStrokeToTile = applyStrokeToTile; exports.coverageTileCoord = coverageTileCoord; exports.MIXING_MODELS = MIXING_MODELS; exports.DEFAULT_MIXER = DEFAULT_MIXER; exports.MIXER_PICKUP_RATE = MIXER_PICKUP_RATE; exports.MIXER_DRAIN = MIXER_DRAIN; exports.normalizeMixer = normalizeMixer; exports.EMPTY_MIXER_LOAD = EMPTY_MIXER_LOAD; exports.loadMixer = loadMixer; exports.cleanMixer = cleanMixer; exports.MixerStroke = MixerStroke; exports.createPigmentTools = createPigmentTools;
+//# sourceMappingURL=chunk-ZZOTHJ4K.cjs.map