@pixerate/editor 0.115.0 → 0.116.0

package/dist/chunk-TCKIXI46.cjs

@@ -1,1136 +0,0 @@
-"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 _class5; var _class6; var _class7;
-
-
-
-
-
-
-
-
-
-
-
-var _chunkTFOPHZ3Ucjs = require('./chunk-TFOPHZ3U.cjs');
-
-// src/paint/brush.ts
-var DEFAULT_BRUSH = {
-  size: 20,
-  hardness: 1,
-  spacing: 0.1,
-  angle: 0,
-  roundness: 1,
-  opacity: 1,
-  flow: 1,
-  smoothing: 0,
-  pressureSize: true,
-  pressureOpacity: false,
-  blend: "normal"
-};
-var MAX_BRUSH_SIZE = 2500;
-function normalizeBrush(raw = {}) {
-  const num = (v, lo, hi, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : d;
-  return {
-    size: num(raw.size, 1, MAX_BRUSH_SIZE, DEFAULT_BRUSH.size),
-    hardness: num(raw.hardness, 0, 1, DEFAULT_BRUSH.hardness),
-    spacing: num(raw.spacing, 0.01, 10, DEFAULT_BRUSH.spacing),
-    angle: num(raw.angle, -360, 360, DEFAULT_BRUSH.angle),
-    roundness: num(raw.roundness, 0.01, 1, DEFAULT_BRUSH.roundness),
-    opacity: num(raw.opacity, 0, 1, DEFAULT_BRUSH.opacity),
-    flow: num(raw.flow, 0, 1, DEFAULT_BRUSH.flow),
-    smoothing: num(raw.smoothing, 0, 0.95, DEFAULT_BRUSH.smoothing),
-    pressureSize: typeof raw.pressureSize === "boolean" ? raw.pressureSize : DEFAULT_BRUSH.pressureSize,
-    pressureOpacity: typeof raw.pressureOpacity === "boolean" ? raw.pressureOpacity : DEFAULT_BRUSH.pressureOpacity,
-    blend: _nullishCoalesce(raw.blend, () => ( "normal"))
-  };
-}
-var TIP_SHAPE = [
-  [0, 0.664],
-  [0.14, 0.58],
-  [0.28, 0.5],
-  [0.4, 0.44],
-  [0.52, 0.36],
-  [0.63, 0.29],
-  [0.7, 0.24],
-  [0.78, 0.19],
-  [0.84, 0.15],
-  [0.89, 0.11],
-  [1, 0]
-];
-var TIP_EDGE_PX = 1.2;
-var SMALL_TIP_RADIUS = 3;
-var SUBPIXEL = [-0.375, -0.125, 0.125, 0.375];
-function tipShape(radius, hardness) {
-  const h = (Number.isNaN(hardness) ? 0 : Math.min(1, Math.max(0, hardness))) * 10;
-  const i = Math.min(9, Math.floor(h));
-  const t = h - i;
-  const a = TIP_SHAPE[i];
-  const b = TIP_SHAPE[i + 1];
-  const r0 = a[0] + (b[0] - a[0]) * t;
-  const s = a[1] + (b[1] - a[1]) * t;
-  const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
-  const edge = Math.max(0.25, Math.min(TIP_EDGE_PX, 0.3 * r));
-  return [Math.max(0, Math.min(r0 * r, r - edge)), Math.max(1e-3, s * r, edge)];
-}
-function softExp(u) {
-  let g = Math.min(1, Math.max(0, 1 - u / 64));
-  for (let k = 0; k < 6; k++) g *= g;
-  return g;
-}
-function tipFalloff(d, radius, hardness) {
-  const [r0, s] = tipShape(radius, hardness);
-  if (d <= r0) return 1;
-  const x = (d - r0) / s;
-  return softExp(x * x);
-}
-function tipReach(radius, hardness) {
-  const [r0, s] = tipShape(radius, hardness);
-  return r0 + 2.6 * s;
-}
-function dabCoverage(d, radius, hardness) {
-  if (Number.isNaN(d) || d >= tipReach(radius, hardness) + 0.5) return 0;
-  return tipFalloff(d, radius, hardness);
-}
-function smoothPoints(points, amount) {
-  const a = 1 - Math.min(0.95, Math.max(0, amount));
-  if (a >= 1 || points.length < 3) return points.slice();
-  const out = [];
-  let cur = null;
-  for (const p of points) {
-    const n = cur ? { ...p, x: cur.x + (p.x - cur.x) * a, y: cur.y + (p.y - cur.y) * a } : p;
-    out.push(n);
-    cur = n;
-  }
-  out[out.length - 1] = points[points.length - 1];
-  return out;
-}
-var pressureOf = (p) => typeof p.pressure === "number" && Number.isFinite(p.pressure) ? Math.min(1, Math.max(0, p.pressure)) : 1;
-var DabWalker = (_class = class {
-  constructor(brush) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
-    this.brush = brush;
-  }
-  
-  __init() {this.last = null}
-  __init2() {this.nextAt = 0}
-  __init3() {this.pendingFirst = null}
-  diameter(p) {
-    return this.brush.pressureSize ? this.brush.size * pressureOf(p) : this.brush.size;
-  }
-  stepLen(p) {
-    return Math.max(0.5, Math.max(1, this.diameter(p)) * Math.max(0.01, this.brush.spacing));
-  }
-  dab(p) {
-    const b = this.brush;
-    return {
-      x: p.x,
-      y: p.y,
-      radius: Math.max(0.5, this.diameter(p) / 2),
-      alpha: Math.min(1, Math.max(0, b.flow)),
-      opacity: b.pressureOpacity ? pressureOf(p) : 1,
-      angle: b.angle * Math.PI / 180,
-      roundness: Math.min(1, Math.max(0.01, b.roundness))
-    };
-  }
-  push(p, out) {
-    const a = this.last;
-    if (!a) {
-      this.last = p;
-      this.pendingFirst = p;
-      this.nextAt = this.stepLen(p);
-      return;
-    }
-    if (this.pendingFirst) {
-      out.push(this.dab(this.pendingFirst));
-      this.pendingFirst = null;
-    }
-    const dx = p.x - a.x;
-    const dy = p.y - a.y;
-    const len = Math.hypot(dx, dy);
-    if (len > 1e-9) {
-      while (this.nextAt <= len + 1e-9) {
-        const f = Math.min(1, this.nextAt / len);
-        const q = {
-          x: a.x + dx * f,
-          y: a.y + dy * f,
-          pressure: pressureOf(a) + (pressureOf(p) - pressureOf(a)) * f
-        };
-        out.push(this.dab(q));
-        this.nextAt += this.stepLen(q);
-      }
-      this.nextAt -= len;
-    }
-    this.last = p;
-  }
-  finish(out) {
-    if (this.pendingFirst) {
-      out.push(this.dab(this.pendingFirst));
-      this.pendingFirst = null;
-    }
-  }
-}, _class);
-function walkDabs(points, brush) {
-  const w = new DabWalker(brush);
-  const out = [];
-  for (const p of smoothPoints(points, brush.smoothing)) w.push(p, out);
-  w.finish(out);
-  return out;
-}
-function dabRect(d, hardness) {
-  const ro = Math.min(1, Math.max(0.5 / d.radius, d.roundness));
-  const rm = Math.max(0.5, d.radius * ro);
-  const r = Math.max(rm, tipReach(rm, hardness)) / ro + 1.5;
-  const x0 = Math.floor(d.x - r);
-  const y0 = Math.floor(d.y - r);
-  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };
-}
-function rasterizeDab(d, hardness, rect, out) {
-  const w = rect.width;
-  const h = rect.height;
-  out.fill(0, 0, w * h);
-  const r = d.radius;
-  const ro = Math.min(1, Math.max(0.5 / r, d.roundness));
-  const rm = Math.max(0.5, r * ro);
-  const reach = Math.max(rm, tipReach(rm, hardness));
-  const sn = Math.sin(d.angle);
-  const cs = Math.cos(d.angle);
-  const toTip = (dx, dy) => {
-    const ux = dx;
-    const uy = -dy;
-    return [ux * cs + uy * sn, -ux * sn + uy * cs];
-  };
-  const small = rm < SMALL_TIP_RADIUS;
-  const reach2 = (reach + (small ? 0.75 : 0.5)) ** 2;
-  for (let yy = 0; yy < h; yy++) {
-    const dy = rect.y + yy + 0.5 - d.y;
-    for (let xx = 0; xx < w; xx++) {
-      const dx = rect.x + xx + 0.5 - d.x;
-      const [u, v] = toTip(dx, dy);
-      const d2 = (u * ro) ** 2 + v * v;
-      if (d2 >= reach2) continue;
-      let val;
-      if (small) {
-        let sum = 0;
-        for (const sy of SUBPIXEL) {
-          for (const sx of SUBPIXEL) {
-            const [su, sv] = toTip(dx + sx, dy + sy);
-            sum += tipFalloff(Math.sqrt((su * ro) ** 2 + sv * sv), rm, hardness);
-          }
-        }
-        val = sum / 16;
-      } else {
-        val = dabCoverage(Math.sqrt(d2), rm, hardness);
-      }
-      if (val > 0) out[yy * w + xx] = val * d.alpha;
-    }
-  }
-}
-var TILE_PIXELS = _chunkTFOPHZ3Ucjs.TILE * _chunkTFOPHZ3Ucjs.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 / _chunkTFOPHZ3Ucjs.TILE);
-    const ty = Math.floor(y / _chunkTFOPHZ3Ucjs.TILE);
-    const t = this.tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty));
-    return t ? t[(y - ty * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE + (x - tx * _chunkTFOPHZ3Ucjs.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 / _chunkTFOPHZ3Ucjs.TILE);
-    const ty0 = Math.floor(rect.y / _chunkTFOPHZ3Ucjs.TILE);
-    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunkTFOPHZ3Ucjs.TILE);
-    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.TILE);
-        const y0 = Math.max(rect.y, ty * _chunkTFOPHZ3Ucjs.TILE);
-        const x1 = Math.min(rect.x + rect.width, tx * _chunkTFOPHZ3Ucjs.TILE + _chunkTFOPHZ3Ucjs.TILE);
-        const y1 = Math.min(rect.y + rect.height, ty * _chunkTFOPHZ3Ucjs.TILE + _chunkTFOPHZ3Ucjs.TILE);
-        let tile;
-        for (let y = y0; y < y1; y++) {
-          const row = (y - rect.y) * w;
-          const trow = (y - ty * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE;
-          for (let x = x0; x < x1; x++) {
-            const v = vals[row + (x - rect.x)];
-            if (v <= 0) continue;
-            if (!tile) {
-              const key = _chunkTFOPHZ3Ucjs.tileKey.call(void 0, tx, ty);
-              tile = this.tiles.get(key);
-              if (!tile) {
-                tile = new Float32Array(TILE_PIXELS);
-                this.tiles.set(key, tile);
-              }
-              this.dirty.add(key);
-              touched = true;
-            }
-            const ti = trow + (x - tx * _chunkTFOPHZ3Ucjs.TILE);
-            const c = tile[ti];
-            if (ceil > c) tile[ti] = c + v * (ceil - c);
-          }
-        }
-      }
-    }
-    if (touched) this.bounds = unionRect(this.bounds, rect);
-  }
-  /** Tiles changed since the last call. */
-  takeDirty() {
-    const out = [...this.dirty];
-    this.dirty.clear();
-    return out;
-  }
-}, _class2);
-function unionRect(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 };
-}
-var StrokeCoverage = (_class3 = class {
-  constructor(brush) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
-    this.brush = brush;
-    this.walker = new DabWalker(brush);
-    this.smoothing = brush.smoothing;
-  }
-  
-  __init7() {this.coverage = new CoverageMap()}
-  
-  
-  __init8() {this.smoothPos = null}
-  __init9() {this.buf = new Float32Array(0)}
-  __init10() {this.dabCount = 0}
-  /** Feeds input points; returns the document rectangles the new dabs touched. */
-  push(points) {
-    const dabs = [];
-    for (const p of points) this.walker.push(this.smooth(p), dabs);
-    return this.paint(dabs);
-  }
-  /** Ends the stroke (a single click still paints one dab). */
-  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);
-  }
-  smooth(p) {
-    const a = 1 - Math.min(0.95, Math.max(0, this.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;
-  }
-  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 vals = this.buf.subarray(0, n);
-      rasterizeDab(d, this.brush.hardness, rect, vals);
-      this.coverage.accumulate(rect, vals, d.opacity);
-      rects.push(rect);
-      this.dabCount++;
-    }
-    return rects;
-  }
-}, _class3);
-function applyStrokeToTile(coverage, tileData, channels, tx, ty, s, options = {}) {
-  const out = options.into ? new Uint8ClampedArray(options.into) : new Uint8ClampedArray(tileData);
-  const ox = tx * _chunkTFOPHZ3Ucjs.TILE + s.offset.x;
-  const oy = ty * _chunkTFOPHZ3Ucjs.TILE + s.offset.y;
-  let x0 = 0;
-  let y0 = 0;
-  let x1 = _chunkTFOPHZ3Ucjs.TILE;
-  let y1 = _chunkTFOPHZ3Ucjs.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(_chunkTFOPHZ3Ucjs.TILE, Math.ceil(r.x + r.width) - ox);
-    y1 = Math.min(_chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.TILE + x0) * channels, (y * _chunkTFOPHZ3Ucjs.TILE + x1) * channels), (y * _chunkTFOPHZ3Ucjs.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 % _chunkTFOPHZ3Ucjs.TILE === 0 && s.offset.y % _chunkTFOPHZ3Ucjs.TILE === 0;
-  const covTile = aligned ? coverage.tiles.get(_chunkTFOPHZ3Ucjs.tileKey.call(void 0, Math.floor(ox / _chunkTFOPHZ3Ucjs.TILE), Math.floor(oy / _chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.TILE + x] : coverage.get(dx, dy);
-      if (c <= 0) continue;
-      let k = c * s.opacity;
-      if (sel) {
-        if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) continue;
-        k *= sel.data[dy * sel.width + dx] / 255;
-      }
-      if (k > 1) k = 1;
-      if (k <= 0) continue;
-      const p = y * _chunkTFOPHZ3Ucjs.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);
-        continue;
-      }
-      const i = p * 4;
-      if (s.mode === "erase" && !s.lockTransparency) {
-        out[i + 3] = Math.round(out[i + 3] * (1 - k));
-        continue;
-      }
-      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);
-        _chunkTFOPHZ3Ucjs.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 = _chunkTFOPHZ3Ucjs.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);
-      if (!s.lockTransparency) out[i + 3] = Math.round(o[3] * 255);
-    }
-  }
-  return out;
-}
-function coverageTileCoord(key) {
-  return _chunkTFOPHZ3Ucjs.tileCoord.call(void 0, key);
-}
-
-// src/paint/exchange.ts
-var MIXING_MODELS = ["rgb", "pigment"];
-var EMPTY_MIXER_LOAD = { reservoir: null, amount: 0, pickup: null };
-var MIXER_PICKUP_RATE = 0.25;
-var MIXER_DRAIN = 0.08;
-function exchangeRates(pickup, mix, load, mixing) {
-  return { pickup: MIXER_PICKUP_RATE * pickup, mix: mix * pickup, drain: MIXER_DRAIN * (1 - load), mixing };
-}
-var PaintExchange = (_class4 = class {
-  constructor(rates, load) {;_class4.prototype.__init11.call(this);
-    this.rates = rates;
-    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.well = load.pickup ? [load.pickup[0], load.pickup[1], load.pickup[2]] : null;
-    this.pig = rates.mixing === "pigment" ? { res: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, _nullishCoalesce(this.reservoir, () => ( [0, 0, 0]))), well: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, _nullishCoalesce(this.well, () => ( [0, 0, 0]))), paint: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0]), canvas: _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0]) } : null;
-  }
-  
-  
-  
-  
-  
-  __init11() {this.out = [0, 0, 0]}
-  /** What the brush carries now. */
-  get load() {
-    return { reservoir: this.reservoir ? [...this.reservoir] : null, amount: this.amount, pickup: this.well ? [...this.well] : null };
-  }
-  /** The colour picked up so far, or `null`. */
-  get pickup() {
-    return this.well;
-  }
-  /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
-  get paintPigment() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _ => _.pig, 'optionalAccess', _2 => _2.paint]), () => ( null));
-  }
-  /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
-  setReservoirColor(r, g, b) {
-    if (!this.reservoir) {
-      this.reservoir = [r, g, b];
-      this.amount = 1;
-    } else {
-      this.reservoir[0] = r;
-      this.reservoir[1] = g;
-      this.reservoir[2] = b;
-    }
-    if (this.pig) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.pig.res, r, g, b);
-  }
-  /** `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) _chunkTFOPHZ3Ucjs.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;
-  }
-  /** `a` mixed `t` of the way to `b` (sRGB 0..1) by the mixing model, into `out`. */
-  mixColors(a, b, t, out) {
-    if (this.pig) {
-      _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.pig.canvas, a[0], a[1], a[2]);
-      _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.pig.paint, b[0], b[1], b[2]);
-      _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, this.pig.canvas, this.pig.paint, t, out, 0);
-    } else for (let c = 0; c < 3; c++) out[c] = a[c] + (b[c] - a[c]) * t;
-    return out;
-  }
-  /** 1. Pick-up: the well moves towards the sampled colour (or takes it, when clean). */
-  pickUp(sample) {
-    if (!sample || !(this.rates.pickup > 0)) return;
-    const pig = this.pig;
-    if (!this.well) this.well = [sample.rgb[0], sample.rgb[1], sample.rgb[2]];
-    else {
-      if (pig) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, pig.canvas, sample.rgb[0], sample.rgb[1], sample.rgb[2]);
-      const o = this.mix(this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _3 => _3.well]), () => ( null)), sample.rgb, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _4 => _4.canvas]), () => ( null)), this.rates.pickup * sample.contact);
-      this.well = [o[0], o[1], o[2]];
-    }
-    if (pig) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, pig.well, this.well[0], this.well[1], this.well[2]);
-  }
-  /**
-   * 2. The dab's paint: the reservoir mixed with the well, written to `out`. Returns the total
-   * weight (≤ 0: nothing to lay down); deposit `min(1, weight)` of it. With pigment mixing,
-   * `paintPigment` is the result's pigment afterwards.
-   */
-  paint(out) {
-    const res = this.reservoir;
-    const wr = res ? this.amount * (1 - this.rates.mix) : 0;
-    const wp = this.well ? this.rates.mix : 0;
-    const total = wr + wp;
-    if (!(total > 1e-6)) return 0;
-    const pig = this.pig;
-    if (res && this.well) {
-      const m = this.mix(res, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _5 => _5.res]), () => ( null)), this.well, _nullishCoalesce(_optionalChain([pig, 'optionalAccess', _6 => _6.well]), () => ( null)), wp / total);
-      out[0] = m[0];
-      out[1] = m[1];
-      out[2] = m[2];
-    } else {
-      const c = _nullishCoalesce(res, () => ( this.well));
-      out[0] = c[0];
-      out[1] = c[1];
-      out[2] = c[2];
-    }
-    if (pig) _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, pig.paint, out[0], out[1], out[2]);
-    return total;
-  }
-  /** 3. The reservoir drains. */
-  drain() {
-    this.amount *= 1 - this.rates.drain;
-  }
-}, _class4);
-var TileMedium = (_class5 = class {
-  constructor(target, options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);
-    this.target = target;
-    this.options = options;
-  }
-  
-  
-  // The tile last looked up by `locate` (and whether it came from `writeTile`).
-  __init12() {this.tx = NaN}
-  __init13() {this.ty = NaN}
-  __init14() {this.tile = null}
-  __init15() {this.writable = false}
-  __init16() {this.canvasPig = _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0])}
-  __init17() {this.paintPig = _chunkTFOPHZ3Ucjs.createPigment.call(void 0, [0, 0, 0])}
-  __init18() {this.paintKey = -1}
-  __init19() {this.cb = [0, 0, 0, 0]}
-  __init20() {this.src = [0, 0, 0, 1]}
-  __init21() {this.o = [0, 0, 0]}
-  /** Forgets the cached tile (call when another writer may have replaced tiles). */
-  reset() {
-    this.tx = NaN;
-  }
-  /**
-   * The tile holding document pixel (dx, dy) (`pixels`) and the pixel's byte index in it, 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 / _chunkTFOPHZ3Ucjs.TILE);
-    const ty = Math.floor(ly / _chunkTFOPHZ3Ucjs.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 * _chunkTFOPHZ3Ucjs.TILE) * _chunkTFOPHZ3Ucjs.TILE + (lx - tx * _chunkTFOPHZ3Ucjs.TILE)) * 4 : -1;
-  }
-  /** The tile `locate` last found. */
-  get pixels() {
-    return this.tile;
-  }
-  /** Selection coverage at a document pixel, 0..1 (1 without a selection). */
-  selectionAt(dx, dy) {
-    const sel = this.target.selection;
-    if (!sel) return 1;
-    if (dx < 0 || dy < 0 || dx >= sel.width || dy >= sel.height) return 0;
-    return sel.data[dy * sel.width + dx] / 255;
-  }
-  sample(rect, cov) {
-    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)) return null;
-    return { rgb: [ar / asum, ag / asum, ab / asum], contact: asum / Math.max(1e-6, wsum) };
-  }
-  deposit(rect, cov, dep, paint, paintPigment, field = null) {
-    const t = this.target;
-    const sel = t.selection;
-    const w = rect.width;
-    const o = this.o;
-    const blend = this.options.blend;
-    const pigment = blend === void 0 ? paintPigment !== null : blend === "pigment";
-    const general = blend !== void 0 && blend !== "normal" && blend !== "pigment";
-    let lastKey = -1;
-    this.tx = NaN;
-    for (let yy = 0; yy < rect.height; yy++) {
-      const dy = rect.y + yy;
-      for (let xx = 0; xx < w; xx++) {
-        const p = yy * w + xx;
-        let k = cov[p] * 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 pr = field ? field[p * 3] : paint[0];
-        const pg = field ? field[p * 3 + 1] : paint[1];
-        const pb = field ? field[p * 3 + 2] : paint[2];
-        if (general) {
-          const cb = this.cb;
-          for (let c = 0; c < 4; c++) cb[c] = px[i + c] / 255;
-          const src = this.src;
-          src[0] = pr;
-          src[1] = pg;
-          src[2] = pb;
-          const r = _chunkTFOPHZ3Ucjs.blendPixel.call(void 0, blend, cb, src, k);
-          px[i] = Math.round(r[0] * 255);
-          px[i + 1] = Math.round(r[1] * 255);
-          px[i + 2] = Math.round(r[2] * 255);
-          if (!t.lockTransparency) px[i + 3] = Math.round(r[3] * 255);
-          continue;
-        }
-        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] = pr;
-          o[1] = pg;
-          o[2] = pb;
-        } else if (pigment && field) {
-          _chunkTFOPHZ3Ucjs.mixPigment8.call(void 0, px[i], px[i + 1], px[i + 2], Math.round(pr * 255), Math.round(pg * 255), Math.round(pb * 255), share, o);
-        } else if (pigment) {
-          const key = px[i] << 16 | px[i + 1] << 8 | px[i + 2];
-          if (key !== lastKey) {
-            _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.canvasPig, px[i] / 255, px[i + 1] / 255, px[i + 2] / 255);
-            lastKey = key;
-          }
-          let pp = paintPigment;
-          if (!pp) {
-            const pkey = Math.round(pr * 255) << 16 | Math.round(pg * 255) << 8 | Math.round(pb * 255);
-            if (pkey !== this.paintKey) {
-              _chunkTFOPHZ3Ucjs.setPigmentColor.call(void 0, this.paintPig, pr, pg, pb);
-              this.paintKey = pkey;
-            }
-            pp = this.paintPig;
-          }
-          _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, this.canvasPig, pp, share, o, 0);
-        } else {
-          o[0] = px[i] / 255 + (pr - px[i] / 255) * share;
-          o[1] = px[i + 1] / 255 + (pg - px[i + 1] / 255) * share;
-          o[2] = px[i + 2] / 255 + (pb - px[i + 2] / 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);
-      }
-    }
-  }
-}, _class5);
-
-// src/paint/mixer.ts
-var DEFAULT_MIXER = {
-  wet: 0.5,
-  load: 0.5,
-  mix: 0.5,
-  loadEachStroke: true,
-  cleanEachStroke: true,
-  mixing: "rgb"
-};
-function normalizeMixer(raw = {}) {
-  const unit2 = (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: unit2(raw.wet, DEFAULT_MIXER.wet),
-    load: unit2(raw.load, DEFAULT_MIXER.load),
-    mix: unit2(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 mixerRates(settings) {
-  return exchangeRates(settings.wet, settings.mix, settings.load, settings.mixing);
-}
-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 cleanMixer(load) {
-  return { reservoir: load.reservoir, amount: load.amount, pickup: null };
-}
-var MixerStroke = (_class6 = class {
-  constructor(brush, settings, load, target) {;_class6.prototype.__init22.call(this);_class6.prototype.__init23.call(this);_class6.prototype.__init24.call(this);_class6.prototype.__init25.call(this);_class6.prototype.__init26.call(this);
-    this.brush = brush;
-    this.walker = new DabWalker(brush);
-    this.exchange = new PaintExchange(mixerRates(normalizeMixer(settings)), load);
-    this.medium = new TileMedium(target);
-  }
-  
-  __init22() {this.dabCount = 0}
-  __init23() {this.bounds = null}
-  
-  __init24() {this.smoothPos = null}
-  __init25() {this.buf = new Float32Array(0)}
-  
-  
-  __init26() {this.paintColor = [0, 0, 0]}
-  /** The brush load after the dabs so far. */
-  get load() {
-    return this.exchange.load;
-  }
-  push(points) {
-    const dabs = [];
-    for (const p of points) this.walker.push(this.smooth(p), dabs);
-    return this.paint(dabs);
-  }
-  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);
-  }
-  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;
-  }
-  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;
-  }
-  dab(d, rect, cov) {
-    const ex = this.exchange;
-    ex.pickUp(this.medium.sample(rect, cov));
-    const total = ex.paint(this.paintColor);
-    if (total > 0) {
-      const dep = Math.min(1, total) * this.brush.flow * this.brush.opacity * d.opacity;
-      if (dep > 0) this.medium.deposit(rect, cov, dep, this.paintColor, ex.paintPigment);
-    }
-    ex.drain();
-  }
-}, _class6);
-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/blending.ts
-var DEFAULT_BLENDER = { strength: 0.5, distance: 0.35, mixing: "pigment" };
-var DEFAULT_SMUDGE = { strength: 0.7, length: 0.85, mixing: "rgb" };
-var unit = (v, d) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : d;
-function normalizeBlender(raw = {}, base = DEFAULT_BLENDER) {
-  return { strength: unit(raw.strength, base.strength), distance: unit(raw.distance, base.distance), mixing: raw.mixing === "rgb" || raw.mixing === "pigment" ? raw.mixing : base.mixing };
-}
-function normalizeSmudge(raw = {}, base = DEFAULT_SMUDGE) {
-  return { strength: unit(raw.strength, base.strength), length: unit(raw.length, base.length), mixing: raw.mixing === "rgb" || raw.mixing === "pigment" ? raw.mixing : base.mixing };
-}
-function blendRadius(settings, radius) {
-  return Math.max(1, Math.round(settings.distance * 2 * radius));
-}
-function createBlenderScratch() {
-  return { sums: new Float64Array(0), mix: { rgb: [0, 0, 0], strength: 1, ks: new Float32Array(_chunkTFOPHZ3Ucjs.PIGMENT_BANDS), scatter: 1 }, out: [0, 0, 0] };
-}
-var N = _chunkTFOPHZ3Ucjs.PIGMENT_BANDS;
-function blenderDab(medium, rect, cov, opacity, radius, settings, scratch) {
-  const R = blendRadius(settings, radius);
-  const W = rect.width + 2 * R;
-  const H = rect.height + 2 * R;
-  const pigment = settings.mixing === "pigment";
-  const C = pigment ? N + 2 : 4;
-  const stride = (W + 1) * C;
-  const size = stride * (H + 1);
-  if (scratch.sums.length < size) scratch.sums = new Float64Array(size);
-  const I = scratch.sums;
-  I.fill(0, 0, size);
-  medium.reset();
-  const row = new Float64Array(C);
-  for (let y = 0; y < H; y++) {
-    row.fill(0);
-    const dy = rect.y - R + y;
-    for (let x = 0; x < W; x++) {
-      const dx = rect.x - R + x;
-      const i = medium.locate(dx, dy, false);
-      if (i >= 0) {
-        const px = medium.pixels;
-        const a = px[i + 3] / 255;
-        if (a > 0) {
-          if (pigment) {
-            const p = _chunkTFOPHZ3Ucjs.pigment8.call(void 0, px[i], px[i + 1], px[i + 2]);
-            const sa = p.scatter * p.strength * a;
-            for (let k = 0; k < N; k++) row[k] += sa * p.ks[k];
-            row[N] += sa;
-            row[N + 1] += a;
-          } else {
-            row[0] += px[i] / 255 * a;
-            row[1] += px[i + 1] / 255 * a;
-            row[2] += px[i + 2] / 255 * a;
-            row[3] += a;
-          }
-        }
-      }
-      const o = (y + 1) * stride + (x + 1) * C;
-      const up = y * stride + (x + 1) * C;
-      for (let c = 0; c < C; c++) I[o + c] = I[up + c] + row[c];
-    }
-  }
-  const area = (2 * R + 1) * (2 * R + 1);
-  const strength = settings.strength * opacity;
-  const lock = medium.target.lockTransparency;
-  const mixPig = scratch.mix;
-  const out = scratch.out;
-  const sum = (c, x1, y1, x2, y2) => I[y2 * stride + x2 * C + c] - I[y1 * stride + x2 * C + c] - I[y2 * stride + x1 * C + c] + I[y1 * stride + x1 * C + c];
-  const w = rect.width;
-  medium.reset();
-  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;
-      const dx = rect.x + xx;
-      const dy = rect.y + yy;
-      let t = strength * k * medium.selectionAt(dx, dy);
-      if (t <= 0) continue;
-      if (t > 1) t = 1;
-      const x1 = xx;
-      const y1 = yy;
-      const x2 = xx + 2 * R + 1;
-      const y2 = yy + 2 * R + 1;
-      const asum = sum(pigment ? N + 1 : 3, x1, y1, x2, y2);
-      const ri = medium.locate(dx, dy, false);
-      const a = ri < 0 ? 0 : medium.pixels[ri + 3] / 255;
-      if (lock && a <= 0) continue;
-      const avgA = asum / area;
-      const na = lock ? a : (1 - t) * a + t * avgA;
-      if (asum <= 1e-9) {
-        if (lock || a <= 0) continue;
-        const i2 = medium.locate(dx, dy, true);
-        medium.pixels[i2 + 3] = Math.round(na * 255);
-        continue;
-      }
-      const share = lock ? t : na > 0 ? t * avgA / na : 1;
-      const i = medium.locate(dx, dy, true);
-      const px = medium.pixels;
-      if (pigment) {
-        const sa = sum(N, x1, y1, x2, y2);
-        for (let c = 0; c < N; c++) mixPig.ks[c] = sum(c, x1, y1, x2, y2) / sa;
-        mixPig.scatter = sa / asum;
-        if (a <= 0 || share >= 1) _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, mixPig, mixPig, 0, out, 0);
-        else _chunkTFOPHZ3Ucjs.lerpPigmentInto.call(void 0, _chunkTFOPHZ3Ucjs.pigment8.call(void 0, px[i], px[i + 1], px[i + 2]), mixPig, share, out, 0);
-      } else {
-        for (let c = 0; c < 3; c++) {
-          const m = sum(c, x1, y1, x2, y2) / asum;
-          out[c] = a <= 0 || share >= 1 ? m : px[i + c] / 255 + (m - px[i + c] / 255) * share;
-        }
-      }
-      px[i] = Math.round(out[0] * 255);
-      px[i + 1] = Math.round(out[1] * 255);
-      px[i + 2] = Math.round(out[2] * 255);
-      if (!lock) px[i + 3] = Math.round(na * 255);
-    }
-  }
-}
-var SmudgeTip = (_class7 = class {
-  constructor(settings, diameter) {;_class7.prototype.__init27.call(this);_class7.prototype.__init28.call(this);
-    this.settings = settings;
-    this.size = Math.max(2, Math.min(512, Math.ceil(diameter)));
-    this.patch = new Float32Array(this.size * this.size * 4);
-  }
-  
-  
-  
-  __init27() {this.loaded = false}
-  __init28() {this.out = [0, 0, 0]}
-  cell(d, px, py) {
-    const s = this.size;
-    const r = Math.max(0.5, d.radius);
-    const bx = Math.min(s - 1, Math.max(0, Math.floor(((px - d.x) / r + 1) / 2 * s)));
-    const by = Math.min(s - 1, Math.max(0, Math.floor(((py - d.y) / r + 1) / 2 * s)));
-    return (by * s + bx) * 4;
-  }
-  /** Fills the patch from the pixels under the dab. */
-  load(medium, d) {
-    const s = this.size;
-    const r = Math.max(0.5, d.radius);
-    medium.reset();
-    for (let by = 0; by < s; by++) {
-      for (let bx = 0; bx < s; bx++) {
-        const dx = Math.floor(d.x + ((bx + 0.5) / s * 2 - 1) * r);
-        const dy = Math.floor(d.y + ((by + 0.5) / s * 2 - 1) * r);
-        const i = medium.locate(dx, dy, false);
-        const c = (by * s + bx) * 4;
-        if (i < 0) {
-          this.patch.fill(0, c, c + 4);
-          continue;
-        }
-        const px = medium.pixels;
-        this.patch[c] = px[i] / 255;
-        this.patch[c + 1] = px[i + 1] / 255;
-        this.patch[c + 2] = px[i + 2] / 255;
-        this.patch[c + 3] = px[i + 3] / 255;
-      }
-    }
-    this.loaded = true;
-  }
-  /** `a` mixed `t` of the way to `b` (both 0..1) into `out`. */
-  mix(a0, a1, a2, b0, b1, b2, t) {
-    const o = this.out;
-    if (this.settings.mixing === "pigment") {
-      _chunkTFOPHZ3Ucjs.mixPigment8.call(void 0, Math.round(a0 * 255), Math.round(a1 * 255), Math.round(a2 * 255), Math.round(b0 * 255), Math.round(b1 * 255), Math.round(b2 * 255), t, o);
-    } else {
-      o[0] = a0 + (b0 - a0) * t;
-      o[1] = a1 + (b1 - a1) * t;
-      o[2] = a2 + (b2 - a2) * t;
-    }
-    return o;
-  }
-  /** One dab: lays the carried patch over the tip's footprint (`cov` over `rect`), then picks up. */
-  dab(medium, d, rect, cov) {
-    if (!this.loaded) {
-      this.load(medium, d);
-      return;
-    }
-    const { strength, length } = this.settings;
-    const lock = medium.target.lockTransparency;
-    const patch = this.patch;
-    const w = rect.width;
-    medium.reset();
-    for (let yy = 0; yy < rect.height; yy++) {
-      for (let xx = 0; xx < w; xx++) {
-        const cv = cov[yy * w + xx];
-        if (cv <= 0) continue;
-        const dx = rect.x + xx;
-        const dy = rect.y + yy;
-        let k = strength * cv * d.opacity * medium.selectionAt(dx, dy);
-        if (k <= 0) continue;
-        if (k > 1) k = 1;
-        const c = this.cell(d, dx + 0.5, dy + 0.5);
-        const ba = patch[c + 3];
-        const ri = medium.locate(dx, dy, false);
-        const a = ri < 0 ? 0 : medium.pixels[ri + 3] / 255;
-        if (lock && a <= 0) continue;
-        const px0 = ri >= 0 ? medium.pixels : null;
-        const o0 = px0 ? px0[ri] / 255 : 0;
-        const o1 = px0 ? px0[ri + 1] / 255 : 0;
-        const o2 = px0 ? px0[ri + 2] / 255 : 0;
-        if (a > 0 || ba > 0) {
-          const na = lock ? a : a + (ba - a) * k;
-          const share = lock ? k * ba : na > 0 ? k * ba / na : 0;
-          let r = o0;
-          let g = o1;
-          let b = o2;
-          if (a <= 0 || share >= 1) {
-            r = patch[c];
-            g = patch[c + 1];
-            b = patch[c + 2];
-          } else if (share > 0) {
-            const m = this.mix(o0, o1, o2, patch[c], patch[c + 1], patch[c + 2], share);
-            r = m[0];
-            g = m[1];
-            b = m[2];
-          }
-          const i = medium.locate(dx, dy, true);
-          const out = medium.pixels;
-          out[i] = Math.round(r * 255);
-          out[i + 1] = Math.round(g * 255);
-          out[i + 2] = Math.round(b * 255);
-          out[i + 3] = Math.round(na * 255);
-        }
-        const pick = (1 - length) * Math.min(1, cv * d.opacity);
-        if (pick > 0) {
-          const pa = ba + (a - ba) * pick;
-          const s = pa > 0 ? a * pick / pa : 0;
-          if (s > 0) {
-            const m = ba <= 0 || s >= 1 ? [o0, o1, o2] : this.mix(patch[c], patch[c + 1], patch[c + 2], o0, o1, o2, s);
-            patch[c] = m[0];
-            patch[c + 1] = m[1];
-            patch[c + 2] = m[2];
-          }
-          patch[c + 3] = pa;
-        }
-      }
-    }
-  }
-}, _class7);
-
-// src/paint/pigment-tools.ts
-var HEX = /^#?([0-9a-f]{6})$/i;
-function parseHex(value, index) {
-  const m = typeof value === "string" ? HEX.exec(value.trim()) : null;
-  if (!m) throw new Error(`colors[${index}].color is ${JSON.stringify(value)}; use #rrggbb, e.g. "#1e40af".`);
-  const n = parseInt(m[1], 16);
-  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
-}
-function toHex(rgb) {
-  return "#" + rgb.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("");
-}
-function createPigmentTools() {
-  const mixColors = {
-    name: "mix_colors",
-    title: "Mix colours like paint",
-    description: "Mixes colours as paint would (model pigment, the default: Kubelka-Munk mixing over reflectance spectra, so blue and yellow make green and white lightens a colour into a tint instead of greying it), or as light on screen (model rgb: the weighted RGB average). Changes nothing. Returns mixed (#rrggbb, by the chosen model), the other model's result for comparison (rgbLerp and pigment), the normalised weights and the model.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        colors: {
-          type: "array",
-          minItems: 1,
-          maxItems: 16,
-          description: "The paints to mix (1 to 16).",
-          items: {
-            type: "object",
-            properties: {
-              color: { type: "string", description: "Paint colour #rrggbb." },
-              weight: { type: "number", minimum: 0, description: "Parts of this paint, any scale (e.g. 1 and 3 for a 1:3 mix). At least one weight must be above 0." },
-              strength: {
-                type: "number",
-                exclusiveMinimum: 0,
-                maximum: 100,
-                description: "Tinting strength (default 1): each part counts as this many, so a strong dark paint (e.g. 4) tints a lot of white."
-              }
-            },
-            required: ["color", "weight"],
-            additionalProperties: false
-          }
-        },
-        model: {
-          type: "string",
-          enum: ["pigment", "rgb"],
-          description: "pigment (default): mix like paint (Kubelka-Munk), as the pigment blend mode, Mixer Brush and mixing pad do; rgb: average the RGB values, as normal blending and rgb mixing brushes do (strength is ignored)."
-        }
-      },
-      required: ["colors"],
-      additionalProperties: false
-    },
-    annotations: { title: "Mix colours like paint", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    handler: (args) => {
-      const items = args.colors;
-      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((rgb2, i) => _chunkTFOPHZ3Ucjs.createPigment.call(void 0, rgb2, { strength: items[i].strength }));
-      const mixed = _chunkTFOPHZ3Ucjs.mixPigments.call(void 0, pigments, items.map((item) => item.weight));
-      const lerp = [0, 1, 2].map((c) => rgbs.reduce((sum, rgb2, i) => sum + rgb2[c] * items[i].weight, 0) / total);
-      const rgb = args.model === "rgb";
-      return {
-        mixed: toHex(rgb ? lerp : mixed),
-        rgbLerp: toHex(lerp),
-        pigment: toHex(mixed),
-        weights: items.map((item) => item.weight / total),
-        model: rgb ? "rgb" : "kubelka-munk"
-      };
-    }
-  };
-  return [mixColors];
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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.EMPTY_MIXER_LOAD = EMPTY_MIXER_LOAD; exports.MIXER_PICKUP_RATE = MIXER_PICKUP_RATE; exports.MIXER_DRAIN = MIXER_DRAIN; exports.exchangeRates = exchangeRates; exports.PaintExchange = PaintExchange; exports.TileMedium = TileMedium; exports.DEFAULT_MIXER = DEFAULT_MIXER; exports.normalizeMixer = normalizeMixer; exports.mixerRates = mixerRates; exports.loadMixer = loadMixer; exports.cleanMixer = cleanMixer; exports.MixerStroke = MixerStroke; exports.DEFAULT_BLENDER = DEFAULT_BLENDER; exports.DEFAULT_SMUDGE = DEFAULT_SMUDGE; exports.normalizeBlender = normalizeBlender; exports.normalizeSmudge = normalizeSmudge; exports.blendRadius = blendRadius; exports.createBlenderScratch = createBlenderScratch; exports.blenderDab = blenderDab; exports.SmudgeTip = SmudgeTip; exports.createPigmentTools = createPigmentTools;
-//# sourceMappingURL=chunk-TCKIXI46.cjs.map