@pixerate/editor 0.266.2 → 0.267.0

package/dist/chunk-EXB2EGBE.cjs

@@ -0,0 +1,802 @@
+"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 _chunkBB6TR422cjs = require('./chunk-BB6TR422.cjs');
+
+
+
+
+
+
+
+var _chunkFQPUF2W2cjs = require('./chunk-FQPUF2W2.cjs');
+
+
+
+
+
+
+var _chunk2VX55NFMcjs = require('./chunk-2VX55NFM.cjs');
+
+
+
+var _chunk474IQG74cjs = require('./chunk-474IQG74.cjs');
+
+// 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) => _chunk2VX55NFMcjs.createPigment.call(void 0, rgb2, { strength: items[i].strength }));
+      const mixed = _chunk2VX55NFMcjs.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];
+}
+
+// src/paint/retouch.ts
+var TONE_RANGES = ["shadows", "midtones", "highlights"];
+function luma(r, g, b) {
+  return 0.299 * r + 0.587 * g + 0.114 * b;
+}
+function dodgeBurnCurve(v, e, range, burn) {
+  const x = Math.max(0, v);
+  const k = Math.min(1, Math.max(0, e));
+  const c = Math.min(1, x);
+  if (range === "midtones") {
+    const w2 = Math.min(1, Math.max(0, 4 * x * (1 - x)));
+    return x + w2 * (Math.pow(c, burn ? 1 + k : 1 / (1 + k)) - x);
+  }
+  const w = range === "shadows" ? (1 - c) * (1 - c) : c * c;
+  return burn ? x - k * w * x : x + k * w * (1 - c);
+}
+function compressGamut(c, l) {
+  const L = Math.min(1, Math.max(0, l));
+  const lo = Math.min(c[0], c[1], c[2]);
+  const hi = Math.max(c[0], c[1], c[2]);
+  let t = 1;
+  if (hi > 1 && hi - L > 1e-9) t = Math.min(t, (1 - L) / (hi - L));
+  if (lo < 0 && L - lo > 1e-9) t = Math.min(t, L / (L - lo));
+  for (let i = 0; i < 3; i++) c[i] = L + (c[i] - L) * t;
+}
+function dodgeBurn(c, e, range, burn, protectTones) {
+  if (!(e > 0)) return c;
+  if (protectTones) {
+    const l = luma(c[0], c[1], c[2]);
+    const nl = dodgeBurnCurve(l, e, range, burn);
+    if (l > 1e-6) for (let i = 0; i < 3; i++) c[i] *= nl / l;
+    else c[0] = c[1] = c[2] = nl;
+    compressGamut(c, nl);
+  } else for (let i = 0; i < 3; i++) c[i] = dodgeBurnCurve(c[i], e, range, burn);
+  return c;
+}
+function saturationOf(r, g, b) {
+  const lo = Math.min(r, g, b);
+  const hi = Math.max(r, g, b);
+  return hi <= 1e-6 ? 0 : Math.min(1, Math.max(0, (hi - lo) / hi));
+}
+function sponge(c, amount, saturate, vibrance) {
+  let a = Math.min(1, Math.max(0, amount));
+  if (!(a > 0)) return c;
+  if (vibrance) {
+    const s = saturationOf(c[0], c[1], c[2]);
+    a *= saturate ? 1 - s : 0.25 + 0.75 * s;
+  }
+  const l = luma(c[0], c[1], c[2]);
+  const k = saturate ? 1 + a : 1 - a;
+  for (let i = 0; i < 3; i++) c[i] = l + (c[i] - l) * k;
+  compressGamut(c, l);
+  return c;
+}
+function perDabStrength(e, spacing) {
+  return 1 - Math.pow(1 - Math.min(1, Math.max(0, e)), Math.min(1, Math.max(0.01, spacing)));
+}
+var RETOUCH_SAMPLES = ["current", "current-below", "all"];
+var SPOT_HEAL_TYPES = ["proximity-match", "content-aware", "smooth"];
+var DEFAULT_RETOUCH = {
+  aligned: true,
+  sample: "current",
+  spotType: "proximity-match",
+  range: "midtones",
+  exposure: 0.5,
+  protectTones: true,
+  spongeMode: "desaturate",
+  vibrance: true,
+  strength: 0.5,
+  historySteps: 0
+};
+function normalizeRetouch(raw = {}, base = DEFAULT_RETOUCH) {
+  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;
+  const pick = (v, all, d) => all.includes(v) ? v : d;
+  return {
+    aligned: bool(raw.aligned, base.aligned),
+    sample: pick(raw.sample, RETOUCH_SAMPLES, base.sample),
+    spotType: pick(raw.spotType, SPOT_HEAL_TYPES, base.spotType),
+    range: pick(raw.range, TONE_RANGES, base.range),
+    exposure: unit(raw.exposure, base.exposure),
+    protectTones: bool(raw.protectTones, base.protectTones),
+    spongeMode: pick(raw.spongeMode, ["desaturate", "saturate"], base.spongeMode),
+    vibrance: bool(raw.vibrance, base.vibrance),
+    strength: unit(raw.strength, base.strength),
+    historySteps: typeof raw.historySteps === "number" && Number.isFinite(raw.historySteps) ? Math.min(1e3, Math.max(0, Math.round(raw.historySteps))) : base.historySteps
+  };
+}
+function boxBlurPixels(data, w, h, n, r) {
+  if (r < 1) return;
+  if (n === 4) for (let i = 0; i < data.length; i += 4) for (let c = 0; c < 3; c++) data[i + c] *= data[i + 3] / 255;
+  const tmp = new Float32Array(data.length);
+  const k = 1 / (2 * r + 1);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < n; c++) {
+        let s = 0;
+        for (let d = -r; d <= r; d++) s += data[(y * w + Math.min(w - 1, Math.max(0, x + d))) * n + c];
+        tmp[(y * w + x) * n + c] = s * k;
+      }
+    }
+  }
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      for (let c = 0; c < n; c++) {
+        let s = 0;
+        for (let d = -r; d <= r; d++) s += tmp[(Math.min(h - 1, Math.max(0, y + d)) * w + x) * n + c];
+        data[(y * w + x) * n + c] = s * k;
+      }
+    }
+  }
+  if (n === 4) {
+    for (let i = 0; i < data.length; i += 4) {
+      const a = data[i + 3] / 255;
+      for (let c = 0; c < 3; c++) data[i + c] = a > 0 ? data[i + c] / a : 0;
+    }
+  }
+}
+function retouchFilter(data, w, h, n, kind, radius = 2, amount = 1) {
+  if (kind === "blur") {
+    boxBlurPixels(data, w, h, n, radius);
+    boxBlurPixels(data, w, h, n, radius);
+    return;
+  }
+  const soft = data.slice();
+  boxBlurPixels(soft, w, h, n, 1);
+  for (let i = 0; i < data.length; i++) {
+    if (n === 4 && (i & 3) === 3) continue;
+    const v = data[i] + amount * (data[i] - soft[i]);
+    data[i] = v > 0 ? v : 0;
+  }
+}
+var IDENTITY_CLONE_TRANSFORM = { scaleX: 1, scaleY: 1, rotate: 0 };
+function isIdentityCloneTransform(t) {
+  return t.scaleX === 1 && t.scaleY === 1 && (t.rotate % 360 + 360) % 360 === 0;
+}
+function cloneSamplePoint(t, source, anchor, x, y) {
+  const a = -t.rotate * Math.PI / 180;
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  const dx = x - anchor.x;
+  const dy = y - anchor.y;
+  return [source.x + (c * dx - s * dy) / t.scaleX, source.y + (s * dx + c * dy) / t.scaleY];
+}
+var TransformedPixelSource = (_class = class {
+  constructor(inner, map) {;_class.prototype.__init.call(this);
+    this.inner = inner;
+    this.map = map;
+  }
+  
+  
+  __init() {this.px = [0, 0, 0, 0]}
+  sample(x, y, out) {
+    const [u, v] = this.map(x, y);
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 0;
+    for (let k = 0; k < 4; k++) {
+      const w = (k & 1 ? fx : 1 - fx) * (k & 2 ? fy : 1 - fy);
+      if (w <= 0) continue;
+      if (!this.inner.sample(x0 + (k & 1), y0 + (k >> 1), this.px)) continue;
+      const pa = this.px[3] * w;
+      r += this.px[0] * pa;
+      g += this.px[1] * pa;
+      b += this.px[2] * pa;
+      a += pa;
+    }
+    if (!(a > 0)) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return false;
+    }
+    out[0] = r / a;
+    out[1] = g / a;
+    out[2] = b / a;
+    out[3] = a;
+    return true;
+  }
+}, _class);
+var TilePixelSource = (_class2 = class {
+  constructor(readTile, channels, offset = { x: 0, y: 0 }) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+    this.readTile = readTile;
+    this.channels = channels;
+    this.offset = offset;
+  }
+  
+  
+  
+  __init2() {this.cache = /* @__PURE__ */ new Map()}
+  __init3() {this.lastKey = NaN}
+  __init4() {this.last = null}
+  sample(x, y, out) {
+    const lx = x - this.offset.x;
+    const ly = y - this.offset.y;
+    const tx = Math.floor(lx / _chunk474IQG74cjs.TILE);
+    const ty = Math.floor(ly / _chunk474IQG74cjs.TILE);
+    const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+    if (key !== this.lastKey) {
+      let t2 = this.cache.get(key);
+      if (t2 === void 0) {
+        t2 = this.readTile(tx, ty);
+        this.cache.set(key, t2);
+      }
+      this.last = t2;
+      this.lastKey = key;
+    }
+    const t = this.last;
+    if (!t) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return false;
+    }
+    const p = (ly - ty * _chunk474IQG74cjs.TILE) * _chunk474IQG74cjs.TILE + (lx - tx * _chunk474IQG74cjs.TILE);
+    if (this.channels === 1) {
+      out[0] = out[1] = out[2] = t[p];
+      out[3] = 255;
+      return true;
+    }
+    const i = p * 4;
+    out[0] = t[i];
+    out[1] = t[i + 1];
+    out[2] = t[i + 2];
+    out[3] = t[i + 3];
+    return out[3] > 0;
+  }
+}, _class2);
+var RegionPixelSource = class {
+  constructor(rect, data) {
+    this.rect = rect;
+    this.data = data;
+  }
+  
+  
+  sample(x, y, out) {
+    const r = this.rect;
+    const lx = x - r.x;
+    const ly = y - r.y;
+    if (lx < 0 || ly < 0 || lx >= r.width || ly >= r.height) {
+      out[0] = out[1] = out[2] = out[3] = 0;
+      return false;
+    }
+    const i = (ly * r.width + lx) * 4;
+    out[0] = this.data[i];
+    out[1] = this.data[i + 1];
+    out[2] = this.data[i + 2];
+    out[3] = this.data[i + 3];
+    return out[3] > 0;
+  }
+};
+function readSourceRegion(source, rect, dx = 0, dy = 0) {
+  const out = new Float32Array(rect.width * rect.height * 4);
+  const px = [0, 0, 0, 0];
+  for (let y = 0; y < rect.height; y++) {
+    for (let x = 0; x < rect.width; x++) {
+      source.sample(rect.x + x + dx, rect.y + y + dy, px);
+      const i = (y * rect.width + x) * 4;
+      out[i] = px[0];
+      out[i + 1] = px[1];
+      out[i + 2] = px[2];
+      out[i + 3] = px[3];
+    }
+  }
+  return out;
+}
+function applyRetouchToTile(coverage, tileData, channels, tx, ty, paint, s, options = {}) {
+  const out = (_nullishCoalesce(options.into, () => ( tileData))).slice();
+  const ox = tx * _chunk474IQG74cjs.TILE + s.offset.x;
+  const oy = ty * _chunk474IQG74cjs.TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = _chunk474IQG74cjs.TILE;
+  let y1 = _chunk474IQG74cjs.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(_chunk474IQG74cjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunk474IQG74cjs.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 * _chunk474IQG74cjs.TILE + x0) * channels, (y * _chunk474IQG74cjs.TILE + x1) * channels), (y * _chunk474IQG74cjs.TILE + x0) * channels);
+    }
+  }
+  const sel = s.selection;
+  const blend = _nullishCoalesce(s.blend, () => ( "normal"));
+  const src = [0, 0, 0, 0];
+  const rgb = [0, 0, 0];
+  const cb = [0, 0, 0, 0];
+  const cs = [0, 0, 0, 0];
+  let covKey = NaN;
+  let covTile;
+  for (let y = y0; y < y1; y++) {
+    const dy = oy + y;
+    const cty = Math.floor(dy / _chunk474IQG74cjs.TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / _chunk474IQG74cjs.TILE);
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * _chunk474IQG74cjs.TILE) * _chunk474IQG74cjs.TILE + (dx - ctx * _chunk474IQG74cjs.TILE)];
+      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 * _chunk474IQG74cjs.TILE + x;
+      if (channels === 1) {
+        const g = out[p];
+        let t;
+        if (paint.kind === "tone") {
+          rgb[0] = rgb[1] = rgb[2] = g / 255;
+          paint.tone(rgb);
+          t = luma(rgb[0], rgb[1], rgb[2]) * 255;
+        } else if (paint.kind === "color") t = paint.color[0];
+        else {
+          if (!paint.source.sample(dx + paint.dx, dy + paint.dy, src)) continue;
+          t = src[0];
+          k *= src[3] / 255;
+        }
+        out[p] = Math.round(g + (t - g) * k);
+        continue;
+      }
+      const i = p * 4;
+      const a = out[i + 3];
+      if (paint.kind === "tone") {
+        if (a === 0) continue;
+        rgb[0] = out[i] / 255;
+        rgb[1] = out[i + 1] / 255;
+        rgb[2] = out[i + 2] / 255;
+        const r0 = rgb[0];
+        const g0 = rgb[1];
+        const b0 = rgb[2];
+        paint.tone(rgb);
+        _chunkFQPUF2W2cjs.put255.call(void 0, out, i, r0 + (rgb[0] - r0) * k);
+        _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 1, g0 + (rgb[1] - g0) * k);
+        _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 2, b0 + (rgb[2] - b0) * k);
+        continue;
+      }
+      if (s.lockTransparency && a === 0) continue;
+      if (paint.kind === "color") {
+        src[0] = paint.color[0];
+        src[1] = paint.color[1];
+        src[2] = paint.color[2];
+        src[3] = paint.color[3];
+      } else if (!paint.source.sample(dx + paint.dx, dy + paint.dy, src)) continue;
+      for (let ch = 0; ch < 4; ch++) {
+        cb[ch] = out[i + ch] / 255;
+        cs[ch] = src[ch] / 255;
+      }
+      const o = _chunk2VX55NFMcjs.blendPixel.call(void 0, blend, cb, cs, k);
+      _chunkFQPUF2W2cjs.put255.call(void 0, out, i, o[0]);
+      _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 1, o[1]);
+      _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 2, o[2]);
+      if (!s.lockTransparency) _chunkFQPUF2W2cjs.put255.call(void 0, out, i + 3, o[3]);
+    }
+  }
+  return out;
+}
+function applyToneToDeepTile(coverage, samples, tx, ty, tone, s, options = {}) {
+  const linear = samples instanceof Float32Array;
+  const out = (_nullishCoalesce(options.into, () => ( samples))).slice();
+  const ox = tx * _chunk474IQG74cjs.TILE + s.offset.x;
+  const oy = ty * _chunk474IQG74cjs.TILE + s.offset.y;
+  let x0 = 0;
+  let y0 = 0;
+  let x1 = _chunk474IQG74cjs.TILE;
+  let y1 = _chunk474IQG74cjs.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(_chunk474IQG74cjs.TILE, Math.ceil(r.x + r.width) - ox);
+    y1 = Math.min(_chunk474IQG74cjs.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(samples.subarray((y * _chunk474IQG74cjs.TILE + x0) * 4, (y * _chunk474IQG74cjs.TILE + x1) * 4), (y * _chunk474IQG74cjs.TILE + x0) * 4);
+  }
+  const sel = s.selection;
+  const rgb = [0, 0, 0];
+  const before = [0, 0, 0];
+  const excess = [0, 0, 0];
+  let covKey = NaN;
+  let covTile;
+  for (let y = y0; y < y1; y++) {
+    const dy = oy + y;
+    const cty = Math.floor(dy / _chunk474IQG74cjs.TILE);
+    for (let x = x0; x < x1; x++) {
+      const dx = ox + x;
+      const ctx = Math.floor(dx / _chunk474IQG74cjs.TILE);
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, ctx, cty);
+      if (key !== covKey) {
+        covKey = key;
+        covTile = coverage.tiles.get(key);
+      }
+      if (!covTile) continue;
+      const c = covTile[(dy - cty * _chunk474IQG74cjs.TILE) * _chunk474IQG74cjs.TILE + (dx - ctx * _chunk474IQG74cjs.TILE)];
+      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 i = (y * _chunk474IQG74cjs.TILE + x) * 4;
+      if (out[i + 3] === 0) continue;
+      for (let ch = 0; ch < 3; ch++) {
+        const v = out[i + ch];
+        if (linear) {
+          excess[ch] = v > 1 ? v - 1 : 0;
+          rgb[ch] = _chunk2VX55NFMcjs.srgbEncode.call(void 0, v > 1 ? 1 : v < 0 ? 0 : v);
+        } else rgb[ch] = v / 65535;
+        before[ch] = rgb[ch];
+      }
+      tone(rgb);
+      for (let ch = 0; ch < 3; ch++) {
+        const e = before[ch] + (rgb[ch] - before[ch]) * k;
+        if (linear) out[i + ch] = _chunk2VX55NFMcjs.srgbDecode.call(void 0, e) + excess[ch];
+        else out[i + ch] = e <= 0 ? 0 : e >= 1 ? 65535 : Math.round(e * 65535);
+      }
+    }
+  }
+  return out;
+}
+function toneOf(tool, settings) {
+  const burn = tool === "burn";
+  return (rgb) => {
+    dodgeBurn(rgb, settings.exposure, settings.range, burn, settings.protectTones);
+  };
+}
+function healPixels(w, h, src, dst, mask) {
+  const out = new Float32Array(dst);
+  const bb = _chunkBB6TR422cjs.maskBounds.call(void 0, w, h, mask);
+  if (!bb) return out;
+  const x0 = Math.max(0, bb[0] - 1);
+  const y0 = Math.max(0, bb[1] - 1);
+  const x1 = Math.min(w, bb[2] + 1);
+  const y1 = Math.min(h, bb[3] + 1);
+  const rw = x1 - x0;
+  const rh = y1 - y0;
+  const s = new Float32Array(rw * rh * 4);
+  const d = new Float32Array(rw * rh * 4);
+  const m = new Uint8Array(rw * rh);
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const gi = (y + y0) * w + x + x0;
+      const li = y * rw + x;
+      m[li] = mask[gi] ? 1 : 0;
+      for (let c = 0; c < 4; c++) {
+        s[li * 4 + c] = src[gi * 4 + c];
+        d[li * 4 + c] = dst[gi * 4 + c];
+      }
+    }
+  }
+  const healed = _chunkBB6TR422cjs.seamlessClone.call(void 0, rw, rh, 4, s, d, m);
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const gi = ((y + y0) * w + x + x0) * 4;
+      const li = (y * rw + x) * 4;
+      for (let c = 0; c < 4; c++) out[gi + c] = Math.min(255, Math.max(0, healed[li + c]));
+    }
+  }
+  return out;
+}
+function spotHealPixels(w, h, img, hole, size, type, onOffset) {
+  const domain = _chunkBB6TR422cjs.dilateMask.call(void 0, w, h, hole, 2);
+  const healMask = _chunkBB6TR422cjs.dilateMask.call(void 0, w, h, hole, 1);
+  let filled = null;
+  let bestFound = null;
+  if (type === "proximity-match") {
+    const ring = Math.min(16, Math.max(3, Math.floor(size / 8)));
+    const off = _chunkBB6TR422cjs.bestOffset.call(void 0, w, h, 4, img, domain, ring, Math.floor(Math.max(w, h) / 2));
+    if (off) {
+      bestFound = off;
+      filled = new Float32Array(img);
+      const [ddx, ddy] = off;
+      for (let i = 0; i < w * h; i++) {
+        if (!domain[i]) continue;
+        const x = i % w + ddx;
+        const y = Math.floor(i / w) + ddy;
+        const j = (y * w + x) * 4;
+        for (let c = 0; c < 4; c++) filled[i * 4 + c] = img[j + c];
+      }
+    }
+  }
+  _optionalChain([onOffset, 'optionalCall', _ => _(filled ? bestFound : null)]);
+  if (!filled && type === "content-aware") filled = _chunkBB6TR422cjs.contentAwareFill.call(void 0, w, h, 4, img, domain);
+  if (!filled) filled = _chunkBB6TR422cjs.membraneFill.call(void 0, w, h, 4, img, domain);
+  return healPixels(w, h, filled, img, healMask);
+}
+function spotHealWindow(bounds, canvas) {
+  const g = Math.max(8, Math.ceil(Math.max(bounds.width, bounds.height)));
+  const x0 = Math.max(0, bounds.x - g);
+  const y0 = Math.max(0, bounds.y - g);
+  const x1 = Math.min(canvas.width, bounds.x + bounds.width + g);
+  const y1 = Math.min(canvas.height, bounds.y + bounds.height + g);
+  return { x: x0, y: y0, width: Math.max(0, x1 - x0), height: Math.max(0, y1 - y0) };
+}
+var RetouchDabStroke = (_class3 = class {
+  constructor(brush, target, effect) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);
+    this.brush = brush;
+    this.effect = effect;
+    this.walker = new (0, _chunkFQPUF2W2cjs.DabWalker)(brush);
+    this.medium = new (0, _chunkFQPUF2W2cjs.TileMedium)(target);
+  }
+  
+  
+  __init5() {this.dabCount = 0}
+  __init6() {this.bounds = null}
+  
+  
+  __init7() {this.smoothPos = null}
+  __init8() {this.buf = new Float32Array(0)}
+  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 = _chunkFQPUF2W2cjs.dabRect.call(void 0, 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);
+      _chunkFQPUF2W2cjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.brush.hardness, rect, cov);
+      this.medium.reset();
+      this.effect(this.medium, d, rect, cov);
+      rects.push(rect);
+      this.bounds = unionRect(this.bounds, rect);
+      this.dabCount++;
+    }
+    return rects;
+  }
+}, _class3);
+function smudgeEffect(brush, strength, mixing = "rgb") {
+  const s = Math.min(1, Math.max(0, strength));
+  const tip = new (0, _chunkFQPUF2W2cjs.SmudgeTip)({ strength: s, length: s, mixing }, brush.size);
+  return (medium, d, rect, cov) => tip.dab(medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha }, rect, cov);
+}
+function spongeEffect(brush, saturate, vibrance) {
+  const rgb = [0, 0, 0];
+  return (medium, d, rect, cov) => {
+    const w = rect.width;
+    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;
+        const k = perDabStrength(cv * d.alpha * d.opacity * 0.5, brush.spacing) * medium.selectionAt(dx, dy);
+        if (k <= 0) continue;
+        const ri = medium.locate(dx, dy, false);
+        if (ri < 0 || medium.pixels[ri + 3] === 0) continue;
+        const i = medium.locate(dx, dy, true);
+        const px = medium.pixels;
+        rgb[0] = px[i] / 255;
+        rgb[1] = px[i + 1] / 255;
+        rgb[2] = px[i + 2] / 255;
+        sponge(rgb, k, saturate, vibrance);
+        _chunkFQPUF2W2cjs.put255.call(void 0, px, i, rgb[0]);
+        _chunkFQPUF2W2cjs.put255.call(void 0, px, i + 1, rgb[1]);
+        _chunkFQPUF2W2cjs.put255.call(void 0, px, i + 2, rgb[2]);
+      }
+    }
+  };
+}
+function rgbaViewOfGrey(target) {
+  const views = /* @__PURE__ */ new Map();
+  const dirty = /* @__PURE__ */ new Map();
+  const expand = (g) => {
+    const out = new Uint8ClampedArray(g.length * 4);
+    for (let i = 0; i < g.length; i++) {
+      out[i * 4] = out[i * 4 + 1] = out[i * 4 + 2] = g[i];
+      out[i * 4 + 3] = 255;
+    }
+    return out;
+  };
+  const view = {
+    offset: target.offset,
+    lockTransparency: true,
+    selection: target.selection,
+    readTile: (tx, ty) => {
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(_nullishCoalesce(target.readTile(tx, ty), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE))));
+        views.set(key, v);
+      }
+      return v;
+    },
+    writeTile: (tx, ty) => {
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+      let v = views.get(key);
+      if (!v) {
+        v = expand(_nullishCoalesce(target.readTile(tx, ty), () => ( new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE))));
+        views.set(key, v);
+      }
+      dirty.set(key, { tx, ty, data: v });
+      return v;
+    }
+  };
+  return {
+    target: view,
+    flush: () => {
+      for (const { tx, ty, data } of dirty.values()) {
+        const g = target.writeTile(tx, ty);
+        for (let i = 0; i < g.length; i++) g[i] = data[i * 4];
+      }
+      dirty.clear();
+    }
+  };
+}
+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 };
+}
+
+// src/paint/pointer.ts
+function pointerPressure(e) {
+  if (e.pointerType === "pen" && typeof e.pressure === "number" && e.pressure > 0) return Math.min(1, e.pressure);
+  return 1;
+}
+function pointerStrokeSample(e, toPoint) {
+  const p = toPoint(e.clientX, e.clientY);
+  const s = { x: p.x, y: p.y, pressure: pointerPressure(e) };
+  if (typeof e.timeStamp === "number" && Number.isFinite(e.timeStamp)) s.t = e.timeStamp;
+  if (e.pointerType === "pen") {
+    if (typeof e.altitudeAngle === "number" && e.altitudeAngle < Math.PI / 2 - 1e-6) {
+      s.altitude = e.altitudeAngle;
+      s.azimuth = _nullishCoalesce(e.azimuthAngle, () => ( 0));
+    } else if (e.tiltX || e.tiltY) {
+      s.tiltX = _nullishCoalesce(e.tiltX, () => ( 0));
+      s.tiltY = _nullishCoalesce(e.tiltY, () => ( 0));
+    }
+  }
+  return s;
+}
+function pointerStrokeSamples(e, toPoint) {
+  const events = _nullishCoalesce(_optionalChain([e, 'access', _2 => _2.getCoalescedEvents, 'optionalCall', _3 => _3()]), () => ( []));
+  return (events.length ? events : [e]).map((ev) => pointerStrokeSample(ev, toPoint));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createPigmentTools = createPigmentTools; exports.TONE_RANGES = TONE_RANGES; exports.luma = luma; exports.dodgeBurnCurve = dodgeBurnCurve; exports.dodgeBurn = dodgeBurn; exports.saturationOf = saturationOf; exports.sponge = sponge; exports.perDabStrength = perDabStrength; exports.RETOUCH_SAMPLES = RETOUCH_SAMPLES; exports.SPOT_HEAL_TYPES = SPOT_HEAL_TYPES; exports.DEFAULT_RETOUCH = DEFAULT_RETOUCH; exports.normalizeRetouch = normalizeRetouch; exports.boxBlurPixels = boxBlurPixels; exports.retouchFilter = retouchFilter; exports.IDENTITY_CLONE_TRANSFORM = IDENTITY_CLONE_TRANSFORM; exports.isIdentityCloneTransform = isIdentityCloneTransform; exports.cloneSamplePoint = cloneSamplePoint; exports.TransformedPixelSource = TransformedPixelSource; exports.TilePixelSource = TilePixelSource; exports.RegionPixelSource = RegionPixelSource; exports.readSourceRegion = readSourceRegion; exports.applyRetouchToTile = applyRetouchToTile; exports.applyToneToDeepTile = applyToneToDeepTile; exports.toneOf = toneOf; exports.healPixels = healPixels; exports.spotHealPixels = spotHealPixels; exports.spotHealWindow = spotHealWindow; exports.RetouchDabStroke = RetouchDabStroke; exports.smudgeEffect = smudgeEffect; exports.spongeEffect = spongeEffect; exports.rgbaViewOfGrey = rgbaViewOfGrey; exports.pointerPressure = pointerPressure; exports.pointerStrokeSample = pointerStrokeSample; exports.pointerStrokeSamples = pointerStrokeSamples;