@pixerate/editor 0.109.0 → 0.110.0

package/dist/blending-DXl06NSx.d.ts

@@ -0,0 +1,486 @@
+import { B as BlendMode, R as RasterRect, T as TileKey, P as Pigment } from './surface-C8RRg_Bh.js';
+
+/**
+ * The brush engine (a subset of photocraft's `crates/paint`): a computed round tip with size,
+ * hardness, angle, roundness and spacing; pressure to size and opacity; smoothing; and Photoshop's
+ * opacity-versus-flow build-up. Strokes are data, so one replays the same way for undo, agents
+ * and tests.
+ *
+ * - Points are walked into dabs at `spacing × diameter` (`walkDabs`).
+ * - Each dab's coverage (`dabCoverage`, photocraft's measured Photoshop profile) builds up in a
+ *   stroke coverage map with flow towards the dab's opacity ceiling: `c ← c + v·(ceil − c)`.
+ * - The stroke composites once at the stroke opacity over the layer as it was before the stroke,
+ *   so overlapping dabs never exceed the opacity.
+ */
+
+/** One input sample. Missing pressure is a mouse (1). */
+interface StrokePoint {
+    x: number;
+    y: number;
+    /** 0..1 (default 1). */
+    pressure?: number;
+    /** Milliseconds (optional; kept for replays). */
+    t?: number;
+}
+interface BrushSettings {
+    /** Diameter in pixels (1..2500, default 20). */
+    size: number;
+    /** 0 (soft) .. 1 (hard, default). */
+    hardness: number;
+    /** Dab spacing as a fraction of the diameter (0.01..10, default 0.1). */
+    spacing: number;
+    /** Tip angle in degrees (default 0). */
+    angle: number;
+    /** Tip roundness 0.01..1 (default 1). */
+    roundness: number;
+    /** Stroke opacity ceiling 0..1 (default 1). */
+    opacity: number;
+    /** Build-up per dab 0..1 (default 1). */
+    flow: number;
+    /** Input smoothing 0..0.95 (default 0). */
+    smoothing: number;
+    /** Pressure controls size (default true). */
+    pressureSize: boolean;
+    /** Pressure controls opacity (default false). */
+    pressureOpacity: boolean;
+    /** How the stroke paints onto the layer (default normal). */
+    blend: BlendMode;
+}
+declare const DEFAULT_BRUSH: Readonly<BrushSettings>;
+declare const MAX_BRUSH_SIZE = 2500;
+/** A brush with every field in range (missing fields from `DEFAULT_BRUSH`). */
+declare function normalizeBrush(raw?: Partial<BrushSettings>): BrushSettings;
+/** The core radius and shoulder width (pixels) of a round tip of `radius` and `hardness`. */
+declare function tipShape(radius: number, hardness: number): [number, number];
+/** Opacity of a round tip at distance `d` from its centre. */
+declare function tipFalloff(d: number, radius: number, hardness: number): number;
+/** How far from its centre a round tip still paints. */
+declare function tipReach(radius: number, hardness: number): number;
+/** Coverage of a round dab at distance `d` from its centre. */
+declare function dabCoverage(d: number, radius: number, hardness: number): number;
+interface Dab {
+    x: number;
+    y: number;
+    radius: number;
+    /** Flow (per-dab build-up). */
+    alpha: number;
+    /** Opacity ceiling this dab builds up to. */
+    opacity: number;
+    /** Radians. */
+    angle: number;
+    roundness: number;
+}
+/** Exponential smoothing of input points; the first and last point are kept. */
+declare function smoothPoints(points: readonly StrokePoint[], amount: number): StrokePoint[];
+/**
+ * Walks points into dabs (incrementally: feed points in any chunks and get the same dabs). The
+ * first point is a dab; then one every `spacing × diameter` along the path.
+ */
+declare class DabWalker {
+    readonly brush: BrushSettings;
+    private last;
+    private nextAt;
+    private pendingFirst;
+    constructor(brush: BrushSettings);
+    private diameter;
+    private stepLen;
+    private dab;
+    push(p: StrokePoint, out: Dab[]): void;
+    finish(out: Dab[]): void;
+}
+/** All dabs of a point list (smoothing applied). */
+declare function walkDabs(points: readonly StrokePoint[], brush: BrushSettings): Dab[];
+/** The pixel rectangle a dab can touch. */
+declare function dabRect(d: Dab, hardness: number): RasterRect;
+/**
+ * Rasterizes one dab over `rect` into `out` (rect.width × rect.height values, coverage × flow).
+ * Small tips (radius below 3 px) take each pixel's covered area from a 4×4 grid.
+ */
+declare function rasterizeDab(d: Dab, hardness: number, rect: RasterRect, out: Float32Array): void;
+/** A stroke's accumulated coverage, in 256 px tiles over document space. */
+declare class CoverageMap {
+    readonly tiles: Map<number, Float32Array<ArrayBufferLike>>;
+    bounds: RasterRect | null;
+    private dirty;
+    get(x: number, y: number): number;
+    /** Builds up `vals` (over `rect`) with flow towards `ceil`: `c ← c + v·(ceil − c)`. */
+    accumulate(rect: RasterRect, vals: Float32Array, ceil: number): void;
+    /** Tiles changed since the last call. */
+    takeDirty(): TileKey[];
+}
+/** Paints a stroke's dabs into a coverage map, incrementally. */
+declare class StrokeCoverage {
+    readonly brush: BrushSettings;
+    readonly coverage: CoverageMap;
+    private walker;
+    private smoothing;
+    private smoothPos;
+    private buf;
+    dabCount: number;
+    constructor(brush: BrushSettings);
+    /** Feeds input points; returns the document rectangles the new dabs touched. */
+    push(points: readonly StrokePoint[]): RasterRect[];
+    /** Ends the stroke (a single click still paints one dab). */
+    finish(last?: StrokePoint): RasterRect[];
+    private smooth;
+    private paint;
+}
+/** How a stroke changes pixels. */
+interface StrokeApply {
+    /** `paint` puts colour down; `erase` removes alpha (or, with transparency locked, paints `background`). */
+    mode: 'paint' | 'erase';
+    /** RGBA 0..255 (paint colour, or the mask grey in `r`). */
+    color: readonly [number, number, number, number];
+    /** RGBA 0..255 the eraser paints on a transparency-locked layer (and on masks). */
+    background: readonly [number, number, number, number];
+    opacity: number;
+    blend: BlendMode;
+    lockTransparency: boolean;
+    /** Selection coverage (document space, canvas-sized), or `null`. */
+    selection: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+    /** Layer offset (target pixels are in layer space). */
+    offset: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Composites the stroke's coverage over `tileData` (the target's tile (tx, ty) as it was before
+ * the stroke, in layer space; RGBA or one byte for masks) and returns the new tile data. With
+ * `into` (the tile's previous result) and `region` (document space), only `region` is recomputed
+ * and the rest of `into` is kept.
+ */
+declare function applyStrokeToTile(coverage: CoverageMap, tileData: Uint8ClampedArray, channels: 1 | 4, tx: number, ty: number, s: StrokeApply, options?: {
+    into?: Uint8ClampedArray;
+    region?: RasterRect;
+}): Uint8ClampedArray;
+/** Tile coordinates of coverage tile keys (for callers that track dirty tiles). */
+declare function coverageTileCoord(key: TileKey): {
+    tx: number;
+    ty: number;
+};
+
+/**
+ * The pick-up / mix exchange between a loaded brush and the paint under it: the one mechanism
+ * every wet-capable brush shares. The Mixer Brush (`MixerStroke`) and the paint editor's
+ * wet-capable brushes run on it now; the wet layer (phase 3) plugs in as another `PaintMedium`.
+ *
+ * Two halves:
+ *
+ * - `PaintExchange` is what the brush carries: a **reservoir** of loaded paint (with an amount
+ *   that drains per dab) and a **well** of paint picked up from the canvas. Per dab it
+ *   1. picks up: the well moves towards the colour under the dab by the pick-up rate times how
+ *      much of the footprint holds paint (`pickUp`);
+ *   2. mixes the dab's paint: reservoir weight `amount × (1 − mix)`, well weight `mix`
+ *      (`paint`);
+ *   3. drains the reservoir (`drain`).
+ *   Every mix is RGB or Kubelka-Munk pigment (`mixing`), so a blue brush through yellow goes
+ *   green.
+ * - `PaintMedium` is what the brush touches: `sample` (the colour and contact under a footprint)
+ *   and `deposit` (lay paint at per-pixel amounts). `TileMedium` is the raster layer's pixels.
+ *   A wet layer implements the same two calls over its wet pigment and water (sampling only wet
+ *   paint, so pick-up lifts what is still wet), and nothing in `PaintExchange` changes.
+ *
+ * The ratios a user sets are `pickup` (pick-up ratio, 0..1) and `mix` (mix ratio, 0..1);
+ * `exchangeRates` turns them into per-dab rates with the Mixer Brush's constants, so a Mixer
+ * Brush's `wet` and `mix` are exactly these two ratios. Everything is data in, pixels out.
+ */
+
+/** How colours mix: straight sRGB averages, or like paint (Kubelka-Munk). */
+type MixingModel = 'rgb' | 'pigment';
+declare const MIXING_MODELS: readonly MixingModel[];
+/** An sRGB colour, 0..1 per channel. */
+type RgbTriple = [number, number, number];
+/** What a brush carries between dabs and strokes. Colours are straight sRGB, 0..1. */
+interface MixerLoad {
+    /** Loaded paint, or `null` when the brush is unloaded. */
+    readonly reservoir: readonly [number, number, number] | null;
+    /** Reservoir left, 0..1. */
+    readonly amount: number;
+    /** Colour picked up from the canvas (the well), or `null` when the brush is clean. */
+    readonly pickup: readonly [number, number, number] | null;
+}
+declare const EMPTY_MIXER_LOAD: MixerLoad;
+/** Fraction of the way the well moves towards the canvas colour per dab at a pick-up ratio of 1. */
+declare const MIXER_PICKUP_RATE = 0.25;
+/** Fraction of the reservoir that drains per dab at a load of 0. */
+declare const MIXER_DRAIN = 0.08;
+/** Per-dab rates of an exchange. */
+interface ExchangeRates {
+    /** How far the well moves towards the canvas colour per dab at full contact (0: lifts nothing). */
+    pickup: number;
+    /** The well's weight in each dab's paint; the reservoir gets `amount × (1 − mix)`. */
+    mix: number;
+    /** Fraction of the reservoir lost per dab. */
+    drain: number;
+    mixing: MixingModel;
+}
+/**
+ * Per-dab rates from the ratios a user sets: pick-up ratio `pickup` (0 dry .. 1), mix ratio
+ * `mix` (0 .. 1, scaled by the pick-up ratio: a brush that lifts nothing has nothing to mix) and
+ * `load` (1 never drains). The Mixer Brush passes its `wet`, `mix` and `load`.
+ */
+declare function exchangeRates(pickup: number, mix: number, load: number, mixing: MixingModel): ExchangeRates;
+/** What a footprint holds: its average paint colour and how much of it holds paint (0..1). */
+interface PaintSample {
+    rgb: RgbTriple;
+    /** Paint-weighted share of the footprint (alpha × coverage over coverage). */
+    contact: number;
+}
+/** The brush side of the exchange: reservoir, amount and well, mixed per dab. */
+declare class PaintExchange {
+    readonly rates: ExchangeRates;
+    private reservoir;
+    private amount;
+    private well;
+    private readonly pig;
+    private readonly out;
+    constructor(rates: ExchangeRates, load: MixerLoad);
+    /** What the brush carries now. */
+    get load(): MixerLoad;
+    /** The colour picked up so far, or `null`. */
+    get pickup(): Readonly<RgbTriple> | null;
+    /** The prepared pigment of the last `paint` colour (pigment mixing only), for `deposit`. */
+    get paintPigment(): Pigment | null;
+    /** Recolours the reservoir without refilling it (a multi-coloured brush, per dab). */
+    setReservoirColor(r: number, g: number, b: number): void;
+    /** `a` mixed `t` of the way to `b` into `this.out`, by the mixing model. */
+    private mix;
+    /** `a` mixed `t` of the way to `b` (sRGB 0..1) by the mixing model, into `out`. */
+    mixColors(a: readonly number[], b: readonly number[], t: number, out: number[]): number[];
+    /** 1. Pick-up: the well moves towards the sampled colour (or takes it, when clean). */
+    pickUp(sample: PaintSample | null): void;
+    /**
+     * 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: RgbTriple): number;
+    /** 3. The reservoir drains. */
+    drain(): void;
+}
+/** The pixels a brush reads and writes (RGBA tiles in layer space). */
+interface PaintTileTarget {
+    /** The tile (TILE × TILE × 4) at (tx, ty) as it is now, or `null` when it is fully transparent. */
+    readTile(tx: number, ty: number): Uint8ClampedArray | null;
+    /** A writable tile at (tx, ty), returned by `readTile` from then on. */
+    writeTile(tx: number, ty: number): Uint8ClampedArray;
+    /** Layer offset: layer pixel = document pixel − offset. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** Keep alpha and paint only where the layer has pixels. */
+    lockTransparency: boolean;
+    /** Selection coverage (document space, canvas-sized), or `null`. */
+    selection: {
+        width: number;
+        height: number;
+        data: ArrayLike<number>;
+    } | null;
+}
+/** The canvas side of the exchange: where a brush picks paint up and lays it down. */
+interface PaintMedium {
+    /** The paint under a footprint (`cov` over `rect`, document space), or `null` where there is none. */
+    sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
+    /**
+     * Lays paint over the footprint at `dep × cov` per pixel. The colour is `paint` (with its
+     * prepared pigment for pigment mixing), or per pixel from `field` (3 floats per pixel of
+     * `rect`, sRGB 0..1) when given.
+     */
+    deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, paintPigment: Pigment | null, field?: Float32Array | null): void;
+}
+interface TileMediumOptions {
+    /**
+     * How deposits combine with the pixels. Missing: the exchange's mixing (source-over, or a
+     * pigment mix with pigment mixing), as the Mixer Brush paints. Otherwise any blend mode, as a
+     * brush tip's `blend`.
+     */
+    blend?: BlendMode;
+}
+/** A raster layer's pixels as a `PaintMedium` (through live tiles). */
+declare class TileMedium implements PaintMedium {
+    readonly target: PaintTileTarget;
+    private readonly options;
+    private tx;
+    private ty;
+    private tile;
+    private writable;
+    private readonly canvasPig;
+    private readonly paintPig;
+    private paintKey;
+    private readonly cb;
+    private readonly src;
+    private readonly o;
+    constructor(target: PaintTileTarget, options?: TileMediumOptions);
+    /** Forgets the cached tile (call when another writer may have replaced tiles). */
+    reset(): void;
+    /**
+     * 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: number, dy: number, write: boolean): number;
+    /** The tile `locate` last found. */
+    get pixels(): Uint8ClampedArray;
+    /** Selection coverage at a document pixel, 0..1 (1 without a selection). */
+    selectionAt(dx: number, dy: number): number;
+    sample(rect: RasterRect, cov: ArrayLike<number>): PaintSample | null;
+    deposit(rect: RasterRect, cov: ArrayLike<number>, dep: number, paint: Readonly<RgbTriple>, paintPigment: Pigment | null, field?: Float32Array | null): void;
+}
+
+/**
+ * The Mixer Brush: a reservoir of loaded paint plus a pickup well that takes up colour from the
+ * canvas under each dab (photocraft's behavioural model):
+ *
+ * - Each dab samples the canvas under its footprint (coverage- and alpha-weighted). The pickup
+ *   colour `P` moves towards that sample by `PICKUP_RATE × wet` (scaled by the sample's coverage).
+ * - The dab's paint mixes the reservoir `R` (weight `amount × (1 − mix·wet)`) with the pickup
+ *   (weight `mix·wet`) and lands at `flow × opacity` times the total weight, over the pixels as
+ *   they are now, so earlier dabs of the same stroke are picked up again (smearing).
+ * - The reservoir drains per dab unless `load` is 1, so low-load strokes run dry. A dry brush
+ *   (`wet` 0) paints only reservoir colour; an empty, wet brush smears canvas colour.
+ *
+ * `mixing: 'pigment'` does all three mixes (pickup, paint and deposit) with the Kubelka-Munk model
+ * of `./pigment`, so a blue brush dragged through yellow makes green instead of grey. Everything
+ * is data in, pixels out: the same canvas, points, settings and load replay identically.
+ */
+
+/** Mixer Brush options. */
+interface MixerSettings {
+    /** How much colour the brush picks up from the canvas (the pick-up ratio), 0 (dry) .. 1 (default 0.5). */
+    wet: number;
+    /** How much paint the reservoir holds, 0 .. 1 (default 0.5): below 1 it drains per dab and the stroke runs dry. */
+    load: number;
+    /** How far each dab's paint moves from the reservoir towards the picked-up colour (the mix ratio), 0 .. 1 (default 0.5). */
+    mix: number;
+    /** Refill the reservoir with the paint colour at the start of each stroke (default true). */
+    loadEachStroke: boolean;
+    /** Empty the pickup well after each stroke (default true); off keeps the brush dirty for the next stroke. */
+    cleanEachStroke: boolean;
+    /** `rgb` (default) or `pigment` (blue and yellow make green). */
+    mixing: MixingModel;
+}
+declare const DEFAULT_MIXER: Readonly<MixerSettings>;
+/** Mixer settings with every field in range (missing fields from `DEFAULT_MIXER`). */
+declare function normalizeMixer(raw?: Partial<MixerSettings>): MixerSettings;
+/** The per-dab exchange rates of Mixer Brush settings (`wet` is the pick-up ratio, `mix` the mix ratio). */
+declare function mixerRates(settings: MixerSettings): ExchangeRates;
+/** The brush loaded full with `color` (sRGB 0..1); the pickup well is kept. */
+declare function loadMixer(load: MixerLoad, color: readonly [number, number, number]): MixerLoad;
+/** The brush with its pickup well emptied; the reservoir is kept. */
+declare function cleanMixer(load: MixerLoad): MixerLoad;
+/** The pixels a mixer stroke reads and writes (RGBA tiles in layer space). */
+type MixerTarget = PaintTileTarget;
+/**
+ * One Mixer Brush stroke. Feed points with `push` (any chunks give the same dabs), end with
+ * `finish`; `load` is the brush load after the dabs so far. Each call returns the document
+ * rectangles it touched. Runs on the shared pick-up / mix exchange (`./exchange`).
+ */
+declare class MixerStroke {
+    readonly brush: BrushSettings;
+    dabCount: number;
+    bounds: RasterRect | null;
+    private walker;
+    private smoothPos;
+    private buf;
+    private readonly exchange;
+    private readonly medium;
+    private readonly paintColor;
+    constructor(brush: BrushSettings, settings: Partial<MixerSettings>, load: MixerLoad, target: MixerTarget);
+    /** The brush load after the dabs so far. */
+    get load(): MixerLoad;
+    push(points: readonly StrokePoint[]): RasterRect[];
+    finish(last?: StrokePoint): RasterRect[];
+    private smooth;
+    private paint;
+    private dab;
+}
+
+/**
+ * Blending tools on raster tiles, dab by dab (any dab walker can drive them):
+ *
+ * - **Blender** (`blenderDab`): every pixel under the tip moves towards the mix of the paint
+ *   within `distance` of it, so neighbouring colours run together. The mix is taken through the
+ *   pigment model: the neighbourhood's K/S spectra are averaged with Kubelka-Munk weights
+ *   (alpha × scattering), so blue next to yellow blends into green, not grey. `rgb` averages
+ *   straight colours instead.
+ * - **Smudge** (`SmudgeTip`): a finger that carries a patch of paint. Each dab lays the patch it
+ *   carries over the pixels under the tip (`strength`) and picks up some of the paint that was
+ *   there (`1 − length`), so the paint's pattern is dragged along the stroke and fades with distance.
+ *   Optional pigment mixing for both steps.
+ *
+ * Both blend alpha too: blending next to bare canvas softens an edge, smudging drags paint out
+ * into it. A transparency-locked layer keeps its alpha. Pure data in, pixels out.
+ */
+
+/** Blender options. */
+interface BlenderSettings {
+    /** How far each pixel moves towards the neighbourhood mix per dab at full coverage, 0..1 (default 0.5). */
+    strength: number;
+    /** Blend distance: the neighbourhood's radius as a fraction of the tip diameter, 0..1 (default 0.35). */
+    distance: number;
+    /** `pigment` (default: Kubelka-Munk, blue next to yellow blends green) or `rgb`. */
+    mixing: MixingModel;
+}
+declare const DEFAULT_BLENDER: Readonly<BlenderSettings>;
+/** Smudge options. */
+interface SmudgeSettings {
+    /** How strongly the carried paint covers the pixels under the tip per dab, 0..1 (default 0.7). */
+    strength: number;
+    /** How far paint is dragged: the share of the carried patch kept per dab, 0..1 (default 0.85). */
+    length: number;
+    /** `rgb` (default) or `pigment` (smeared colours mix like paint). */
+    mixing: MixingModel;
+}
+declare const DEFAULT_SMUDGE: Readonly<SmudgeSettings>;
+declare function normalizeBlender(raw?: Partial<BlenderSettings>, base?: BlenderSettings): BlenderSettings;
+declare function normalizeSmudge(raw?: Partial<SmudgeSettings>, base?: SmudgeSettings): SmudgeSettings;
+/** The neighbourhood radius in pixels of a blender dab of `radius`. */
+declare function blendRadius(settings: BlenderSettings, radius: number): number;
+/** Reusable buffers for `blenderDab` (one per stroke). */
+interface BlenderScratch {
+    sums: Float64Array;
+    mix: Pigment;
+    out: number[];
+}
+declare function createBlenderScratch(): BlenderScratch;
+/**
+ * One blender dab: `cov` is the tip's coverage over `rect` (document space, 0..1), `opacity` the
+ * dab's (pressure) opacity, `radius` its radius in pixels. Reads the neighbourhood as it was
+ * before the dab, then writes every covered pixel.
+ */
+declare function blenderDab(medium: TileMedium, rect: RasterRect, cov: ArrayLike<number>, opacity: number, radius: number, settings: BlenderSettings, scratch: BlenderScratch): void;
+/** A dab as the smudge needs it: centre, radius (px) and pressure opacity. */
+interface SmudgeDab {
+    x: number;
+    y: number;
+    radius: number;
+    opacity: number;
+}
+/**
+ * A smudging finger: carries a patch of paint (straight RGBA, `size × size` cells over the tip,
+ * in canvas orientation) from dab to dab. The first dab only picks the patch up.
+ */
+declare class SmudgeTip {
+    readonly settings: SmudgeSettings;
+    private readonly size;
+    private readonly patch;
+    private loaded;
+    private readonly out;
+    constructor(settings: SmudgeSettings, 
+    /** The largest tip diameter of the stroke, in pixels (the patch resolution). */
+    diameter: number);
+    private cell;
+    /** Fills the patch from the pixels under the dab. */
+    private load;
+    /** `a` mixed `t` of the way to `b` (both 0..1) into `out`. */
+    private mix;
+    /** One dab: lays the carried patch over the tip's footprint (`cov` over `rect`), then picks up. */
+    dab(medium: TileMedium, d: SmudgeDab, rect: RasterRect, cov: ArrayLike<number>): void;
+}
+
+export { tipShape as $, blendRadius as A, type BrushSettings as B, CoverageMap as C, type Dab as D, EMPTY_MIXER_LOAD as E, blenderDab as F, cleanMixer as G, coverageTileCoord as H, createBlenderScratch as I, dabCoverage as J, dabRect as K, exchangeRates as L, type MixerSettings as M, loadMixer as N, mixerRates as O, type PaintTileTarget as P, normalizeBlender as Q, type RgbTriple as R, type SmudgeSettings as S, TileMedium as T, normalizeBrush as U, normalizeMixer as V, normalizeSmudge as W, rasterizeDab as X, smoothPoints as Y, tipFalloff as Z, tipReach as _, type MixingModel as a, walkDabs as a0, type BlenderSettings as b, type StrokePoint as c, type MixerLoad as d, MAX_BRUSH_SIZE as e, StrokeCoverage as f, type MixerTarget as g, MixerStroke as h, type StrokeApply as i, type BlenderScratch as j, DEFAULT_BLENDER as k, DEFAULT_BRUSH as l, DEFAULT_MIXER as m, DEFAULT_SMUDGE as n, DabWalker as o, type ExchangeRates as p, MIXER_DRAIN as q, MIXER_PICKUP_RATE as r, MIXING_MODELS as s, PaintExchange as t, type PaintMedium as u, type PaintSample as v, type SmudgeDab as w, SmudgeTip as x, type TileMediumOptions as y, applyStrokeToTile as z };