Scrawl-canvas filter engine

import { constructors, filter, filternames, styles, stylesnames } from '../core/library.js';

import { seededRandomNumberGenerator } from './random-seed.js';

import { correctAngle, doCreate, easeEngines, isa_fn } from './utilities.js';

import { getOrAddWorkstoreItem, getWorkstoreItem, setAndReturnWorkstoreItem, setWorkstoreItem } from './workstore.js';

import { colorEngine } from './color-engine.js';

import { releaseArray, requestArray } from './array-pool.js';

import { makeAnimation } from '../factory/animation.js';

import { releaseCell, requestCell } from '../untracked-factory/cell-fragment.js';

import { releaseCoordinate, requestCoordinate } from '../untracked-factory/coordinate.js';

import { bluenoise, orderedNoise } from './filter-engine-bluenoise-data.js';

import { _abs, _atan2, _ceil, _cos, _floor, _isArray, _isFinite, _max, _min, _piHalf, _pow, _radian, _round, _sin, _sqrt, ALPHA_TO_CHANNELS, ALPHA_TO_LUMINANCE, AREA_ALPHA, ARG_SPLITTER, AVERAGE_CHANNELS, BLACK_WHITE, BLEND, BLUENOISE, BLUR, CHANNELS_TO_ALPHA, CHROMA, CLAMP_CHANNELS, CLAMP_VALUES, CLEAR, COLOR, COLORS_TO_ALPHA, COMPOSE, CORRODE, DEFAULT_SEED, DESTINATION_OUT, DESTINATION_OVER, DISPLACE, DOWN, EMBOSS, FLOOD, GAUSSIAN_BLUR, GLITCH, GRAYSCALE, GREEN, INVERT_CHANNELS, LOCK_CHANNELS_TO_LEVELS, LUMINANCE_TO_ALPHA, MAP_TO_GRADIENT, MATRIX, MEAN, MODIFY_OK_CHANNELS, MODULATE_CHANNELS, MODULATE_OK_CHANNELS, MULTIPLY, NEGATIVE, NEWSPRINT, OFFSET, OK_PERCEPTUAL_CURVES, ORDERED, PIXELATE, PROCESS_IMAGE, RANDOM, RANDOM_NOISE, RED, REDUCE_PALETTE, ROTATE_HUE, ROUND, SET_CHANNEL_TO_LEVEL, SOURCE, SOURCE_IN, SOURCE_OUT, SOURCE_OVER, STEP_CHANNELS, SWIRL, THRESHOLD, TILES, TINT_CHANNELS, UP, UNSHARP, USER_DEFINED_LEGACY, VARY_CHANNELS_BY_WEIGHTS, ZERO_STR, ZOOM_BLUR } from './shared-vars.js';

const _256 = 256,
    _256_SQUARE = 256 * 256,
    _exp = Math.exp,
    BLUE = 'blue',
    CHROMA_MATCH = 'chroma-match',
    COLOR_BURN = 'color-burn',
    COLOR_DODGE = 'color-dodge',
    CURRENT = 'current',
    DARKEN = 'darken',
    DESTINATION_ATOP = 'destination-atop',
    DESTINATION_IN = 'destination-in',
    DESTINATION_ONLY = 'destination-only',
    DIFFERENCE = 'difference',
    EXCLUSION = 'exclusion',
    GRAY_PALETTES = ['black-white', 'monochrome-4', 'monochrome-8', 'monochrome-16'],
    HARD_LIGHT = 'hard-light',
    HEX = 'hex',
    HUE = 'hue',
    HUE_MATCH = 'hue-match',
    LIGHTEN = 'lighten',
    LIGHTER = 'lighter',
    LUMINOSITY = 'luminosity',
    MONOCHROME_16 = 'monochrome-16',
    MONOCHROME_4 = 'monochrome-4',
    MONOCHROME_8 = 'monochrome-8',
    NAIVE_GRAY_LUT = 'naive-gray-lut',
    OVERLAY = 'overlay',
    POINTS = 'points',
    RECT = 'rect',
    SATURATION = 'saturation',
    SCREEN = 'screen',
    SOFT_LIGHT = 'soft-light',
    SOURCE_ALPHA = 'source-alpha',
    SOURCE_ATOP = 'source-atop',
    SOURCE_ONLY = 'source-only',
    T_FILTER_ENGINE = 'FilterEngine',
    XOR = 'xor';

const OK_BLENDS = [HUE, SATURATION, LUMINOSITY, COLOR, HUE_MATCH, CHROMA_MATCH];

const newspaperPatterns = [
    new Uint8Array([0,0,0,0]),
    new Uint8Array([0,0,0,180]),
    new Uint8Array([180,0,0,0]),
    new Uint8Array([180,0,0,180]),
    new Uint8Array([0,180,180,180]),
    new Uint8Array([180,180,180,0]),
    new Uint8Array([180,180,180,180]),
    new Uint8Array([180,180,180,255]),
    new Uint8Array([255,180,180,180]),
    new Uint8Array([255,180,180,255]),
    new Uint8Array([180,255,255,255]),
    new Uint8Array([255,255,255,180]),
    new Uint8Array([255,255,255,255])
];

const predefinedPalette = {
    [BLACK_WHITE]: [255, 0],
    [MONOCHROME_4]: [255, 187, 102, 0],
    [MONOCHROME_8]: [255, 221, 187, 153, 119, 85, 51, 0],
    [MONOCHROME_16]: [255, 238, 221, 204, 187, 170, 153, 136, 119, 102, 85, 68, 51, 34, 17, 0],
}

let lastUsedReducePalette = 'black-white';
const setLastUsedReducePalette = (val) => lastUsedReducePalette = val;
export const getLastUsedReducePalette = () => lastUsedReducePalette;

let cache = null;

const FilterEngine = function () {

    this.actions = [];

    return this;
};

const P = FilterEngine.prototype = doCreate();
P.type = T_FILTER_ENGINE;

P.action = function (packet) {

    const { identifier, filters, image } = packet;
    const { actions, theBigActionsObject } = this;

    let i, iz, actData, a;

    const itemInWorkstore = getWorkstoreItem(identifier);
    if (itemInWorkstore) return itemInWorkstore;

    actions.length = 0;

    for (i = 0, iz = filters.length; i < iz; i++) {

        actions.push(...filters[i].actions);
    }

    const actionsLen = actions.length;

    if (actionsLen) {

        this.unknit(image);

        for (i = 0; i < actionsLen; i++) {

            actData = actions[i];
            a = theBigActionsObject[actData.action];

            if (a) a.call(this, actData);
        }

        if (identifier) setWorkstoreItem(identifier, cache.work);

        return cache.work;
    }
    return image;
};

P.unknit = function (image) {

    cache = {};

    const { width, height, data } = image;

    cache.source = new ImageData(new Uint8ClampedArray(data), width, height);
    cache.work = new ImageData(new Uint8ClampedArray(data), width, height);
};

const getRandomNumbers = function (items = {}) {

    const {
        seed = DEFAULT_SEED,
        length = 0,
        imgWidth = 0,
        type = RANDOM,
    } = items;

    const name = `random-${seed}-${length}-${type}`,
        itemInWorkstore = getWorkstoreItem(name);

    if (itemInWorkstore) return itemInWorkstore;

    if ((type === BLUENOISE || type === ORDERED) && imgWidth) {

        const base = (type === BLUENOISE) ? bluenoise : orderedNoise,
            dim = (_sqrt(base.length) | 0),
            imgH = ((length / imgWidth) | 0),
            out = new Float32Array(length);

        let p = 0,
            y, y0, x;

        for (y = 0; y < imgH && p < length; y++) {

            y0 = (y % dim) * dim;

            for (x = 0; x < imgWidth && p < length; x++) {

                out[p++] = base[y0 + (x % dim)];
            }
        }
        setWorkstoreItem(name, out);

        return out;
    }
    else {

        const engine = seededRandomNumberGenerator(seed),
            out = new Float32Array(length);

        for (let i = 0; i < length; i++) {

            out[i] = engine.random();
        }
        setWorkstoreItem(name, out);

        return out;
    }
};

const buildTileRects = function (tileWidth, tileHeight, offsetX, offsetY, image) {

    if (!image) image = cache.source;

    const iWidth  = image.width | 0,
        iHeight = image.height | 0;

    if (!iWidth || !iHeight) return new Int32Array(0);

    let tW = (_isFinite(tileWidth) ? tileWidth : 1) | 0,
        tH = (_isFinite(tileHeight) ? tileHeight : 1) | 0,
        offX = (_isFinite(offsetX) ? offsetX : 0) | 0,
        offY = (_isFinite(offsetY) ? offsetY : 0) | 0;

    if (tW < 1) tW = 1;
    if (tW >= iWidth)  tW = iWidth - 1;
    if (tH < 1) tH = 1;
    if (tH >= iHeight) tH = iHeight - 1;

    if (offX < 0) offX = 0;
    else if (offX >= tW) offX = tW - 1;

    if (offY < 0) offY = 0;
    else if (offY >= tH) offY = tH - 1;

    const name = `simple-tileset-rects-${iWidth}-${iHeight}-${tW}-${tH}-${offX}-${offY}`;

    const cached = getWorkstoreItem(name);
    if (cached) return cached;

    const rects = requestArray();

    let j, y0, y1, yEnd, i, x0, x1, xEnd;

    for (j = offY - tH; j < iHeight; j += tH) {

        y0 = (j < 0 ? 0 : j);
        y1 = j + tH;

        if (y0 >= iHeight) break;

        yEnd = (y1 > iHeight ? iHeight : y1);

        for (i = offX - tW; i < iWidth; i += tW) {

            x0 = (i < 0 ? 0 : i);
            x1 = i + tW;

            if (x0 >= iWidth) break;

            xEnd = (x1 > iWidth ? iWidth : x1);

            if (x0 < xEnd && y0 < yEnd) rects.push(x0, y0, xEnd, yEnd);
        }
    }
    const out = new Int32Array(rects);

    setWorkstoreItem(name, out);

    releaseArray(rects);

    return out;
};

const getInputAndOutputLines = function (requirements) {

    const getAlphaData = function (image) {

        const { width, height, data:iData } = image,
            aImg = new ImageData(width, height),
            aData = aImg.data;

        for (let i = 3, len = iData.length; i < len; i += 4) {

            aData[i] = (iData[i] > 0) ? 255 : 0;
        }

        return aImg;
    };

    const sourceData = cache.source;

    let lineIn = cache.work,
        lineMix = false,
        alphaData = false;

    if (requirements.lineIn === SOURCE_ALPHA || requirements.lineMix === SOURCE_ALPHA) alphaData = getAlphaData(sourceData);

    if (requirements.lineIn) {

        if (requirements.lineIn === SOURCE) lineIn = sourceData;
        else if (requirements.lineIn === SOURCE_ALPHA) lineIn = alphaData;
        else if (cache[requirements.lineIn]) lineIn = cache[requirements.lineIn];
    }

    if (requirements.lineMix) {

        if (requirements.lineMix === SOURCE) lineMix = sourceData;
        else if (requirements.lineMix === SOURCE_ALPHA) lineMix = alphaData;
        else if (requirements.lineMix === CURRENT) lineMix = cache.work;
        else if (cache[requirements.lineMix]) lineMix = cache[requirements.lineMix];
    }

    let lineOut;

    if (!requirements.lineOut || !cache[requirements.lineOut]) {

        lineOut = new ImageData(lineIn.width, lineIn.height);

        if (requirements.lineOut) cache[requirements.lineOut] = lineOut;
    }
    else lineOut = cache[requirements.lineOut];

    return [lineIn, lineOut, lineMix];
};

const processResults = function (store, incoming, ratio) {

    const sData = store.data,
        iData = incoming.data;

    if (ratio <= 0) return;

    if (ratio >= 1) {

        sData.set(iData);
        return;
    }

    if (sData.buffer === iData.buffer && sData.byteOffset === iData.byteOffset && sData.byteLength === iData.byteLength) return;

    const k  = (ratio * 255 + 0.5) | 0,
        ak = 255 - k;

    const nPixels = sData.byteLength >>> 2,
        s32 = new Uint32Array(sData.buffer, sData.byteOffset, nPixels),
        i32 = new Uint32Array(iData.buffer, iData.byteOffset, nPixels);

    const M = 0x00FF00FF,
        ROUND = 0x00800080;

    let sv, iv, s_lo, s_hi, i_lo, i_hi, o_lo, o_hi;

    for (let p = 0, pz = s32.length | 0; p < pz; p++) {

        sv = s32[p];
        iv = i32[p];

        s_lo = sv & M;
        s_hi = (sv >>> 8) & M;
        i_lo = iv & M;
        i_hi = (iv >>> 8) & M;

        o_lo = (((s_lo * ak) + (i_lo * k) + ROUND) >>> 8) & M;
        o_hi = (((s_hi * ak) + (i_hi * k) + ROUND) >>> 8) & M;

        s32[p] = ((o_hi << 8) & 0xFF00FF00) | o_lo;
    }
};

const transferDataUnchanged = function (oData, iData, len) {

    if (len === iData.length) oData.set(iData);
    else oData.set(iData.subarray(0, len));
};

const getGaussianCoeffCache = () => {

    const COEFFS_KEY = 'gaussian-blur::coeffs';

    let m = getWorkstoreItem(COEFFS_KEY);

    if (!m) {
        m = new Map();
        setWorkstoreItem(COEFFS_KEY, m);
    }
    return m;
};

const gaussCoefRawFloat = (sigmaIn) => {

    let sigma = sigmaIn;
    if (sigma < 0.5) sigma = 0.5;

    const a  = _exp(0.726 * 0.726) / sigma,
        g1 = _exp(-a),
        g2 = _exp(-2 * a);

    const a0 = (1 - g1) * (1 - g1) / (1 + 2 * a * g1 - g2),
        a1 = a0 * (a - 1) * g1,
        a2 = a0 * (a + 1) * g1,
        a3 = -a0 * g2,
        b1 = 2 * g1,
        b2 = -g2;

    const left_corner  = (a0 + a1) / (1 - b1 - b2),
        right_corner = (a2 + a3) / (1 - b1 - b2);

    return new Float32Array([a0, a1, a2, a3, b1, b2, left_corner, right_corner]);
};

const getGaussianCoeffsFloat = (sigma) => {

    const s = (sigma > 0 ? sigma : 0) || 0,
        key = s < 0.5 ? 0.5 : Math.round(s * 1024) / 1024,
        cache = getGaussianCoeffCache();

    let c = cache.get(key);

    if (!c) {

        c = gaussCoefRawFloat(key);
        cache.set(key, c);
    }
    return c;
};

P.theBigActionsObject = {

    [ALPHA_TO_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer, oData.byteOffset, oData.byteLength >>> 2);

        const {
            opacity = 1,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            excludeRed = true,
            excludeGreen = true,
            excludeBlue = true,
            lineOut,
        } = requirements;

        const Rb = 0x000000FF,
            Gb = 0x0000FF00,
            Bb = 0x00FF0000;

        const incMask = (includeRed ? Rb : 0) | (includeGreen ? Gb : 0) | (includeBlue ? Bb : 0);

        const zeroMask = (!includeRed && excludeRed   ? Rb : 0) | (!includeGreen && excludeGreen ? Gb : 0) | (!includeBlue && excludeBlue  ? Bb : 0);

        const onlyAlphaTo255 = (incMask | zeroMask) === 0;

        if (onlyAlphaTo255) {

            let p, pz, s, a;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                s = src32[p];
                a = (s >>> 24) & 0xFF;

                if (a === 0) continue;

                out32[p] = (s & 0x00FFFFFF) | 0xFF000000;
            }
        }
        else {

            const rgbMask = 0x00FFFFFF;

            let p, pz, s, a, rgb, aRGB;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                s = src32[p];
                a = (s >>> 24) & 0xFF;

                if (a === 0) continue;

                rgb = s & rgbMask;

                if (zeroMask) rgb &= ~zeroMask;

                if (incMask) {

                    aRGB = (a * 0x00010101) & rgbMask;
                    rgb = (rgb & ~incMask) | (aRGB & incMask);
                }
                out32[p] = 0xFF000000 | rgb;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [ALPHA_TO_LUMINANCE]: function (requirements) {

        const LUMINANCE_OKLAB_GRAY_LUT = 'alpha-to-luminance-oklab-gray-lut-256';
        const getOklabGrayLut = () => {

            let lut = getWorkstoreItem(LUMINANCE_OKLAB_GRAY_LUT);

            if (lut != null) return lut;

            else {

                lut = new Uint32Array(256);

                const libs = colorEngine.getRgbOkCache();

                let a, L, r, g, b;

                for (a = 0; a < 256; a++) {

                    L = a / 256;
                    if (L > 1) L = 1;
                    else if (L < 0) L = 0;

                    [r, g, b] = colorEngine.getRgbValsForOklab(L, 0, 0, libs);

                    lut[a] = (255 << 24) | (b << 16) | (g << 8) | r;
                }
                setWorkstoreItem(LUMINANCE_OKLAB_GRAY_LUT, lut);

                return lut;
            }
        };

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            lineOut,
        } = requirements;

        const lut = getOklabGrayLut();

        const RGB_MASK = 0x00FFFFFF;

        let p, pz, s, a;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            s = src32[p];
            a = (s >>> 24) & 0xFF;

            if (a === 0) out32[p] = s & RGB_MASK;
            else out32[p] = lut[a];
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [AREA_ALPHA]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data,
            len = iData.length,
            width = input.width,
            height = input.height;

        const {
            opacity = 1,
            tileWidth = 1,
            tileHeight = 1,
            offsetX = 0,
            offsetY = 0,
            gutterWidth = 1,
            gutterHeight = 1,

            areaAlphaLevels = [255, 0, 0, 0],
            lineOut,
        } = requirements;

        transferDataUnchanged(oData, iData, len);

        let tW = (_isFinite(tileWidth) ? tileWidth : 1) | 0,
            tH = (_isFinite(tileHeight) ? tileHeight : 1) | 0,
            gW = (_isFinite(gutterWidth) ? gutterWidth : 1) | 0,
            gH = (_isFinite(gutterHeight) ? gutterHeight : 1) | 0;

        if (tW < 1) tW = 1;
        if (tH < 1) tH = 1;

        if (tW + gW >= width)  {

            tW = _max(1, width  - gW - 1);
            gW = _max(1, width  - tW - 1);
        }

        if (tH + gH >= height) {

            tH = _max(1, height - gH - 1);
            gH = _max(1, height - tH - 1);
        }

        const aW = tW + gW,
            aH = tH + gH;

        let offX = (_isFinite(offsetX) ? offsetX : 0) | 0,
            offY = (_isFinite(offsetY) ? offsetY : 0) | 0;

        if (offX < 0) offX = 0;
        else if (offX >= aW) offX = aW - 1;

        if (offY < 0) offY = 0;
        else if (offY >= aH) offY = aH - 1;

        const mod = (a, m) => {
            const r = a % m;
            return r < 0 ? r + m : r;
        };

        let y, localY, inCoreY, localX, x, inCoreX, idx, a, segmentSpan, runLen, remain, p, k;

        for (y = 0; y < height; y++) {

            localY = mod(y - offY, aH);
            inCoreY = (localY < tH);

            localX = mod(0 - offX, aW);
            x = 0;

            while (x < width) {

                inCoreX = (localX < tW);

                idx = inCoreY ? (inCoreX ? 0 : 2) : (inCoreX ? 1 : 3);

                a = areaAlphaLevels[idx] | 0;

                segmentSpan = inCoreX ? (tW - localX) : (aW - localX);
                runLen = segmentSpan;
                remain = width - x;

                if (runLen > remain) runLen = remain;

                p = ((y * width) + x) * 4 + 3;

                for (k = 0; k < runLen; k++) {

                    if (iData[p]) oData[p] = a;
                    p += 4;
                }

                x += runLen;

                localX = (localX + runLen) % aW;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [AVERAGE_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer, oData.byteOffset, oData.byteLength >>> 2);

        const {
            opacity = 1,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            excludeRed = false,
            excludeGreen = false,
            excludeBlue = false,
            lineOut,
        } = requirements;

        const divisor = (includeRed ? 1 : 0) + (includeGreen ? 1 : 0) + (includeBlue ? 1 : 0);

        const incR = includeRed  | 0,
            incG = includeGreen | 0,
            incB = includeBlue | 0,
            excR = excludeRed | 0,
            excG = excludeGreen | 0,
            excB = excludeBlue | 0;

        let p, rgba, r, g, b, a, rOut, gOut, bOut, sum, avg;

        for (p = 0; p < src32.length; p++) {

            rgba = src32[p];

            r =  rgba & 0xff;
            g = (rgba >>> 8) & 0xff;
            b = (rgba >>> 16) & 0xff;
            a = (rgba >>> 24) & 0xff;

            if (a === 0) {

                out32[p] = rgba;
                continue;
            }

            if (divisor) {

                sum = (incR ? r : 0) + (incG ? g : 0) + (incB ? b : 0);

                avg = (sum / divisor) | 0;

                rOut = excR ? 0 : avg;
                gOut = excG ? 0 : avg;
                bOut = excB ? 0 : avg;
            }
            else {

                rOut = excR ? 0 : r;
                gOut = excG ? 0 : g;
                bOut = excB ? 0 : b;
            }

            out32[p] = ((a << 24) | (bOut << 16) | (gOut << 8) | (rOut << 0)) >>> 0;
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [BLEND]: function (requirements) {

        const [input, output, mix] = getInputAndOutputLines(requirements);

        const {
            opacity = 1,
            blend = ZERO_STR,
            offsetX = 0,
            offsetY = 0,
            lineOut,
        } = requirements || {};

        if (!mix) {

            transferDataUnchanged(output.data, input.data, input.data.length);
            return;
        }

        const iWidth  = input.width | 0,
            iHeight = input.height | 0,
            iData = input.data,
            mWidth = mix.width | 0,
            mHeight = mix.height | 0,
            mData = mix.data,
            oData = output.data;

        oData.set(iData);

        const nPixInput = (iWidth * iHeight) | 0,
            nPixMix = (mWidth * mHeight) | 0;

        const i32 = new Uint32Array(iData.buffer, iData.byteOffset, nPixInput),
            m32 = new Uint32Array(mData.buffer, mData.byteOffset, nPixMix),
            o32 = new Uint32Array(oData.buffer, oData.byteOffset, nPixInput);

        const x0 = (offsetX > 0 ? offsetX : 0) | 0,
            y0 = (offsetY > 0 ? offsetY : 0) | 0,
            x1 = _min(iWidth,  offsetX + mWidth)  | 0,
            y1 = _min(iHeight, offsetY + mHeight) | 0;

        const hasOverlap = (x1 > x0) && (y1 > y0);
        if (!hasOverlap) {

            if (lineOut) processResults(output, input, 1 - opacity);
            else processResults(cache.work, output, opacity);
            return;
        }

        const inv255 = 1 / 255;

        const libs = colorEngine.getRgbOkCache();

        const isOkBlend = OK_BLENDS.includes(blend);

        const mx0 = (x0 - offsetX) | 0,
            my0 = (y0 - offsetY) | 0;

        let y, my, x, mx,
            iPix, mPix,
            ip, mp,
            ia8, ma8,
            ir, ig, ib, mr, mg, mb,
            As, Ab,
            br, bg, bb,
            Fr, Fg, Fb, Sr, Sg, Sb, Br, Bg, Bb,
            k, oneMinusAs, oneMinusAb, R, G, B, A,
            outR, outG, outB, outA,
            IL, IC, IH, ML, MC, MH,
            okSrc, okMix,
            tmp;

        for (y = y0, my = my0; y < y1; y++, my++) {

            for (x = x0, mx = mx0; x < x1; x++, mx++) {

                iPix = (y * iWidth + x) | 0;
                mPix = (my * mWidth + mx) | 0;

                ip = i32[iPix];
                mp = m32[mPix];

                ia8 = ip >>> 24;
                ma8 = mp >>> 24;

                if (ia8 === 0 || ma8 === 0) continue;

                ir = ip & 0xFF;
                ig = (ip >>> 8) & 0xFF;
                ib = (ip >>> 16) & 0xFF;

                mr = mp & 0xFF;
                mg = (mp >>> 8) & 0xFF;
                mb = (mp >>> 16) & 0xFF;

                As = ia8 * inv255;
                Ab = ma8 * inv255;

                if (isOkBlend) {

                    okSrc = colorEngine.getOkValsForRgb(ir, ig, ib, libs);
                    okMix = colorEngine.getOkValsForRgb(mr, mg, mb, libs);

                    IL = okSrc[0];
                    IC = okSrc[3];
                    IH = okSrc[4];

                    ML = okMix[0];
                    MC = okMix[3];
                    MH = okMix[4];

                    switch (blend) {

                        case COLOR:
                            [br, bg, bb] = colorEngine.getRgbValsForOklch(ML, IC, IH, libs);
                            break;

                        case HUE_MATCH:
                            [br, bg, bb] = colorEngine.getRgbValsForOklch(IL, MC, IH, libs);
                            break;

                        case CHROMA_MATCH:
                            [br, bg, bb] = colorEngine.getRgbValsForOklch(IL, IC, MH, libs);
                            break;

                        case HUE:
                            [br, bg, bb] = colorEngine.getRgbValsForOklch(ML, MC, IH, libs);
                            break;

                        case SATURATION:
                            [br, bg, bb] = colorEngine.getRgbValsForOklch(ML, IC, MH, libs);
                            break;

                        case LUMINOSITY:
                            [br, bg, bb] = colorEngine.getRgbValsForOklch(IL, MC, MH, libs);
                            break;
                    }

                    Fr = br * inv255;
                    Fg = bg * inv255;
                    Fb = bb * inv255;

                    Sr = ir * inv255;
                    Sg = ig * inv255;
                    Sb = ib * inv255;

                    Br = mr * inv255;
                    Bg = mg * inv255;
                    Bb = mb * inv255;

                    k = As * Ab;
                    oneMinusAs = 1 - As;
                    oneMinusAb = 1 - Ab;

                    R = Sr * oneMinusAb + Br * oneMinusAs + Fr * k;
                    G = Sg * oneMinusAb + Bg * oneMinusAs + Fg * k;
                    B = Sb * oneMinusAb + Bb * oneMinusAs + Fb * k;
                    A = As + Ab - As * Ab;
                }
                else {

                    Sr = ir * inv255;
                    Sg = ig * inv255;
                    Sb = ib * inv255;

                    Br = mr * inv255;
                    Bg = mg * inv255;
                    Bb = mb * inv255;

                    switch (blend) {

                        case COLOR_BURN:
                            if (Sr === 0) Fr = 0;
                            else if (Br === 1) Fr = 1;
                            else {
                                tmp = (1 - Br) / Sr;
                                if (tmp > 1) tmp = 1;
                                Fr = 1 - tmp;
                            }

                            if (Sg === 0) Fg = 0;
                            else if (Bg === 1) Fg = 1;
                            else {
                                tmp = (1 - Bg) / Sg;
                                if (tmp > 1) tmp = 1;
                                Fg = 1 - tmp;
                            }

                            if (Sb === 0) Fb = 0;
                            else if (Bb === 1) Fb = 1;
                            else {
                                tmp = (1 - Bb) / Sb;
                                if (tmp > 1) tmp = 1;
                                Fb = 1 - tmp;
                            }
                            break;

                        case COLOR_DODGE:
                            if (Sr === 1) Fr = 1;
                            else if (Br === 0) Fr = 0;
                            else {
                                tmp = Br / (1 - Sr);
                                Fr = tmp > 1 ? 1 : tmp;
                            }

                            if (Sg === 1) Fg = 1;
                            else if (Bg === 0) Fg = 0;
                            else {
                                tmp = Bg / (1 - Sg);
                                Fg = tmp > 1 ? 1 : tmp;
                            }

                            if (Sb === 1) Fb = 1;
                            else if (Bb === 0) Fb = 0;
                            else {
                                tmp = Bb / (1 - Sb);
                                Fb = tmp > 1 ? 1 : tmp;
                            }
                            break;

                        case DARKEN:
                            Fr = _min(Sr, Br);
                            Fg = _min(Sg, Bg);
                            Fb = _min(Sb, Bb);
                            break;

                        case LIGHTEN:
                            Fr = _max(Sr, Br);
                            Fg = _max(Sg, Bg);
                            Fb = _max(Sb, Bb);
                            break;

                        case LIGHTER:
                            Fr = _min(1, Sr + Br);
                            Fg = _min(1, Sg + Bg);
                            Fb = _min(1, Sb + Bb);
                            break;

                        case MULTIPLY:
                            Fr = Sr * Br;
                            Fg = Sg * Bg;
                            Fb = Sb * Bb;
                            break;

                        case SCREEN:
                            Fr = Br + Sr - Br * Sr;
                            Fg = Bg + Sg - Bg * Sg;
                            Fb = Bb + Sb - Bb * Sb;
                            break;

                        case DIFFERENCE:
                            Fr = _abs(Sr - Br);
                            Fg = _abs(Sg - Bg);
                            Fb = _abs(Sb - Bb);
                            break;

                        case EXCLUSION:
                            Fr = Sr + Br - 2 * Sr * Br;
                            Fg = Sg + Bg - 2 * Sg * Bg;
                            Fb = Sb + Bb - 2 * Sb * Bb;
                            break;

                        case OVERLAY:
                            Fr = (Br <= 0.5 ? 2 * Sr * Br : 1 - 2 * (1 - Sr) * (1 - Br));
                            Fg = (Bg <= 0.5 ? 2 * Sg * Bg : 1 - 2 * (1 - Sg) * (1 - Bg));
                            Fb = (Bb <= 0.5 ? 2 * Sb * Bb : 1 - 2 * (1 - Sb) * (1 - Bb));
                            break;

                        case HARD_LIGHT:
                            Fr = (Sr <= 0.5 ? 2 * Sr * Br : 1 - 2 * (1 - Sr) * (1 - Br));
                            Fg = (Sg <= 0.5 ? 2 * Sg * Bg : 1 - 2 * (1 - Sg) * (1 - Bg));
                            Fb = (Sb <= 0.5 ? 2 * Sb * Bb : 1 - 2 * (1 - Sb) * (1 - Bb));
                            break;

                        case SOFT_LIGHT: {

                            const DBr = (Br <= 0.25)
                                ? (((16 * Br - 12) * Br) + 4) * Br
                                : _sqrt(Br);

                            const DBg = (Bg <= 0.25)
                                ? (((16 * Bg - 12) * Bg) + 4) * Bg
                                : _sqrt(Bg);

                            const DBb = (Bb <= 0.25)
                                ? (((16 * Bb - 12) * Bb) + 4) * Bb
                                : _sqrt(Bb);

                            Fr = (Sr <= 0.5)
                                ? (Br - (1 - 2 * Sr) * Br * (1 - Br))
                                : (Br + (2 * Sr - 1) * (DBr - Br));

                            Fg = (Sg <= 0.5)
                                ? (Bg - (1 - 2 * Sg) * Bg * (1 - Bg))
                                : (Bg + (2 * Sg - 1) * (DBg - Bg));

                            Fb = (Sb <= 0.5)
                                ? (Bb - (1 - 2 * Sb) * Bb * (1 - Bb))
                                : (Bb + (2 * Sb - 1) * (DBb - Bb));

                            break;
                        }

                        default:
                            Fr = Sr;
                            Fg = Sg;
                            Fb = Sb;
                    }

                    k = As * Ab;
                    oneMinusAs = 1 - As;
                    oneMinusAb = 1 - Ab;

                    R = Sr * oneMinusAb + Br * oneMinusAs + Fr * k;
                    G = Sg * oneMinusAb + Bg * oneMinusAs + Fg * k;
                    B = Sb * oneMinusAb + Bb * oneMinusAs + Fb * k;
                    A = As + Ab - As * Ab;
                }

                outR = (R * 255) | 0;
                outG = (G * 255) | 0;
                outB = (B * 255) | 0;
                outA = (A * 255) | 0;

                o32[iPix] = (outA << 24) | (outB << 16) | (outG << 8) | outR;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [BLUR]: function (requirements) {

        const getBlurPrefixBuffers = function (len, axisKey) {

            const name = `blur-prefix-${axisKey}-${len}`;

            let obj = getWorkstoreItem(name);
            if (obj) return obj;

            const n = (len + 1),
                bytes = n * 4 * 4,
                buf = new ArrayBuffer(bytes);

            const r = new Uint32Array(buf, 0, n),
                g = new Uint32Array(buf, n * 4, n),
                b = new Uint32Array(buf, n * 8, n),
                a = new Uint32Array(buf, n * 12, n);

            obj = { r, g, b, a };

            setWorkstoreItem(name, obj);

            return obj;
        };

        const buildHorizontalBlur = function (gridWidth, gridHeight, radius) {

            if (!_isFinite(radius)) radius = 0;

            const name = `blur-h-${gridWidth}-${gridHeight}-${radius}`,
                itemInWorkstore = getWorkstoreItem(name);

            if (itemInWorkstore) return itemInWorkstore;

            const startX = new Uint16Array(gridWidth * gridHeight);
            const endX = new Uint16Array(gridWidth * gridHeight);

            let x, y, p, sx, ex;

            for (y = 0; y < gridHeight; y++) {

                for (x = 0; x < gridWidth; x++) {

                    p = (y * gridWidth) + x;
                    sx = x - radius;
                    ex = x + radius;

                    if (sx < 0) sx = 0;
                    if (ex >= gridWidth) ex = gridWidth - 1;

                    startX[p] = sx;
                    endX[p] = ex;
                }
            }

            const horizontalRanges = { startX, endX, width: gridWidth, height: gridHeight, kind: 'range-h' };

            setWorkstoreItem(name, horizontalRanges);
            return horizontalRanges;
        };

        const buildVerticalBlur = function (gridWidth, gridHeight, radius) {

            if (!_isFinite(radius)) radius = 0;

            const name = `blur-v-${gridWidth}-${gridHeight}-${radius}`,
                itemInWorkstore = getWorkstoreItem(name);

            if (itemInWorkstore) return itemInWorkstore;

            const startY = new Uint16Array(gridWidth * gridHeight);
            const endY = new Uint16Array(gridWidth * gridHeight);

            let x, y, p, sy, ey;

            for (y = 0; y < gridHeight; y++) {

                for (x = 0; x < gridWidth; x++) {

                    p = (y * gridWidth) + x;
                    sy = y - radius;
                    ey = y + radius;

                    if (sy < 0) sy = 0;
                    if (ey >= gridHeight) ey = gridHeight - 1;

                    startY[p] = sy;
                    endY[p] = ey;
                }
            }

            const verticalRanges = { startY, endY, width: gridWidth, height: gridHeight, kind: 'range-v' };

            setWorkstoreItem(name, verticalRanges);
            return verticalRanges;
        };

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data,
            len = iData.length,
            pixelLen = _floor(len / 4);

        const {
            opacity = 1,
            processVertical = true,
            radiusVertical = 0,
            passesVertical = 1,
            stepVertical = 1,
            processHorizontal = true,
            radiusHorizontal = 0,
            passesHorizontal = 1,
            stepHorizontal = 1,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            includeAlpha = false,
            excludeTransparentPixels = false,
            lineOut,
        } = requirements;

        if ((!processVertical && !processHorizontal) || (!includeRed && !includeGreen && !includeBlue && !includeAlpha)) transferDataUnchanged(oData, iData, len);
        else {

            const gridWidth = input.width,
                gridHeight = input.height;

            let horizontalBlurGrid, verticalBlurGrid;

            if (processHorizontal || processVertical) {

                if (processHorizontal) horizontalBlurGrid = buildHorizontalBlur(gridWidth, gridHeight, radiusHorizontal);

                if (processVertical) verticalBlurGrid = buildVerticalBlur(gridWidth, gridHeight, radiusVertical);
            }

            oData.set(iData);

            const hold = new Uint8ClampedArray(iData);

            let pass, counter, rIdx, gIdx, bIdx, aIdx, startX, endX, width, height, sx, ex, y, rowBase, step4, sumR, sumG, sumB, sumA, countRGB, totalCount, idx, c, aVal, startY, endY, sy, ey, x, stepRow4, pr, pg, pb, pa, base, pos, count;

            const canFastH = (stepHorizontal === 1) && !excludeTransparentPixels,
                canFastV = (stepVertical === 1) && !excludeTransparentPixels;

            if (processHorizontal) {

                for (pass = 0; pass < passesHorizontal; pass++) {

                    if (canFastH) {

                        ({ startX, endX, width, height } = horizontalBlurGrid);
                        ({ r: pr, g: pg, b: pb, a: pa } = getBlurPrefixBuffers(width, 'h'));

                        for (y = 0; y < height; y++) {

                            base = (y * width) << 2;

                            if (includeRed) pr[0] = 0;
                            if (includeGreen) pg[0] = 0;
                            if (includeBlue) pb[0] = 0;
                            if (includeAlpha) pa[0] = 0;

                            for (let x = 0; x < width; x++) {

                                idx = base + (x << 2);

                                if (includeRed) pr[x + 1] = pr[x] + hold[idx];
                                if (includeGreen) pg[x + 1] = pg[x] + hold[idx + 1];
                                if (includeBlue) pb[x + 1] = pb[x] + hold[idx + 2];
                                if (includeAlpha) pa[x + 1] = pa[x] + hold[idx + 3];
                            }

                            for (let x = 0; x < width; x++) {

                                pos = (y * width) + x;
                                sx = startX[pos];
                                ex = endX[pos];
                                count = (ex - sx + 1);
                                idx = base + (x << 2);

                                if (includeRed) oData[idx] = (pr[ex + 1] - pr[sx]) / count;
                                else oData[idx] = hold[idx];

                                if (includeGreen) oData[idx + 1] = (pg[ex + 1] - pg[sx]) / count;
                                else oData[idx + 1] = hold[idx + 1];

                                if (includeBlue) oData[idx + 2] = (pb[ex + 1] - pb[sx]) / count;
                                else oData[idx + 2] = hold[idx + 2];

                                if (includeAlpha) oData[idx + 3] = (pa[ex + 1] - pa[sx]) / count;
                                else oData[idx + 3] = hold[idx + 3];
                            }
                        }
                    }
                    else {

                        for (counter = 0; counter < pixelLen; counter++) {

                            rIdx = counter * 4;
                            gIdx = rIdx + 1;
                            bIdx = gIdx + 1;
                            aIdx = bIdx + 1;

                            if (includeAlpha || hold[aIdx]) {

                                ({ startX, endX, width } = horizontalBlurGrid);

                                sx = startX[counter];
                                ex = endX[counter];
                                y  = (counter / width) | 0;
                                rowBase = (y * width) * 4;

                                step4 = stepHorizontal << 2;

                                sumR = 0;
                                sumG = 0;
                                sumB = 0;
                                sumA = 0;
                                countRGB = 0;

                                totalCount = ((ex - sx) / stepHorizontal | 0) + 1;

                                idx = rowBase + (sx << 2);

                                if (!excludeTransparentPixels) {

                                    for (c = sx; c <= ex; c += stepHorizontal) {

                                        if (includeRed) sumR += hold[idx];
                                        if (includeGreen) sumG += hold[idx + 1];
                                        if (includeBlue) sumB += hold[idx + 2];
                                        if (includeAlpha) sumA += hold[idx + 3];
                                        idx += step4;
                                    }

                                    if (includeRed) oData[rIdx] = sumR / totalCount;
                                    else oData[rIdx] = hold[rIdx];

                                    if (includeGreen) oData[gIdx] = sumG / totalCount;
                                    else oData[gIdx] = hold[gIdx];

                                    if (includeBlue) oData[bIdx] = sumB / totalCount;
                                    else oData[bIdx] = hold[bIdx];

                                    if (includeAlpha) oData[aIdx] = sumA / totalCount;
                                    else oData[aIdx] = hold[aIdx];
                                }
                                else {

                                    for (c = sx; c <= ex; c += stepHorizontal) {

                                        aVal = hold[idx + 3];

                                        if (aVal) {

                                            if (includeRed) sumR += hold[idx];
                                            if (includeGreen) sumG += hold[idx + 1];
                                            if (includeBlue) sumB += hold[idx + 2];
                                            countRGB++;
                                        }

                                        if (includeAlpha) sumA += aVal;

                                        idx += step4;
                                    }

                                    if (includeRed) oData[rIdx] = countRGB ? (sumR / countRGB) : hold[rIdx];
                                    else oData[rIdx] = hold[rIdx];

                                    if (includeGreen) oData[gIdx] = countRGB ? (sumG / countRGB) : hold[gIdx];
                                    else oData[gIdx] = hold[gIdx];

                                    if (includeBlue)  oData[bIdx] = countRGB ? (sumB / countRGB) : hold[bIdx];
                                    else oData[bIdx] = hold[bIdx];

                                    if (includeAlpha) oData[aIdx] = sumA / totalCount;
                                    else oData[aIdx] = hold[aIdx];
                                }
                            }
                        }
                    }
                    if (processVertical || pass < passesHorizontal - 1) hold.set(oData);
                }
            }

            if (processVertical) {

                for (pass = 0; pass < passesVertical; pass++) {

                    if (canFastV) {

                        ({ startY, endY, width, height } = verticalBlurGrid);
                        ({ r: pr, g: pg, b: pb, a: pa } = getBlurPrefixBuffers(height, 'v'));

                        for (x = 0; x < width; x++) {

                            if (includeRed) pr[0] = 0;
                            if (includeGreen) pg[0] = 0;
                            if (includeBlue) pb[0] = 0;
                            if (includeAlpha) pa[0] = 0;

                            for (y = 0; y < height; y++) {

                                idx = (((y * width) + x) << 2);

                                if (includeRed) pr[y + 1] = pr[y] + hold[idx];
                                if (includeGreen) pg[y + 1] = pg[y] + hold[idx + 1];
                                if (includeBlue) pb[y + 1] = pb[y] + hold[idx + 2];
                                if (includeAlpha) pa[y + 1] = pa[y] + hold[idx + 3];
                            }

                            for (y = 0; y < height; y++) {

                                pos = (y * width) + x;
                                sy = startY[pos];
                                ey = endY[pos];
                                count = (ey - sy + 1);
                                idx = (((y * width) + x) << 2);

                                if (includeRed) oData[idx] = (pr[ey + 1] - pr[sy]) / count;
                                else oData[idx] = hold[idx];

                                if (includeGreen) oData[idx + 1] = (pg[ey + 1] - pg[sy]) / count;
                                else oData[idx + 1] = hold[idx + 1];

                                if (includeBlue) oData[idx + 2] = (pb[ey + 1] - pb[sy]) / count;
                                else oData[idx + 2] = hold[idx + 2];

                                if (includeAlpha) oData[idx + 3] = (pa[ey + 1] - pa[sy]) / count;
                                else oData[idx + 3] = hold[idx + 3];
                            }
                        }
                    }
                    else {

                        for (counter = 0; counter < pixelLen; counter++) {

                            rIdx = counter * 4;
                            gIdx = rIdx + 1;
                            bIdx = gIdx + 1;
                            aIdx = bIdx + 1;

                            if (includeAlpha || hold[aIdx]) {

                                ({ startY, endY, width } = verticalBlurGrid);
                                sy = startY[counter];
                                ey = endY[counter];
                                x  = counter % width;

                                stepRow4 = (width * 4 * stepVertical);

                                sumR = 0;
                                sumG = 0;
                                sumB = 0;
                                sumA = 0;
                                countRGB = 0;

                                totalCount = ((ey - sy) / stepVertical | 0) + 1;

                                idx = (sy * width * 4) + (x << 2);

                                if (!excludeTransparentPixels) {

                                    for (let r = sy; r <= ey; r += stepVertical) {

                                        if (includeRed) sumR += hold[idx];
                                        if (includeGreen) sumG += hold[idx + 1];
                                        if (includeBlue) sumB += hold[idx + 2];
                                        if (includeAlpha) sumA += hold[idx + 3];

                                        idx += stepRow4;
                                    }
                                    if (includeRed) oData[rIdx] = sumR / totalCount;
                                    else oData[rIdx] = hold[rIdx];

                                    if (includeGreen) oData[gIdx] = sumG / totalCount;
                                    else oData[gIdx] = hold[gIdx];

                                    if (includeBlue) oData[bIdx] = sumB / totalCount;
                                    else oData[bIdx] = hold[bIdx];

                                    if (includeAlpha) oData[aIdx] = sumA / totalCount;
                                    else oData[aIdx] = hold[aIdx];
                                }
                                else {

                                    for (let r = sy; r <= ey; r += stepVertical) {

                                        aVal = hold[idx + 3];

                                        if (aVal) {

                                            if (includeRed) sumR += hold[idx];
                                            if (includeGreen) sumG += hold[idx + 1];
                                            if (includeBlue) sumB += hold[idx + 2];
                                            countRGB++;
                                        }

                                        if (includeAlpha) sumA += aVal;

                                        idx += stepRow4;
                                    }

                                    if (includeRed) oData[rIdx] = countRGB ? (sumR / countRGB) : hold[rIdx];
                                    else oData[rIdx] = hold[rIdx];

                                    if (includeGreen) oData[gIdx] = countRGB ? (sumG / countRGB) : hold[gIdx];
                                    else oData[gIdx] = hold[gIdx];

                                    if (includeBlue) oData[bIdx] = countRGB ? (sumB / countRGB) : hold[bIdx];
                                    else oData[bIdx] = hold[bIdx];

                                    if (includeAlpha) oData[aIdx] = sumA / totalCount;
                                    else oData[aIdx] = hold[aIdx];
                                }
                            }
                        }
                    }
                    if (pass < passesVertical - 1) hold.set(oData);
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [CHANNELS_TO_ALPHA]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            lineOut,
        } = requirements;

        const incR = includeRed ? 1 : 0,
            incG = includeGreen ? 1 : 0,
            incB = includeBlue ? 1 : 0,
            div  = incR + incG + incB;

        if (div === 0) out32.set(src32);
        else {

            let sumDiv3LUT = null;

            if (div === 3) {

                sumDiv3LUT = getWorkstoreItem('cta::sumDiv3');

                if (!sumDiv3LUT) {

                    sumDiv3LUT = new Uint8Array(766);

                    for (let s = 0; s <= 765; s++) {

                        sumDiv3LUT[s] = Math.floor(s / 3) & 0xFF;
                    }
                    setWorkstoreItem('cta::sumDiv3', sumDiv3LUT);
                }
            }

            let p, pz, s, r, g, b, aNew, sum;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                s = src32[p];

                r = s & 0xFF;
                g = (s >>> 8) & 0xFF;
                b = (s >>> 16) & 0xFF;

                if (div === 1) aNew = incR ? r : (incG ? g : b);
                else if (div === 2) {

                    sum = (incR ? r : 0) + (incG ? g : 0) + (incB ? b : 0);
                    aNew = sum >>> 1;
                }
                else aNew = sumDiv3LUT[r + g + b];

                out32[p] = (s & 0x00FFFFFF) | (aNew << 24);
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [CHROMA]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            ranges = [],
            featherRed = 0,
            featherGreen = 0,
            featherBlue  = 0,
            lineOut,
        } = requirements;

        const clamp8 = v => (v < 0 ? 0 : v > 255 ? 255 : v | 0);

        const posNumOr0 = v => {

            const n = +v;
            return (_isFinite(n) && n >= 0) ? n : 0;
        };

        const normRanges = (() => {

            const res = [];

            let i, iz, r, minR, minG, minB, maxR, maxG, maxB, t;

            for (i = 0, iz = ranges.length; i < iz; i++) {

                r = ranges[i];
                if (!r || r.length < 6) continue;

                [minR, minG, minB, maxR, maxG, maxB] = r;

                if (!(_isFinite(minR) && _isFinite(minG) && _isFinite(minB) && _isFinite(maxR) && _isFinite(maxG) && _isFinite(maxB))) continue;

                minR |= 0;
                minG |= 0;
                minB |= 0;
                maxR |= 0;
                maxG |= 0;
                maxB |= 0;

                if (minR > maxR) {

                    t = minR;
                    minR = maxR;
                    maxR = t;
                }

                if (minG > maxG) {

                    t = minG;
                    minG = maxG;
                    maxG = t;
                }

                if (minB > maxB) {

                    t = minB;
                    minB = maxB;
                    maxB = t;
                }


                res.push([clamp8(minR), clamp8(minG), clamp8(minB), clamp8(maxR), clamp8(maxG), clamp8(maxB)]);
            }
            return res;
        })();

        if (normRanges.length === 0) out32.set(src32);
        else {

            const fR = clamp8(posNumOr0(featherRed)),
                fG = clamp8(posNumOr0(featherGreen)),
                fB = clamp8(posNumOr0(featherBlue));

            const keyBase = JSON.stringify(normRanges),
                bitKey = `chroma-bitset::${keyBase}`,
                fKey = `chroma-feather::${fR}_${fG}_${fB}::${keyBase}`;

            if ((fR | fG | fB) === 0) {

                let pack = getWorkstoreItem(bitKey);

                if (!pack) {

                    const n = normRanges.length | 0,
                        words = (n + 31) >>> 5;

                    const rMasks = Array.from({ length: words }, () => new Uint32Array(256)),
                        gMasks = Array.from({ length: words }, () => new Uint32Array(256)),
                        bMasks = Array.from({ length: words }, () => new Uint32Array(256));

                    let k, w, bit, minR, minG, minB, maxR, maxG, maxB, v;

                    for (k = 0; k < n; k++) {

                        w = k >>> 5;
                        bit = 1 << (k & 31);

                        [minR, minG, minB, maxR, maxG, maxB] = normRanges[k];

                        for (v = minR; v <= maxR; v++) {

                            rMasks[w][v] |= bit;
                        }
                        for (v = minG; v <= maxG; v++) {

                            gMasks[w][v] |= bit;
                        }
                        for (v = minB; v <= maxB; v++) {

                            bMasks[w][v] |= bit;
                        }
                    }

                    pack = { words, rMasks, gMasks, bMasks };
                    setWorkstoreItem(bitKey, pack);
                }

                const { words, rMasks, gMasks, bMasks } = pack;

                let p, pz, rgba, r, g, b, a, hit, w;

                for (p = 0, pz = src32.length | 0; p < pz; p++) {

                    rgba = src32[p];
                    r = rgba & 0xFF;
                    g = (rgba >>> 8) & 0xFF;
                    b = (rgba >>> 16) & 0xFF;
                    a = (rgba >>> 24) & 0xFF;

                    hit = 0;

                    for (w = 0; w < words; w++) {

                        if ((rMasks[w][r] & gMasks[w][g] & bMasks[w][b]) !== 0) {

                            hit = 1; break;
                        }
                    }
                    if (hit) a = 0;

                    out32[p] = ((a << 24) | (b << 16) | (g << 8) | r) >>> 0;
                }
            }

            else {

                let fpack = getWorkstoreItem(fKey);

                if (!fpack) {

                    const n = normRanges.length | 0;

                    const makeLUT = (min, max, F) => {

                        const lut = new Uint8Array(256);

                        if (F <= 0) {

                            for (let v = 0; v < 256; v++) {

                                lut[v] = (v < min || v > max) ? 0 : 255;
                            }
                            return lut;
                        }

                        const lo = _max(0, min - F),
                            hi = _min(255, max + F);

                        let v, w;

                        for (v = 0; v < 256; v++) {

                            if (v < lo || v > hi) w = 0;
                            else if (v < min) w = ((v - (min - F)) * 255 / F) | 0;
                            else if (v > max) w = (((max + F) - v) * 255 / F) | 0;
                            else w = 255;

                            lut[v] = w < 0 ? 0 : (w > 255 ? 255 : w);
                        }
                        return lut;
                    };

                    const rLUTs = new Array(n),
                        gLUTs = new Array(n),
                        bLUTs = new Array(n);

                    let k, minR, minG, minB, maxR, maxG, maxB;

                    for (k = 0; k < n; k++) {

                        [minR, minG, minB, maxR, maxG, maxB] = normRanges[k];

                        rLUTs[k] = makeLUT(minR, maxR, fR);
                        gLUTs[k] = makeLUT(minG, maxG, fG);
                        bLUTs[k] = makeLUT(minB, maxB, fB);
                    }
                    fpack = { rLUTs, gLUTs, bLUTs };
                    setWorkstoreItem(fKey, fpack);
                }

                const { rLUTs, gLUTs, bLUTs } = fpack,
                    nRanges = rLUTs.length | 0;

                let p, pz, rgba, r, g, b, a, wMax, k, w, na;

                for (p = 0, pz = src32.length | 0; p < pz; p++) {

                    rgba = src32[p];

                    r = rgba & 0xFF;
                    g = (rgba >>> 8) & 0xFF;
                    b = (rgba >>> 16) & 0xFF;
                    a = (rgba >>> 24) & 0xFF;

                    wMax = 0;

                    for (k = 0; k < nRanges; k++) {

                        w = _min(rLUTs[k][r], gLUTs[k][g], bLUTs[k][b]);

                        if (w > wMax) {

                            wMax = w;
                            if (wMax === 255) break;
                        }
                    }

                    na = ((a * (255 - wMax) + 128) >> 8) & 0xFF;

                    out32[p] = ((na << 24) | (b << 16) | (g << 8) | r) >>> 0;
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [CLAMP_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            lowRed = 0,
            lowGreen = 0,
            lowBlue = 0,
            highRed = 255,
            highGreen = 255,
            highBlue = 255,
            lineOut,
        } = requirements;

        const c8 = v => (v < 0 ? 0 : v > 255 ? 255 : v | 0);

        const lr = c8(lowRed),
            lg = c8(lowGreen),
            lb = c8(lowBlue),
            hr = c8(highRed),
            hg = c8(highGreen),
            hb = c8(highBlue);

        const idR = (lr === 0 && hr === 255),
            idG = (lg === 0 && hg === 255),
            idB = (lb === 0 && hb === 255);

        if (idR && idG && idB)  out32.set(src32);
        else {

            const keyR = `clampch::R:${lr},${hr}`,
                keyG = `clampch::G:${lg},${hg}`,
                keyB = `clampch::B:${lb},${hb}`;

            let lutR = idR ? null : getWorkstoreItem(keyR),
                lutG = idG ? null : getWorkstoreItem(keyG),
                lutB = idB ? null : getWorkstoreItem(keyB);

            const buildLUT = (lo, hi) => {

                const d = hi - lo,
                    lut = new Uint8ClampedArray(256);

                for (let v = 0; v < 256; v++) {

                    lut[v] = lo + (v * d) / 255;
                }
                return lut;
            };

            if (!idR && !lutR) {

                lutR = buildLUT(lr, hr);
                setWorkstoreItem(keyR, lutR);
            }
            if (!idG && !lutG) {

                lutG = buildLUT(lg, hg);
                setWorkstoreItem(keyG, lutG);
            }
            if (!idB && !lutB) {

                lutB = buildLUT(lb, hb);
                setWorkstoreItem(keyB, lutB);
            }

            let p, pz, s, a, r, g, b, nr, ng, nb;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                s = src32[p];

                r = s & 0xFF;
                g = (s >>> 8) & 0xFF;
                b = (s >>> 16) & 0xFF;
                a = (s >>> 24) & 0xFF;

                if (a === 0) {

                    out32[p] = s;
                    continue;
                }

                nr = idR ? r : lutR[r];
                ng = idG ? g : lutG[g];
                nb = idB ? b : lutB[b];

                out32[p] = ((a << 24) | (nb << 16) | (ng << 8) | nr) >>> 0;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [COLORS_TO_ALPHA]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            red = 0,
            green = 255,
            blue = 0,
            opaqueAt = 1,
            transparentAt = 0,
            lineOut,
        } = requirements;

        const clamp8 = v => (v < 0 ? 0 : v > 255 ? 255 : v | 0);

        const clamp01 = v => {

            const n = +v;
            return _isFinite(n) ? (n < 0 ? 0 : n > 1 ? 1 : n) : 0;
        };

        const R = clamp8(red),
            G = clamp8(green),
            B = clamp8(blue);

        const tAt = clamp01(transparentAt),
            oAt = clamp01(opaqueAt);

        const key = `cta::${R},${G},${B}::${tAt},${oAt}`;

        let pack = getWorkstoreItem(key);

        if (!pack) {

            const diffR = new Uint16Array(256),
                diffG = new Uint16Array(256),
                diffB = new Uint16Array(256);

            for (let v = 0; v < 256; v++) {

                diffR[v] = _abs(v - R);
                diffG[v] = _abs(v - G);
                diffB[v] = _abs(v - B);
            }

            const sumRef = R + G + B,
                maxDiff3 = _max(sumRef, 765 - sumRef);

            const tScaled = (tAt * maxDiff3) | 0,
                oScaled = (oAt * maxDiff3) | 0;

            let rangeScaled = oScaled - tScaled;

            const binaryStep = (rangeScaled <= 0);

            if (binaryStep) rangeScaled = 1;

            pack = { diffR, diffG, diffB, tScaled, oScaled, rangeScaled, binaryStep };

            setWorkstoreItem(key, pack);
        }

        const { diffR, diffG, diffB, tScaled, oScaled, rangeScaled, binaryStep } = pack;

        out32.set(src32);

        let p, pz, rgba, a, r, g, b, sumDiff, na;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            rgba = src32[p];
            a = (rgba >>> 24) & 0xFF;

            if (a === 0) continue;

            r = rgba & 0xFF;
            g = (rgba >>> 8) & 0xFF;
            b = (rgba >>> 16) & 0xFF;

            sumDiff = diffR[r] + diffG[g] + diffB[b];

            if (sumDiff < tScaled) na = 0;
            else if (sumDiff > oScaled) na = 255;
            else if (binaryStep) na = (sumDiff > tScaled) ? 255 : 0;
            else na = (((sumDiff - tScaled) * 255 + (rangeScaled >> 1)) / rangeScaled) | 0;

            if (na < 0) na = 0;
            else if (na > 255) na = 255;

            out32[p] = (out32[p] & 0x00FFFFFF) | (na << 24);
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [COMPOSE]: function (requirements) {

        const [input, output, mix] = getInputAndOutputLines(requirements);

        const {
            opacity = 1,
            compose = SOURCE_OVER,
            offsetX = 0,
            offsetY = 0,
            lineOut,
        } = requirements || {};

        if (!mix) {

            transferDataUnchanged(output.data, input.data, input.data.length);
            return;
        }

        const iWidth  = input.width | 0,
            iHeight = input.height | 0,
            mWidth  = mix.width | 0,
            mHeight = mix.height | 0;

        const iData = input.data,
            mData = mix.data,
            oData = output.data;

        const nPixIn = (iWidth * iHeight) | 0,
            nPixMix = (mWidth * mHeight) | 0;

        const i32 = new Uint32Array(iData.buffer, iData.byteOffset, nPixIn),
            o32 = new Uint32Array(oData.buffer, oData.byteOffset, nPixIn),
            m32 = new Uint32Array(mData.buffer, mData.byteOffset, nPixMix);

        const x0 = (offsetX > 0 ? offsetX : 0) | 0,
            y0 = (offsetY > 0 ? offsetY : 0) | 0,
            x1 = _min(iWidth,  offsetX + mWidth)  | 0,
            y1 = _min(iHeight, offsetY + mHeight) | 0;

        const hasOverlap = (x1 > x0) && (y1 > y0);

        switch (compose) {

            case SOURCE_ONLY:

                o32.set(i32);

                if (lineOut) processResults(output, input, 1 - opacity);
                else processResults(cache.work, output, opacity);

                return;

            case SOURCE_OVER:
            case SOURCE_OUT:
            case DESTINATION_OVER:
            case DESTINATION_ATOP:
            case XOR:

                o32.set(i32);
                break;

            default:
                break;
        }

        if (!hasOverlap || compose === CLEAR) {

            if (lineOut) processResults(output, input, 1 - opacity);
            else processResults(cache.work, output, opacity);
            return;
        }

        const inv255 = 1 / 255;

        const mx0 = (x0 - offsetX) | 0,
            my0 = (y0 - offsetY) | 0;

        const rowIn  = iWidth,
            rowMix = mWidth;

        let y, my, baseIn, baseMix, x, mx,
            srcIndex, dstIndex, srcPacked, dstPacked,
            Sr8, Sg8, Sb8, Sa8, Dr8, Dg8, Db8, Da8,
            As, Ad, Sr, Sg, Sb, Dr, Dg, Db,
            outR, outG, outB, outA, t, t1, t2,
            r8, g8, b8, a8;

        for (y = y0, my = my0; y < y1; y++, my++) {

            baseIn  = y  * rowIn;
            baseMix = my * rowMix;

            for (x = x0, mx = mx0; x < x1; x++, mx++) {

                srcIndex = baseIn + x;
                dstIndex = baseMix + mx;

                srcPacked = i32[srcIndex];
                dstPacked = m32[dstIndex];

                Sr8 = srcPacked & 0xFF;
                Sg8 = (srcPacked >>> 8) & 0xFF;
                Sb8 = (srcPacked >>> 16) & 0xFF;
                Sa8 = (srcPacked >>> 24) & 0xFF;

                Dr8 = dstPacked & 0xFF;
                Dg8 = (dstPacked >>> 8) & 0xFF;
                Db8 = (dstPacked >>> 16) & 0xFF;
                Da8 = (dstPacked >>> 24) & 0xFF;

                As = Sa8 * inv255;
                Ad = Da8 * inv255;

                Sr = Sr8 * inv255;
                Sg = Sg8 * inv255;
                Sb = Sb8 * inv255;

                Dr = Dr8 * inv255;
                Dg = Dg8 * inv255;
                Db = Db8 * inv255;

                switch (compose) {

                    case SOURCE_ATOP: {
                        t1 = As * Ad;
                        outR = Sr * t1 + Dr * Ad * (1 - As);
                        outG = Sg * t1 + Dg * Ad * (1 - As);
                        outB = Sb * t1 + Db * Ad * (1 - As);
                        outA = Ad;
                        break;
                    }

                    case SOURCE_IN: {
                        t = As * Ad;
                        outR = Sr * t;
                        outG = Sg * t;
                        outB = Sb * t;
                        outA = t;
                        break;
                    }

                    case SOURCE_OUT: {
                        t = As * (1 - Ad);
                        outR = Sr * t;
                        outG = Sg * t;
                        outB = Sb * t;
                        outA = t;
                        break;
                    }

                    case DESTINATION_ONLY: {
                        o32[srcIndex] = dstPacked;
                        continue;
                    }

                    case DESTINATION_ATOP: {
                        t1 = As * (1 - Ad);
                        t2 = Ad * As;
                        outR = Sr * t1 + Dr * t2;
                        outG = Sg * t1 + Dg * t2;
                        outB = Sb * t1 + Db * t2;
                        outA = As;
                        break;
                    }

                    case DESTINATION_OVER: {
                        t = As * (1 - Ad);
                        outR = Sr * t + Dr * Ad;
                        outG = Sg * t + Dg * Ad;
                        outB = Sb * t + Db * Ad;
                        outA = Ad + As * (1 - Ad);
                        break;
                    }

                    case DESTINATION_IN: {
                        t = Ad * As;
                        outR = Dr * t;
                        outG = Dg * t;
                        outB = Db * t;
                        outA = t;
                        break;
                    }

                    case DESTINATION_OUT: {
                        t = Ad * (1 - As);
                        outR = Dr * t;
                        outG = Dg * t;
                        outB = Db * t;
                        outA = t;
                        break;
                    }

                    case XOR: {
                        t1 = As * (1 - Ad);
                        t2 = Ad * (1 - As);
                        outR = Sr * t1 + Dr * t2;
                        outG = Sg * t1 + Dg * t2;
                        outB = Sb * t1 + Db * t2;
                        outA = As * (1 - Ad) + Ad * (1 - As);
                        break;
                    }

                    case SOURCE_OVER:
                    default: {
                        t = Ad * (1 - As);
                        outR = Sr * As + Dr * t;
                        outG = Sg * As + Dg * t;
                        outB = Sb * As + Db * t;
                        outA = As + Ad * (1 - As);
                        break;
                    }
                }

                r8 = (outR * 255 + 0.5) | 0;
                g8 = (outG * 255 + 0.5) | 0;
                b8 = (outB * 255 + 0.5) | 0;
                a8 = (outA * 255 + 0.5) | 0;

                o32[srcIndex] = ((a8 & 255) << 24) | ((b8 & 255) << 16) | ((g8 & 255) <<  8) | ( r8 & 255);
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [CORRODE]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data,
            len   = iData.length;

        const width  = input.width  | 0,
            height = input.height | 0;

        const {
            opacity = 1,
            includeRed = false,
            includeGreen = false,
            includeBlue = false,
            includeAlpha = true,
            operation = MEAN,
            lineOut,
        } = requirements;

        let kW = requirements.width;
        if (!_isFinite(kW) || kW < 1) kW = 3;
        kW = _floor(kW);

        let kH = requirements.height;
        if (!_isFinite(kH) || kH < 1) kH = 3;
        kH = _floor(kH);

        let offX = requirements.offsetX;
        if (!_isFinite(offX) || offX < 0) offX = (kW >> 1);
        offX = _floor(offX);

        let offY = requirements.offsetY;
        if (!_isFinite(offY) || offY < 0) offY = (kH >> 1);
        offY = _floor(offY);

        if (kW === 1 && kH === 1 && offX === 0 && offY === 0) transferDataUnchanged(oData, iData, len);
        else {

            const left = offX | 0,
                right = (kW - offX - 1) | 0,
                top = offY | 0,
                bottom = (kH - offY - 1) | 0;

            const x0 = left,
                x1 = (width - right) | 0,
                y0 = top,
                y1 = (height - bottom) | 0;

            const nameQx = `corrode-deque-x-${width}`;
            let Qx = getWorkstoreItem(nameQx);
            if (!Qx) {

                Qx = new Int32Array(width);
                setWorkstoreItem(nameQx, Qx);
            }

            const nameQy = `corrode-deque-y-${height}`;
            let Qy = getWorkstoreItem(nameQy);

            if (!Qy) {

                Qy = new Int32Array(height);
                setWorkstoreItem(nameQy, Qy);
            }

            const midMin = new Uint8ClampedArray(len),
                midMax = (operation === 'lowest') ? null : new Uint8ClampedArray(len);

            const rowScan = (src, rowBase, xs, xe, ch, wantMin) => {

                let m = wantMin ? 255 : 0,
                    v, x;

                const base = rowBase + ch;

                for (x = xs; x <= xe; x++) {

                    v = src[base + (x << 2)];
                    if (wantMin ? (v < m) : (v > m)) m = v;
                }
                return m;
            };

            const colScan = (src, xs, ys, ye, ch, wantMin) => {

                let m = wantMin ? 255 : 0,
                    v, y;

                const base = (xs << 2) + ch,
                    stride = width << 2;

                let idx = (ys * stride) + base;

                for (y = ys; y <= ye; y++) {

                    v = src[idx];
                    if (wantMin ? (v < m) : (v > m)) m = v;
                    idx += stride;
                }
                return m;
            };

            const horizontalPass = (src, dst, ch, wantMin) => {

                const w = width,
                    h = height,
                    fullW = left + right + 1;

                let y, rowBase, x, xs, xe, head, tail, v, qx, qv, leftEdge, center;

                for (y = 0; y < h; y++) {

                    rowBase = (y * w) << 2;

                    for (x = 0; x < x0; x++) {

                        xs = 0;
                        xe = Math.min(w - 1, x + right);
                        dst[rowBase + (x << 2) + ch] = rowScan(src, rowBase, xs, xe, ch, wantMin);
                    }

                    if (x1 > x0) {

                        head = 0;
                        tail = -1;

                        for (x = 0; x < w; x++) {

                            v = src[rowBase + (x << 2) + ch];

                            while (tail >= head) {

                                qx = Qx[tail];
                                qv = src[rowBase + (qx << 2) + ch];

                                if (wantMin ? (v <= qv) : (v >= qv)) tail--;
                                else break;
                            }

                            Qx[++tail] = x;

                            leftEdge = x - fullW + 1;

                            while (head <= tail && Qx[head] < leftEdge) head++;

                            if (x >= fullW - 1) {

                                center = x - right;

                                if (center >= x0 && center < x1) {

                                    qx = Qx[head];
                                    dst[rowBase + (center << 2) + ch] = src[rowBase + (qx << 2) + ch];
                                }
                            }
                        }
                    }

                    for (x = x1; x < w; x++) {

                        xs = _max(0, x - left);
                        xe = w - 1;
                        dst[rowBase + (x << 2) + ch] = rowScan(src, rowBase, xs, xe, ch, wantMin);
                    }
                }
            };

            const verticalPass = (src, dst, ch, wantMin) => {

                const w = width,
                    h = height,
                    fullH = top + bottom + 1,
                    stride = w << 2;

                let x, ys, ye, head, tail, y, idx, v, qv, topEdge, center, qy;

                for (x = 0; x < w; x++) {

                    for (y = 0; y < y0; y++) {

                        ys = 0;
                        ye = _min(h - 1, y + bottom);
                        dst[(y * stride) + (x << 2) + ch] = colScan(src, x, ys, ye, ch, wantMin);
                    }

                    if (y1 > y0) {

                        head = 0;
                        tail = -1;

                        for (y = 0; y < h; y++) {

                            idx = (y * stride) + (x << 2) + ch;
                            v = src[idx];

                            while (tail >= head) {

                                qy = Qy[tail];
                                qv = src[(qy * stride) + (x << 2) + ch];

                                if (wantMin ? (v <= qv) : (v >= qv)) tail--;
                                else break;
                            }

                            Qy[++tail] = y;

                            topEdge = y - fullH + 1;

                            while (head <= tail && Qy[head] < topEdge) head++;

                            if (y >= fullH - 1) {

                                center = y - bottom;

                                if (center >= y0 && center < y1) {

                                    qy = Qy[head];

                                    dst[(center * stride) + (x << 2) + ch] = src[(qy * stride) + (x << 2) + ch];
                                }
                            }
                        }
                    }

                    for (y = y1; y < h; y++) {

                        ys = _max(0, y - top);
                        ye = h - 1;
                        dst[(y * stride) + (x << 2) + ch] = colScan(src, x, ys, ye, ch, wantMin);
                    }
                }
            };

            const doR = !!includeRed,
                doG = !!includeGreen,
                doB = !!includeBlue,
                doA = !!includeAlpha;

            if (doA && !doR && !doG && !doB) {

                oData.set(iData);

                if (operation === 'lowest' || operation === 'mean') horizontalPass(iData, midMin, 3, true);
                if (operation === 'highest' || operation === 'mean') horizontalPass(iData, midMax || midMin, 3, false);

                if (operation === 'lowest') verticalPass(midMin, oData, 3, true);
                else if (operation === 'highest') verticalPass(midMax, oData, 3, false);
                else {

                    const tmpMin = new Uint8ClampedArray(len),
                        tmpMax = new Uint8ClampedArray(len);

                    verticalPass(midMin, tmpMin, 3, true);
                    verticalPass(midMax, tmpMax, 3, false);

                    for (let i = 3; i < len; i += 4) {

                        oData[i] = (tmpMin[i] + tmpMax[i]) >> 1;
                    }
                }
            }
            else {

                oData.set(iData);

                const runForChannel = (ch) => {

                    if (operation === 'lowest') {

                        horizontalPass(iData,  midMin, ch, true);
                        verticalPass(midMin, oData,  ch, true);
                    }
                    else if (operation === 'highest') {

                        horizontalPass(iData,  midMin, ch, false);
                        verticalPass(midMin, oData,  ch, false);
                    }
                    else {

                        const tmpVMin = new Uint8ClampedArray(len),
                            tmpVMax = new Uint8ClampedArray(len);

                        horizontalPass(iData, midMin, ch, true);
                        horizontalPass(iData, midMax, ch, false);
                        verticalPass(midMin, tmpVMin, ch, true);
                        verticalPass(midMax, tmpVMax, ch, false);

                        for (let i = ch; i < len; i += 4) {

                            oData[i] = (tmpVMin[i] + tmpVMax[i]) >> 1;
                        }
                    }
                };

                if (doR) runForChannel(0);
                if (doG) runForChannel(1);
                if (doB) runForChannel(2);
                if (doA) runForChannel(3);
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [DISPLACE]: function (requirements) {

        const [input, output, mix] = getInputAndOutputLines(requirements);

        if (!mix) {

            transferDataUnchanged(output.data, input.data, input.data.length);
            return;
        }

        const { width: iWidth, height: iHeight, data: iData } = input;
        const { data: oData } = output;
        const { width: mWidth, height: mHeight, data: mData } = mix;

        const nPix = (iWidth * iHeight) | 0;

        const i32 = new Uint32Array(iData.buffer, iData.byteOffset, nPix),
            o32 = new Uint32Array(oData.buffer, oData.byteOffset, nPix);

        const {
            opacity = 1,
            channelX = RED,
            channelY = GREEN,
            offsetX = 0,
            offsetY = 0,
            transparentEdges = false,
            useInputAsMask = false,
            lineOut,
        } = requirements || {};

        const strengthX = requirements.strengthX || requirements.scaleX || 1,
            strengthY = requirements.strengthY || requirements.scaleY || 1;

        let offsetForChannelX = 3;
        if (channelX === RED) offsetForChannelX = 0;
        else if (channelX === GREEN) offsetForChannelX = 1;
        else if (channelX === BLUE) offsetForChannelX = 2;

        let offsetForChannelY = 3;
        if (channelY === RED) offsetForChannelY = 0;
        else if (channelY === GREEN) offsetForChannelY = 1;
        else if (channelY === BLUE) offsetForChannelY = 2;

        let p = 0,
            y, iy, my, mRowBase, x, ix, mx,
            destPx, destA, mPos, dispX, dispY, dx, dy,
            srcPx, srcA, dIndex, movedZero, destZero, outPx;

        for (y = 0; y < iHeight; y++) {

            iy = y;
            my = y + offsetY;
            mRowBase = my * mWidth;

            for (x = 0; x < iWidth; x++, p++) {

                ix = x;
                mx = x + offsetX;

                destPx = i32[p];
                destA  = (destPx >>> 24) & 0xFF;

                mPos = -1;

                if (mx >= 0 && mx < mWidth && my >= 0 && my < mHeight) mPos = ((mRowBase + mx) * 4) | 0;

                if (mPos < 0) {

                    o32[p] = destPx;
                    continue;
                }

                dispX = mData[mPos + offsetForChannelX];
                dispY = mData[mPos + offsetForChannelY];

                dx = _floor(ix + ((127 - dispX) / 127) * strengthX);
                dy = _floor(iy + ((127 - dispY) / 127) * strengthY);

                dIndex = -1;

                if (!transparentEdges) {

                    if (dx < 0) dx = 0;
                    else if (dx >= iWidth) dx = iWidth - 1;

                    if (dy < 0) dy = 0;
                    else if (dy >= iHeight) dy = iHeight - 1;

                    dIndex = (dy * iWidth + dx) | 0;
                    srcPx  = i32[dIndex];
                    srcA   = (srcPx >>> 24) & 0xFF;
                }
                else {

                    if (dx >= 0 && dx < iWidth && dy >= 0 && dy < iHeight) {

                        dIndex = (dy * iWidth + dx) | 0;
                        srcPx  = i32[dIndex];
                        srcA   = (srcPx >>> 24) & 0xFF;
                    }
                    else {

                        srcPx = 0;
                        srcA  = 0;
                        dIndex = -1;
                    }
                }

                if (!useInputAsMask) {

                    if (transparentEdges && dIndex < 0) o32[p] = 0;
                    else o32[p] = srcPx;
                    continue;
                }

                movedZero = (srcA === 0);
                destZero = (destA === 0);

                outPx = destPx;

                if (!movedZero && !destZero) outPx = srcPx;
                else if (movedZero && !destZero && transparentEdges) outPx = 0;

                o32[p] = outPx;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [EMBOSS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
              oData = output.data,
              W = input.width  | 0,
              H = input.height | 0,
              rowStride = W << 2;

        const {
            opacity = 1,
            tolerance = 0,
            keepOnlyChangedAreas = false,
            postProcessResults = false,
            lineOut,
        } = requirements;

        const strength = _abs(requirements.strength || 1),
            angle = correctAngle(requirements.angle || 0),
            slices  = (angle / 45) | 0,
            remains = ((angle % 45) / 45) * strength;

        const w = new Float32Array(9);

        w[4] = 1;

        if (slices === 0) {

            w[5] = strength - remains;
            w[8] = remains;
            w[3] = -w[5];
            w[0] = -w[8];
        }
        else if (slices === 1) {

            w[8] = strength - remains;
            w[7] = remains;
            w[0] = -w[8];
            w[1] = -w[7];
        }
        else if (slices === 2) {

            w[7] = strength - remains;
            w[6] = remains;
            w[1] = -w[7];
            w[2] = -w[6];
        }
        else if (slices === 3) {
            w[6] = strength - remains;
            w[3] = remains;
            w[2] = -w[6];
            w[5] = -w[3];
        }
        else if (slices === 4) {
            w[3] = strength - remains;
            w[0] = remains;
            w[5] = -w[3];
            w[8] = -w[0];
        }
        else if (slices === 5) {
            w[0] = strength - remains;
            w[1] = remains;
            w[8] = -w[0];
            w[7] = -w[1];
        }
        else if (slices === 6) {
            w[1] = strength - remains;
            w[2] = remains;
            w[7] = -w[1];
            w[6] = -w[2];
        }
        else {
            w[2] = strength - remains;
            w[5] = remains;
            w[6] = -w[2];
            w[3] = -w[5];
        }

        let x, y, yU, yD, rowU, rowM, rowD, xL, xC, xR,
            p00, p01, p02, p10, p11, p12, p20, p21, p22,
            r, g, b, iR, iG, iB, unchanged;

        for (y = 0; y < H; y++) {

            yU = (y === 0 ? H - 1 : y - 1);
            yD = (y === H - 1 ? 0 : y + 1);

            rowU = (yU * rowStride) | 0;
            rowM = (y * rowStride) | 0;
            rowD = (yD * rowStride) | 0;

            for (x = 0; x < W; x++) {

                xL = (x === 0 ? W - 1 : x - 1) << 2;
                xC = (x << 2);
                xR = (x === W - 1 ? 0 : x + 1) << 2;

                p00 = rowU + xL;
                p01 = rowU + xC;
                p02 = rowU + xR;
                p10 = rowM + xL;
                p11 = rowM + xC;
                p12 = rowM + xR;
                p20 = rowD + xL;
                p21 = rowD + xC;
                p22 = rowD + xR;

                if (!iData[p11 + 3]) continue;

                r = iData[p00] * w[0] + iData[p01] * w[1] + iData[p02] * w[2] +
                    iData[p10] * w[3] + iData[p11] * w[4] + iData[p12] * w[5] +
                    iData[p20] * w[6] + iData[p21] * w[7] + iData[p22] * w[8];

                g = iData[p00 + 1] * w[0] + iData[p01 + 1] * w[1] + iData[p02 + 1] * w[2] +
                    iData[p10 + 1] * w[3] + iData[p11 + 1] * w[4] + iData[p12 + 1] * w[5] +
                    iData[p20 + 1] * w[6] + iData[p21 + 1] * w[7] + iData[p22 + 1] * w[8];

                b = iData[p00 + 2] * w[0] + iData[p01 + 2] * w[1] + iData[p02 + 2] * w[2] +
                    iData[p10 + 2] * w[3] + iData[p11 + 2] * w[4] + iData[p12 + 2] * w[5] +
                    iData[p20 + 2] * w[6] + iData[p21 + 2] * w[7] + iData[p22 + 2] * w[8];

                oData[p11] = r;
                oData[p11 + 1] = g;
                oData[p11 + 2] = b;
                oData[p11 + 3] = iData[p11 + 3];

                if (postProcessResults) {

                    iR = iData[p11];
                    iG = iData[p11 + 1];
                    iB = iData[p11 + 2];

                    unchanged =
                        (r >= iR - tolerance && r <= iR + tolerance) &&
                        (g >= iG - tolerance && g <= iG + tolerance) &&
                        (b >= iB - tolerance && b <= iB + tolerance);

                    if (unchanged) {

                        if (keepOnlyChangedAreas) oData[p11 + 3] = 0;
                        else {

                            oData[p11] = 127;
                            oData[p11 + 1] = 127;
                            oData[p11 + 2] = 127;
                        }
                    }
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [FLOOD]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            red = 0,
            green = 0,
            blue = 0,
            alpha = 255,
            excludeAlpha = false,
            lineOut,
        } = requirements;

        const clamp8 = v => (v < 0 ? 0 : v > 255 ? 255 : v | 0);

        const R = clamp8(red),
            G = clamp8(green),
            B = clamp8(blue),
            A = clamp8(alpha);

        const baseRGB = (B << 16) | (G << 8) | R,
            packedWithA = ((A << 24) | baseRGB) >>> 0;

        let p, pz, s, a;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            s = src32[p];
            a = (s >>> 24) & 0xFF;

            if (a === 0) out32[p] = s;
            else out32[p] = excludeAlpha ? (((a << 24) | baseRGB) >>> 0) : packedWithA;
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [GAUSSIAN_BLUR]: function (requirements) {

        const WS_KEY = 'gaussian-blur::workspace';
        const getWorkspace = (pixelCount, maxSide4, expandedPixelCount = 0, expandedMaxSide4 = 0) => {

            let ws = getWorkstoreItem(WS_KEY);
            if (!ws) ws = {};

            if (!ws.bufA32 || ws.bufA32.length !== pixelCount) ws.bufA32 = new Uint32Array(pixelCount);
            if (!ws.bufB32 || ws.bufB32.length !== pixelCount) ws.bufB32 = new Uint32Array(pixelCount);

            if (expandedPixelCount) {

                if (!ws.expA32 || ws.expA32.length !== expandedPixelCount) ws.expA32 = new Uint32Array(expandedPixelCount);
                if (!ws.expB32 || ws.expB32.length !== expandedPixelCount) ws.expB32 = new Uint32Array(expandedPixelCount);
                if (!ws.expOut32 || ws.expOut32.length !== pixelCount) ws.expOut32 = new Uint32Array(pixelCount);
            }

            const lineLength = _max(maxSide4, expandedMaxSide4);

            if (!ws.tmpLineF32 || ws.tmpLineF32.length < lineLength) ws.tmpLineF32 = new Float32Array(lineLength);

            setWorkstoreItem(WS_KEY, ws);
            return ws;
        };

        const COEFFS_KEY = 'gaussian-blur::coeffs';
        const getCoeffCache = () => {

            let m = getWorkstoreItem(COEFFS_KEY);
            if (!m) {

                m = new Map();
                setWorkstoreItem(COEFFS_KEY, m);
            }
            return m;
        };

        const gaussCoefRaw = (sigmaIn) => {

            let sigma = sigmaIn;
            if (sigma < 0.5) sigma = 0.5;

            const a = _exp(0.726 * 0.726) / sigma,
                g1 = _exp(-a),
                g2 = _exp(-2 * a),
                a0 = (1 - g1) * (1 - g1) / (1 + 2 * a * g1 - g2),
                a1 = a0 * (a - 1) * g1,
                a2 = a0 * (a + 1) * g1,
                a3 = -a0 * g2,
                b1 = 2 * g1,
                b2 = -g2,
                left_corner  = (a0 + a1) / (1 - b1 - b2),
                right_corner = (a2 + a3) / (1 - b1 - b2);

            return new Float32Array([a0, a1, a2, a3, b1, b2, left_corner, right_corner]);
        };

        const getCoeffs = (sigma) => {

            const s = (sigma > 0 ? sigma : 0) || 0,
                key = s < 0.5 ? 0.5 : Math.round(s * 1024) / 1024;

            const cache = getCoeffCache();

            let c = cache.get(key);

            if (!c) {

                c = gaussCoefRaw(key);
                cache.set(key, c);
            }
            return c;
        };

        const premultiply_u32 = (buf32, count) => {

            let i, px, r, g, b, a, f;

            for (i = 0; i < count; i++) {

                px = buf32[i];

                a  = (px >>> 24) & 0xFF;

                if (a === 0 || a === 255) continue;

                f = a / 255;

                r = ((px) & 0xFF);
                g = ((px >>> 8) & 0xFF);
                b = ((px >>> 16) & 0xFF);

                r = (r * f + 0.5) | 0;
                g = (g * f + 0.5) | 0;
                b = (b * f + 0.5) | 0;

                buf32[i] = (px & 0xFF000000) | (b << 16) | (g << 8) | r;
            }
        };

        const unpremultiply_u32 = (buf32, count) => {

            let i, px, r, g, b, a, f;

            for (i = 0; i < count; i++) {

                px = buf32[i];

                a  = (px >>> 24) & 0xFF;

                if (a === 0 || a === 255) continue;

                f = 255 / a;

                r = ((px) & 0xFF);
                g = ((px >>> 8) & 0xFF);
                b = ((px >>> 16) & 0xFF);

                r = _min(255, (r * f + 0.5) | 0);
                g = _min(255, (g * f + 0.5) | 0);
                b = _min(255, (b * f + 0.5) | 0);

                buf32[i] = (px & 0xFF000000) | (b << 16) | (g << 8) | r;
            }
        };

        const bilinearResult = [0, 0, 0, 0];
        const sampleRGBA_bilinear_u32 = (src32, width, height, xf, yf) => {

            if (xf < 0) xf = 0;
            else if (xf > width  - 1) xf = width  - 1;

            if (yf < 0) yf = 0;
            else if (yf > height - 1) yf = height - 1;

            const x0 = xf | 0,
                y0 = yf | 0,
                x1 = x0 + 1 < width ? x0 + 1 : x0,
                y1 = y0 + 1 < height ? y0 + 1 : y0;

            const fx = xf - x0,
                fy = yf - y0;

            const w00 = (1 - fx) * (1 - fy),
                w10 = (fx) * (1 - fy),
                w01 = (1 - fx) * (fy),
                w11 = (fx) * (fy);

            const i00 = y0 * width + x0,
                i10 = y0 * width + x1,
                i01 = y1 * width + x0,
                i11 = y1 * width + x1;

            const p00 = src32[i00],
                p10 = src32[i10],
                p01 = src32[i01],
                p11 = src32[i11];

            const r00 = p00 & 0xFF,
                g00 = (p00 >>> 8) & 0xFF,
                b00 = (p00 >>> 16) & 0xFF,
                a00 = (p00 >>> 24) & 0xFF;

            const r10 = p10 & 0xFF,
                g10 = (p10 >>> 8) & 0xFF,
                b10 = (p10 >>> 16) & 0xFF,
                a10 = (p10 >>> 24) & 0xFF;

            const r01 = p01 & 0xFF,
                g01 = (p01 >>> 8) & 0xFF,
                b01 = (p01 >>> 16) & 0xFF,
                a01 = (p01 >>> 24) & 0xFF;

            const r11 = p11 & 0xFF,
                g11 = (p11 >>> 8) & 0xFF,
                b11 = (p11 >>> 16) & 0xFF,
                a11 = (p11 >>> 24) & 0xFF;

            bilinearResult[0] = r00 * w00 + r10 * w10 + r01 * w01 + r11 * w11;
            bilinearResult[1] = g00 * w00 + g10 * w10 + g01 * w01 + g11 * w11;
            bilinearResult[2] = b00 * w00 + b10 * w10 + b01 * w01 + b11 * w11;
            bilinearResult[3] = a00 * w00 + a10 * w10 + a01 * w01 + a11 * w11;

            return bilinearResult;
        };

        const pack4 = (r, g, b, a) => {

            r = r < 0 ? 0 : r > 255 ? 255 : r | 0;
            g = g < 0 ? 0 : g > 255 ? 255 : g | 0;
            b = b < 0 ? 0 : b > 255 ? 255 : b | 0;
            a = a < 0 ? 0 : a > 255 ? 255 : a | 0;

            return (a << 24) | (b << 16) | (g << 8) | r;
        };

        const rotateIntoAngleFrame = (src32, dst32, width, height, theta) => {

            const c = _cos(theta),
                s = _sin(theta),
                cx = (width - 1) * 0.5,
                cy = (height - 1) * 0.5;

            let v, dv, u, du, x, y, r, g, b, a;

            for (v = 0; v < height; v++) {

                dv = v - cy;

                for (u = 0; u < width; u++) {

                    du = u - cx;

                    x =  du * c - dv * s + cx;
                    y =  du * s + dv * c + cy;

                    [r,g,b,a] = sampleRGBA_bilinear_u32(src32, width, height, x, y);

                    dst32[v * width + u] = pack4(r, g, b, a);
                }
            }
        };

        const rotateBackToImageFrame = (src32, dst32, width, height, theta) => {

            const c = _cos(theta),
                s = _sin(theta),
                cx = (width - 1) * 0.5,
                cy = (height - 1) * 0.5;

            let y, dy, x, dx, u, v, r, g, b, a;

            for (y = 0; y < height; y++) {

                dy = y - cy;

                for (x = 0; x < width; x++) {

                    dx = x - cx;

                    u =  dx * c + dy * s + cx;
                    v = -dx * s + dy * c + cy;

                    [r,g,b,a] = sampleRGBA_bilinear_u32(src32, width, height, u, v);

                    dst32[y * width + x] = pack4(r, g, b, a);
                }
            }
        };

        const getExpandedBlurBounds = (width, height, theta, radiusHorizontal, radiusVertical) => {

            const c = _abs(_cos(theta)),
                s = _abs(_sin(theta));

            const rotatedWidth = Math.ceil(width * c + height * s),
                rotatedHeight = Math.ceil(width * s + height * c);

            const pad = Math.ceil(_max(radiusHorizontal, radiusVertical) * 3);

            return {
                width: rotatedWidth + pad * 2,
                height: rotatedHeight + pad * 2,
            };
        };

        const rotateIntoExpandedAngleFrame = (src32, dst32, width, height, expWidth, expHeight, theta) => {

            const c = _cos(theta),
                s = _sin(theta),
                cx = (width - 1) * 0.5,
                cy = (height - 1) * 0.5,
                ecx = (expWidth - 1) * 0.5,
                ecy = (expHeight - 1) * 0.5;

            let v, dv, u, du, x, y, r, g, b, a;

            for (v = 0; v < expHeight; v++) {

                dv = v - ecy;

                for (u = 0; u < expWidth; u++) {

                    du = u - ecx;

                    x = du * c - dv * s + cx;
                    y = du * s + dv * c + cy;

                    [r, g, b, a] = sampleRGBA_bilinear_u32(src32, width, height, x, y);

                    dst32[v * expWidth + u] = pack4(r, g, b, a);
                }
            }
        };

        const rotateBackFromExpandedAngleFrame = (src32, dst32, width, height, expWidth, expHeight, theta) => {

            const c = _cos(theta),
                s = _sin(theta),
                cx = (width - 1) * 0.5,
                cy = (height - 1) * 0.5,
                ecx = (expWidth - 1) * 0.5,
                ecy = (expHeight - 1) * 0.5;

            let y, dy, x, dx, u, v, r, g, b, a;

            for (y = 0; y < height; y++) {

                dy = y - cy;

                for (x = 0; x < width; x++) {

                    dx = x - cx;

                    u = dx * c + dy * s + ecx;
                    v = -dx * s + dy * c + ecy;

                    [r, g, b, a] = sampleRGBA_bilinear_u32(src32, expWidth, expHeight, u, v);

                    dst32[y * width + x] = pack4(r, g, b, a);
                }
            }
        };

        const transpose_u32 = (src32, dst32, width, height) => {

            let y, baseY, x;

            for (y = 0; y < height; y++) {

                baseY = y * width;
                for (x = 0; x < width; x++) {

                    dst32[baseY + x] = src32[x * height + y];
                }
            }
        };

        const runRotatedPath = (angleR) => {

            rotateIntoAngleFrame(src32, bufA32, width, height, angleR);

            if (doH && doV) {

                convolveRGBA(bufA32, bufB32, tmpLineF32, hCoeff, width, height);
                convolveRGBA(bufB32, bufA32, tmpLineF32, vCoeff, height, width);
            }
            else if (doH && !doV) {

                convolveRGBA(bufA32, bufB32, tmpLineF32, hCoeff, width, height);
                transpose_u32(bufB32, bufA32, width, height);
            }
            else if (!doH && doV) {

                transpose_u32(bufA32, bufB32, width, height);
                convolveRGBA(bufB32, bufA32, tmpLineF32, vCoeff, height, width);
            }
            else bufA32.set(bufA32);

            rotateBackToImageFrame(bufA32, bufB32, width, height, angleR);
            return bufB32;
        };


        const runExpandedRotatedPath = (angleR, expWidth, expHeight) => {

            rotateIntoExpandedAngleFrame(src32, expA32, width, height, expWidth, expHeight, angleR);

            if (doH && doV) {

                convolveRGBA(expA32, expB32, tmpLineF32, hCoeff, expWidth, expHeight);
                convolveRGBA(expB32, expA32, tmpLineF32, vCoeff, expHeight, expWidth);
            }
            else if (doH && !doV) {

                convolveRGBA(expA32, expB32, tmpLineF32, hCoeff, expWidth, expHeight);
                transpose_u32(expB32, expA32, expWidth, expHeight);
            }
            else if (!doH && doV) {

                transpose_u32(expA32, expB32, expWidth, expHeight);
                convolveRGBA(expB32, expA32, tmpLineF32, vCoeff, expHeight, expWidth);
            }
            else expA32.set(expA32);

            rotateBackFromExpandedAngleFrame(expA32, expOut32, width, height, expWidth, expHeight, angleR);

            return expOut32;
        };

        const convolveRGBA = (src, out, line, coeff, width, height) => {

            const sat8 = (x) => x < 0 ? 0 : (x > 255 ? 255 : x);

            const c_a0L = coeff[0],
                c_a1L = coeff[1],
                c_a0R = coeff[2],
                c_a1R = coeff[3],
                c_b1  = coeff[4],
                c_b2  = coeff[5],
                c_lc  = coeff[6],
                c_rc  = coeff[7];

            let i, j,
                src_index, out_index, line_index, rgba,
                prev_src_r, prev_src_g, prev_src_b, prev_src_a,
                prev_prev_out_r, prev_prev_out_g, prev_prev_out_b, prev_prev_out_a,
                prev_out_r, prev_out_g, prev_out_b, prev_out_a,
                curr_src_r, curr_src_g, curr_src_b, curr_src_a,
                curr_out_r, curr_out_g, curr_out_b, curr_out_a,
                pr, pg, pb, pa;

            for (i = 0; i < height; i++) {

                src_index = i * width;
                out_index = i;
                line_index = 0;

                rgba = src[src_index];

                prev_src_r = rgba & 0xff;
                prev_src_g = (rgba >>> 8) & 0xff;
                prev_src_b = (rgba >>> 16) & 0xff;
                prev_src_a = (rgba >>> 24) & 0xff;

                prev_prev_out_r = prev_src_r * c_lc;
                prev_prev_out_g = prev_src_g * c_lc;
                prev_prev_out_b = prev_src_b * c_lc;
                prev_prev_out_a = prev_src_a * c_lc;

                prev_out_r = prev_prev_out_r;
                prev_out_g = prev_prev_out_g;
                prev_out_b = prev_prev_out_b;
                prev_out_a = prev_prev_out_a;

                for (j = 0; j < width; j++) {

                    rgba = src[src_index];

                    curr_src_r = rgba & 0xff;
                    curr_src_g = (rgba >>> 8) & 0xff;
                    curr_src_b = (rgba >>> 16) & 0xff;
                    curr_src_a = (rgba >>> 24) & 0xff;

                    curr_out_r = curr_src_r * c_a0L + prev_src_r * c_a1L + prev_out_r * c_b1 + prev_prev_out_r * c_b2;
                    curr_out_g = curr_src_g * c_a0L + prev_src_g * c_a1L + prev_out_g * c_b1 + prev_prev_out_g * c_b2;
                    curr_out_b = curr_src_b * c_a0L + prev_src_b * c_a1L + prev_out_b * c_b1 + prev_prev_out_b * c_b2;
                    curr_out_a = curr_src_a * c_a0L + prev_src_a * c_a1L + prev_out_a * c_b1 + prev_prev_out_a * c_b2;

                    prev_prev_out_r = prev_out_r;
                    prev_out_r = curr_out_r;
                    prev_src_r = curr_src_r;

                    prev_prev_out_g = prev_out_g;
                    prev_out_g = curr_out_g;
                    prev_src_g = curr_src_g;

                    prev_prev_out_b = prev_out_b;
                    prev_out_b = curr_out_b;
                    prev_src_b = curr_src_b;

                    prev_prev_out_a = prev_out_a;
                    prev_out_a = curr_out_a;
                    prev_src_a = curr_src_a;

                    line[line_index] = prev_out_r;
                    line[line_index + 1] = prev_out_g;
                    line[line_index + 2] = prev_out_b;
                    line[line_index + 3] = prev_out_a;

                    line_index += 4;
                    src_index++;
                }

                src_index--;
                line_index -= 4;
                out_index += height * (width - 1);

                rgba = src[src_index];

                prev_src_r = rgba & 0xff;
                prev_src_g = (rgba >>> 8) & 0xff;
                prev_src_b = (rgba >>> 16) & 0xff;
                prev_src_a = (rgba >>> 24) & 0xff;

                prev_prev_out_r = prev_src_r * c_rc;
                prev_prev_out_g = prev_src_g * c_rc;
                prev_prev_out_b = prev_src_b * c_rc;
                prev_prev_out_a = prev_src_a * c_rc;

                prev_out_r = prev_prev_out_r;
                prev_out_g = prev_prev_out_g;
                prev_out_b = prev_prev_out_b;
                prev_out_a = prev_prev_out_a;

                curr_src_r = prev_src_r;
                curr_src_g = prev_src_g;
                curr_src_b = prev_src_b;
                curr_src_a = prev_src_a;

                for (j = width - 1; j >= 0; j--) {

                    curr_out_r = curr_src_r * c_a0R + prev_src_r * c_a1R + prev_out_r * c_b1 + prev_prev_out_r * c_b2;
                    curr_out_g = curr_src_g * c_a0R + prev_src_g * c_a1R + prev_out_g * c_b1 + prev_prev_out_g * c_b2;
                    curr_out_b = curr_src_b * c_a0R + prev_src_b * c_a1R + prev_out_b * c_b1 + prev_prev_out_b * c_b2;
                    curr_out_a = curr_src_a * c_a0R + prev_src_a * c_a1R + prev_out_a * c_b1 + prev_prev_out_a * c_b2;

                    prev_prev_out_r = prev_out_r;
                    prev_out_r = curr_out_r;
                    prev_src_r = curr_src_r;

                    prev_prev_out_g = prev_out_g;
                    prev_out_g = curr_out_g;
                    prev_src_g = curr_src_g;

                    prev_prev_out_b = prev_out_b;
                    prev_out_b = curr_out_b;
                    prev_src_b = curr_src_b;

                    prev_prev_out_a = prev_out_a;
                    prev_out_a = curr_out_a;
                    prev_src_a = curr_src_a;

                    rgba = src[src_index];

                    curr_src_r = rgba & 0xff;
                    curr_src_g = (rgba >>> 8) & 0xff;
                    curr_src_b = (rgba >>> 16) & 0xff;
                    curr_src_a = (rgba >>> 24) & 0xff;

                    pr = sat8((line[line_index] + prev_out_r) | 0);
                    pg = sat8((line[line_index + 1] + prev_out_g) | 0);
                    pb = sat8((line[line_index + 2] + prev_out_b) | 0);
                    pa = sat8((line[line_index + 3] + prev_out_a) | 0);

                    out[out_index] = pr | (pg << 8) | (pb << 16) | (pa << 24);

                    src_index--;
                    line_index -= 4;
                    out_index -= height;
                }
            }
        };

        const near = (t) => _abs(_sin(t)) < 1e-6 || _abs(_cos(t)) < 1e-6;

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const { width, height } = input;

        const {
            opacity = 1,
            radiusHorizontal = 1,
            radiusVertical = 1,
            angle = 0,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            includeAlpha = true,
            excludeTransparentPixels = false,
            premultiply = false,
            lineOut,
        } = requirements;

        const angleRad = angle * _radian;

        const pixels = (iData.length >>> 2),
            maxSide4 = _max(width, height) * 4;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, pixels),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  pixels);

        const RM = includeRed   ? 0x000000FF : 0,
            GM = includeGreen ? 0x0000FF00 : 0,
            BM = includeBlue  ? 0x00FF0000 : 0,
            AM = includeAlpha ? 0xFF000000 : 0;

        const CHMASK = (RM | GM | BM | AM) >>> 0;

        if ((radiusHorizontal <= 0) && (radiusVertical <= 0)) {

            if (CHMASK === 0xFFFFFFFF && !excludeTransparentPixels) out32.set(src32);
            else if (!excludeTransparentPixels) {

                let s, p;

                for (p = 0; p < pixels; p++) {

                    s = src32[p];
                    out32[p] = (s & CHMASK) | (s & ~CHMASK);
                }
            }
            else {

                let s, p;

                for (p = 0; p < pixels; p++) {

                    s = src32[p];

                    if ((s >>> 24) === 0) out32[p] = s;
                    else out32[p] = (s & CHMASK) | (s & ~CHMASK);
                }
            }
            if (lineOut) processResults(output, input, 1 - opacity);
            else processResults(cache.work, output, opacity);

            return;
        }

        const k = _round(angleRad / _piHalf),
            snapped = k * _piHalf,
            useExpandedPath = !near(angleRad);

        const expandedBounds = useExpandedPath ?
            getExpandedBlurBounds(width, height, angleRad, radiusHorizontal, radiusVertical) :
            null;

        const expandedPixels = expandedBounds ? expandedBounds.width * expandedBounds.height : 0,
            expandedMaxSide4 = expandedBounds ? _max(expandedBounds.width, expandedBounds.height) * 4 : 0;

        const {
            bufA32,
            bufB32,
            expA32,
            expB32,
            expOut32,
            tmpLineF32,
        } = getWorkspace(pixels, maxSide4, expandedPixels, expandedMaxSide4);

        const doH = radiusHorizontal > 0,
            doV = radiusVertical > 0;

        const hCoeff = doH ? getCoeffs(radiusHorizontal) : null,
            vCoeff = doV ? getCoeffs(radiusVertical) : null;

        if (premultiply) premultiply_u32(src32, pixels);

        let blurred32;

        if (!useExpandedPath) blurred32 = runRotatedPath(snapped);
        else blurred32 = runExpandedRotatedPath(angleRad, expandedBounds.width, expandedBounds.height);

        if (premultiply) unpremultiply_u32(blurred32, pixels);

        if (CHMASK === 0xFFFFFFFF && !excludeTransparentPixels) out32.set(blurred32);
        else if (!excludeTransparentPixels) {

            let p, s, b;

            for (p = 0; p < pixels; p++) {

                s = src32[p];
                b = blurred32[p];

                out32[p] = (b & CHMASK) | (s & ~CHMASK);
            }
        }
        else {

            let p, s, b;

            for (p = 0; p < pixels; p++) {

                s = src32[p];

                if ((s >>> 24) === 0) {

                    out32[p] = s;
                    continue;
                }

                b = blurred32[p];
                out32[p] = (b & CHMASK) | (s & ~CHMASK);
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [GLITCH]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData  = input.data,
            oData  = output.data,
            iWidth = input.width,
            iHeight = input.height;

        const nPix = (iWidth * iHeight) | 0;

        const i32 = new Uint32Array(iData.buffer, iData.byteOffset, nPix),
            o32 = new Uint32Array(oData.buffer, oData.byteOffset, nPix);

        const {
            opacity = 1,
            useMixedChannel = true,
            seed = DEFAULT_SEED,
            level = 0,
            offsetMin = 0,
            offsetMax = 0,
            offsetRedMin = 0,
            offsetRedMax = 0,
            offsetGreenMin = 0,
            offsetGreenMax = 0,
            offsetBlueMin = 0,
            offsetBlueMax = 0,
            offsetAlphaMin = 0,
            offsetAlphaMax = 0,
            transparentEdges = false,
            useInputAsMask = false,
            lineOut,
        } = requirements || {};

        let step = _floor(requirements.step);
        if (step < 1) step = 1;

        const rnd = getRandomNumbers({
            seed,
            length: iHeight * 5,
        });

        const range = offsetMax - offsetMin,
            redRange = offsetRedMax - offsetRedMin,
            greenRange = offsetGreenMax - offsetGreenMin,
            blueRange = offsetBlueMax - offsetBlueMin,
            alphaRange = offsetAlphaMax - offsetAlphaMin;

        let rndCursor = -1;

        const rows = [];

        let i, j, affectedRow, shift, shiftR, shiftG, shiftB, shiftA;

        for (i = 0; i < iHeight; i += step) {

            affectedRow = (rnd[++rndCursor] < level);

            if (affectedRow) {

                if (useMixedChannel) {

                    shift = (offsetMin + _floor(rnd[++rndCursor] * range)) * 4;

                    for (j = 0; j < step; j++) {

                        rows.push(shift, shift, shift, shift);
                    }
                }
                else {

                    shiftR = (offsetRedMin + _floor(rnd[++rndCursor] * redRange)) * 4;
                    shiftG = (offsetGreenMin + _floor(rnd[++rndCursor] * greenRange)) * 4;
                    shiftB = (offsetBlueMin + _floor(rnd[++rndCursor] * blueRange)) * 4;
                    shiftA = (offsetAlphaMin + _floor(rnd[++rndCursor] * alphaRange)) * 4;

                    for (j = 0; j < step; j++) {

                        rows.push(shiftR, shiftG, shiftB, shiftA);
                    }
                }
            }
            else {

                for (j = 0; j < step; j++) {

                    rows.push(0, 0, 0, 0);
                }
            }
        }

        const rowStrideBytes = (iWidth << 2);
        let p = 0;

        let y, x, rowStart, rowEnd, baseByte, cursor,
            dr, dg, db, da,
            ur, ug, ub, ua,
            srcR, srcG, srcB, srcA,
            destPx, destR, destG, destB, destA,
            movedZero, destZero,
            outR, outG, outB, outA,
            outOfRow;

        for (y = 0; y < iHeight; y++) {

            rowStart = y * rowStrideBytes;
            rowEnd   = rowStart + rowStrideBytes;

            cursor = (y << 2);
            dr = rows[cursor];
            dg = rows[cursor + 1];
            db = rows[cursor + 2];
            da = rows[cursor + 3];

            for (x = 0; x < iWidth; x++, p++) {

                baseByte = rowStart + (x << 2);

                destPx = i32[p];
                destR =  destPx & 0xFF;
                destG = (destPx >>> 8) & 0xFF;
                destB = (destPx >>> 16) & 0xFF;
                destA = (destPx >>> 24) & 0xFF;

                ur = baseByte + dr;
                ug = baseByte + 1 + dg;
                ub = baseByte + 2 + db;
                ua = baseByte + 3 + da;

                srcR = iData[ur];
                srcG = iData[ug];
                srcB = iData[ub];

                if (transparentEdges) {

                    outOfRow =
                        (ur < rowStart || ur > rowEnd) ||
                        (ug < rowStart || ug > rowEnd) ||
                        (ub < rowStart || ub > rowEnd) ||
                        (ua < rowStart || ua > rowEnd);

                    srcA = outOfRow ? 0 : iData[ua];
                }
                else srcA = iData[ua];

                if (!useInputAsMask) {

                    outR = srcR;
                    outG = srcG;
                    outB = srcB;
                    outA = srcA;

                    o32[p] = (outA << 24) | (outB << 16) | (outG << 8) | outR;
                    continue;
                }

                movedZero = (srcA === 0);
                destZero  = (destA === 0);

                outR = destR;
                outG = destG;
                outB = destB;
                outA = destA;

                if (!movedZero && !destZero) {

                    outR = srcR;
                    outG = srcG;
                    outB = srcB;
                    outA = srcA;
                }
                else if (movedZero && !destZero && transparentEdges) {

                    outR = 0;
                    outG = 0;
                    outB = 0;
                    outA = 0;
                }
                o32[p] = (outA << 24) | (outB << 16) | (outG << 8) | outR;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [GRAYSCALE]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer, oData.byteOffset, oData.byteLength >>> 2);

        const {
            opacity = 1,
            lineOut
        } = requirements;

        let rgba, r, g, b, a, gray, p, pz;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            rgba = src32[p];

            r = rgba & 0xff;
            g = (rgba >>> 8) & 0xff;
            b = (rgba >>> 16) & 0xff;
            a = (rgba >>> 24) & 0xff;

            gray = (r * 54 + g * 183 + b * 19) >> 8;

            out32[p] = ((a << 24) | (gray << 16) | (gray << 8) | gray) >>> 0;
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [INVERT_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            includeAlpha = false,
            lineOut,
        } = requirements;

        const mask = (includeRed ? 0x000000FF : 0) | (includeGreen ? 0x0000FF00 : 0) | (includeBlue ? 0x00FF0000 : 0) | (includeAlpha ? 0xFF000000 : 0);

        if (mask === 0) out32.set(src32);
        else {

            for (let p = 0, pz = src32.length | 0; p < pz; p++) {

                out32[p] = src32[p] ^ mask;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [LOCK_CHANNELS_TO_LEVELS]: function (requirements) {

        const normalizeLevels = (spec) => {

            let arr;

            if (spec == null) arr = [];
            else if (spec.toFixed) arr = [spec];
            else if (spec.substring) {

                arr = (spec.match(/-?\d+/g) || []).map(n => +n);
            }
            else if (_isArray(spec)) arr = spec.map(n => +n);
            else arr = [];

            const seen = new Uint8Array(256),
                out = [];

            let i, iz, v;

            for (i = 0, iz = arr.length; i < iz; i++) {

                v = arr[i];

                if (!_isFinite(v)) continue;

                v = v < 0 ? 0 : v > 255 ? 255 : v | 0;

                if (!seen[v]) {

                    seen[v] = 1;
                    out.push(v);
                }
            }

            out.sort((a, b) => a - b);

            return out;
        };

        const buildLUT = (levels) => {

            const lut = new Uint8ClampedArray(256);

            if (!levels || levels.length === 0) {

                for (let v = 0; v < 256; v++) {

                    lut[v] = v;
                }
                return lut;
            }

            if (levels.length === 1) {

                const L = levels[0] | 0;

                for (let v = 0; v < 256; v++) {

                    lut[v] = L;
                }
                return lut;
            }

            for (let i = 0, iz = levels.length; i < iz; i++) {

                const cur = levels[i],
                    start = (i === 0) ? 0 : _ceil((levels[i - 1] + cur) * 0.5),
                    end = (i === iz - 1) ? 255 : _floor((cur + levels[i + 1]) * 0.5);

                for (let v = start; v <= end; v++) {

                    lut[v] = cur;
                }
            }
            return lut;
        };

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer, oData.byteOffset, oData.byteLength >>> 2);

        const {
            opacity = 1,
            red = [0],
            green = [0],
            blue = [0],
            alpha = [255],
            lineOut,
        } = requirements;

        const rLevels = normalizeLevels(red),
            gLevels = normalizeLevels(green),
            bLevels = normalizeLevels(blue),
            aLevels = normalizeLevels(alpha);

        const lutR = buildLUT(rLevels),
            lutG = (green === red) ? lutR : buildLUT(gLevels),
            lutB = (blue  === red) ? lutR : (blue === green ? lutG : buildLUT(bLevels)),
            lutA = buildLUT(aLevels);

        let p, pz, rgba, r, g, b, a, nr, ng, nb, na;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            rgba = src32[p];

            r = rgba & 0xFF;
            g = (rgba >>> 8) & 0xFF;
            b = (rgba >>> 16) & 0xFF;
            a = (rgba >>> 24) & 0xFF;

            nr = lutR[r];
            ng = lutG[g];
            nb = lutB[b];
            na = lutA[a];

            out32[p] = ((na << 24) | (nb << 16) | (ng << 8) | nr) >>> 0;
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [LUMINANCE_TO_ALPHA]: function (requirements) {

        const SRGB_TO_LINEAR_LUT = 'srgb-linear-lut-256';
        const OKLAB_L_FROM_SRGB_TABLES = 'oklab-L-from-srgb-9tables';
        const getOklabLTables = () => {

            const getLinearSrgbLut = () => {

                let lut = getWorkstoreItem(SRGB_TO_LINEAR_LUT);

                if (lut) return lut;

                lut = new Float32Array(256);

                let i, cs;

                for (i = 0; i < 256; i++) {

                    cs = i / 255;
                    lut[i] = (cs <= 0.04045) ? (cs / 12.92) : _pow((cs + 0.055) / 1.055, 2.4);
                }
                setWorkstoreItem(SRGB_TO_LINEAR_LUT, lut);

                return lut;
            };

            let lut = getWorkstoreItem(OKLAB_L_FROM_SRGB_TABLES);
            if (lut) return lut;

            const s2l = getLinearSrgbLut();

            const Lr = new Float32Array(256),
                Lg = new Float32Array(256),
                Lb = new Float32Array(256),
                Mr = new Float32Array(256),
                Mg = new Float32Array(256),
                Mb = new Float32Array(256),
                Sr = new Float32Array(256),
                Sg = new Float32Array(256),
                Sb = new Float32Array(256);

            for (let i = 0, v; i < 256; i++) {

                v = s2l[i];

                Lr[i] = 0.4122214708 * v;
                Lg[i] = 0.5363325363 * v;
                Lb[i] = 0.0514459929 * v;

                Mr[i] = 0.2119034982 * v;
                Mg[i] = 0.6806995451 * v;
                Mb[i] = 0.1073969566 * v;

                Sr[i] = 0.0883024619 * v;
                Sg[i] = 0.2817188376 * v;
                Sb[i] = 0.6299787005 * v;
            }

            lut = { Lr, Lg, Lb, Mr, Mg, Mb, Sr, Sg, Sb };

            setWorkstoreItem(OKLAB_L_FROM_SRGB_TABLES, lut);

            return lut;
        };

        const getCbrtLut = function (size = 4096, maxX = 1.0) {

            const key = `oklab::cbrt::${size}::${maxX}`;
            let lut = getWorkstoreItem(key);

            if (!lut) {

                lut = new Float32Array(size + 1);

                const step = maxX / size;

                let i, x;

                for (i = 0; i <= size; i++) {

                    x = i * step;
                    lut[i] = Math.cbrt(x);
                }
                setWorkstoreItem(key, lut);
            }
            return { lut, size, maxX, scale: size / maxX };
        };

        const cbrtLUT = function (x, lutPack) {

            const v = x;

            if (v <= 0) return 0;

            if (v >= lutPack.maxX) return lutPack.lut[lutPack.size];

            const f = v * lutPack.scale,
                i = f | 0,
                t = f - i,
                a = lutPack.lut[i],
                b = lutPack.lut[i + 1];

            return a + t * (b - a);
        };

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            lineOut,
        } = requirements;

        const { Lr, Lg, Lb, Mr, Mg, Mb, Sr, Sg, Sb } = getOklabLTables();

        const lutPack = getCbrtLut(4096, 1.0);

        let p, pz, s, r8, g8, b8, l, m, s3, l_, m_, s_, L, A;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            s = src32[p];

            r8 = s & 0xFF;
            g8 = (s >>> 8) & 0xFF;
            b8 = (s >>> 16) & 0xFF;

            l = Lr[r8] + Lg[g8] + Lb[b8];
            m = Mr[r8] + Mg[g8] + Mb[b8];
            s3 = Sr[r8] + Sg[g8] + Sb[b8];

            l_ = cbrtLUT(l, lutPack);
            m_ = cbrtLUT(m, lutPack);
            s_ = cbrtLUT(s3, lutPack);

            L = (0.2104542553 * l_) + (0.7936177850 * m_) - (0.0040720468 * s_);

            if (L < 0) L = 0;
            else if (L > 1) L = 1;

            A = (L * 256) | 0;
            if (A > 255) A = 255;

            out32[p] = (A << 24) >>> 0;
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [MAP_TO_GRADIENT]: function (requirements) {

        const getGradientData = function (gradient) {

            const name = `gradient-data-${gradient.name}`;

            const itemInWorkstore = getWorkstoreItem(name);

            if (!itemInWorkstore || gradient.dirtyFilterIdentifier || gradient.animateByDelta) {

                const mycell = requestCell();

                const {engine, element} = mycell;

                element.width = 256;
                element.height = 1;

                const G = engine.createLinearGradient(0, 0, 255, 0);

                gradient.addStopsToGradient(G, gradient.paletteStart, gradient.paletteEnd, gradient.cyclePalette);

                engine.fillStyle = G;
                engine.fillRect(0, 0, 256, 1);

                const data = engine.getImageData(0, 0, 256, 1).data;

                releaseCell(mycell);

                return setAndReturnWorkstoreItem(name, data);
            }

            return itemInWorkstore || [];
        };

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            useNaturalGrayscale = false,
            lineOut,
        } = requirements;

        let gradient = requirements.gradient || false;
        if (gradient.substring) gradient = styles[gradient];

        if (!gradient) out32.set(src32);
        else {

            const gradBytes = getGradientData(gradient);

            if (!gradBytes || gradBytes.length < 1024) out32.set(src32);
            else {

                const grad32 = new Uint32Array(gradBytes.buffer, gradBytes.byteOffset, 256);

                let sumLUT;
                if (!useNaturalGrayscale) {

                    sumLUT = getWorkstoreItem(NAIVE_GRAY_LUT);

                    if (!sumLUT) {

                        sumLUT = new Uint8Array(766);

                        for (let s = 0; s <= 765; s++) {

                            sumLUT[s] = Math.floor(0.3333 * s) & 0xFF;
                        }
                        setWorkstoreItem(NAIVE_GRAY_LUT, sumLUT);
                    }
                }

                let p, pz, s, a, r, g, b, gray, sum;

                for (p = 0, pz = src32.length | 0; p < pz; p++) {

                    s = src32[p];
                    a = (s >>> 24) & 0xFF;

                    if (a === 0) {

                        out32[p] = s;
                        continue;
                    }

                    r = s & 0xFF;
                    g = (s >>> 8) & 0xFF;
                    b = (s >>> 16) & 0xFF;

                    if (useNaturalGrayscale) gray = (r * 54 + g * 183 + b * 19) >> 8;
                    else {

                        sum = r + g + b;
                        gray = sumLUT[sum];
                    }
                    out32[p] = grad32[gray];
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [MATRIX]: function (requirements) {

        const getMatrixOffsetsPx = function (mWidth, mHeight, mX, mY, image) {

            if (!image) image = cache.source;

            const iWidth  = image.width  | 0,
                iHeight = image.height | 0;

            mWidth = (_isFinite(mWidth) && mWidth  > 0) ? (mWidth | 0) : 1;
            mHeight = (_isFinite(mHeight) && mHeight > 0) ? (mHeight | 0) : 1;

            mX = (_isFinite(mX) ? mX : 0) | 0;
            if (mX < 0) mX = 0;
            else if (mX >= mWidth)  mX = mWidth  - 1;

            mY = (_isFinite(mY) ? mY : 0) | 0;
            if (mY < 0) mY = 0;
            else if (mY >= mHeight) mY = mHeight - 1;

            const name = `matrix-offsets-px-${iWidth}-${iHeight}-${mWidth}-${mHeight}-${mX}-${mY}`;

            let res = getWorkstoreItem(name);
            if (res) return res;

            res = new Int32Array(mWidth * mHeight);

            let p = 0, y, x, yz, xz, rowOff;

            for (y = -mY, yz = mHeight - mY; y < yz; y++) {

                rowOff = y * iWidth;

                for (x = -mX, xz = mWidth - mX; x < xz; x++) {

                    res[p++] = rowOff + x;
                }
            }
            setWorkstoreItem(name, res);
            return res;
        };

        const [input, output] = getInputAndOutputLines(requirements),
            iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer, oData.byteOffset, oData.byteLength >>> 2);

        const pixels = src32.length;

        const {
            opacity = 1,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            includeAlpha = false,
            premultiply = false,
            useInputAsMask = false,
            offsetX = 1,
            offsetY = 1,
            lineOut,
        } = requirements;

        let mW = requirements.width;
        if (!_isFinite(mW) || mW < 1) {

            mW = 3; mW |= 0;
        }

        let mH = requirements.height;
        if (!_isFinite(mH) || mH < 1) {

            mH = 3;
            mH |= 0;
        }

        let aX = (_isFinite(offsetX) ? offsetX : 0) | 0;
        if (aX < 0) aX = 0;
        else if (aX >= mW) aX = mW - 1;

        let aY = (_isFinite(offsetY) ? offsetY : 0) | 0;
        if (aY < 0) aY = 0;
        else if (aY >= mH) aY = mH - 1;

        let weights = requirements.weights;
        if (!weights || weights.length !== (mW * mH)) {

            weights = new Float32Array(mW * mH);
            weights[(aY * mW) + aX] = 1;
        }
        else if (!(weights instanceof Float32Array)) {

            weights = Float32Array.from(weights);
        }

        const nzIdx = requestArray(),
              nzW   = requestArray();

        for (let i = 0, iz = weights.length, w; i < iz; i++) {

            w = weights[i];

            if (w !== 0) {

                nzIdx.push(i);
                nzW.push(w);
            }
        }

        const nzCount = nzIdx.length;

        if (nzCount === 0) {

            out32.set(src32);

            if (lineOut) processResults(output, input, 1 - opacity);
            else processResults(cache.work, output, opacity);

            releaseArray(nzIdx, nzW);

            return;
        }

        const offsPx = getMatrixOffsetsPx(mW, mH, aX, aY, input);

        if (premultiply) {

            const eps = 1e-6;

            let sumW = 0,
                center, aCenter,
                accR, accG, accB, accA,
                t, i, k, w, di, idx, px, r, g, b, a,
                oR, oG, oB, oA, invA;

            for (t = 0; t < nzCount; t++) {

                sumW += nzW[t];
            }

            if (sumW === 0) sumW = 1;

            for (i = 0; i < pixels; i++) {

                center = src32[i];
                aCenter = (center >>> 24) & 0xFF;

                accR = 0;
                accG = 0;
                accB = 0;
                accA = 0;

                for (k = 0; k < nzCount; k++) {

                    w  = nzW[k];
                    di = offsPx[nzIdx[k]];

                    idx = i + di;
                    if (idx < 0) idx += pixels;
                    else if (idx >= pixels) idx -= pixels;

                    px = src32[idx];

                    a = (px >>> 24) & 0xFF;
                    if (a === 0) continue;

                    r = px & 0xFF;
                    g = (px >>> 8) & 0xFF;
                    b = (px >>> 16) & 0xFF;

                    if (includeRed) accR += (r * a) * w;
                    if (includeGreen) accG += (g * a) * w;
                    if (includeBlue) accB += (b * a) * w;

                    accA += a * w;
                }

                if (accA <= eps) {

                    oR = 0;
                    oG = 0;
                    oB = 0;
                    oA = useInputAsMask ? aCenter : 0;
                }
                else {

                    invA = 1 / accA;
                    oR = includeRed ? (accR * invA) : (center & 0xFF);
                    oG = includeGreen ? (accG * invA) : ((center >>> 8) & 0xFF);
                    oB = includeBlue ? (accB * invA) : ((center >>> 16) & 0xFF);
                    oA = useInputAsMask ? aCenter : (accA / sumW);
                }

                out32[i] = ((oA & 0xFF) << 24) | ((oB & 0xFF) << 16) | ((oG & 0xFF) <<  8) | (oR & 0xFF);
            }
        }
        else {

            let i, center, aCenter,
                oR, oG, oB, oA,
                k, w, di, idx, px;

            for (i = 0; i < pixels; i++) {

                center = src32[i];
                aCenter = (center >>> 24) & 0xFF;

                if (aCenter === 0) {

                    out32[i] = center;
                    continue;
                }

                oR = includeRed ? 0 : (center & 0xFF);
                oG = includeGreen ? 0 : ((center >>> 8) & 0xFF);
                oB = includeBlue ? 0 : ((center >>> 16) & 0xFF);
                oA = includeAlpha ? 0 : aCenter;

                for (k = 0; k < nzCount; k++) {

                    w  = nzW[k];
                    di = offsPx[nzIdx[k]];

                    idx = i + di;
                    if (idx < 0) idx += pixels;
                    else if (idx >= pixels) idx -= pixels;

                    px = src32[idx];

                    if (includeRed) oR += (px & 0xFF) * w;
                    if (includeGreen) oG += ((px >>> 8) & 0xFF) * w;
                    if (includeBlue) oB += ((px >>> 16) & 0xFF) * w;
                    if (includeAlpha) oA += ((px >>> 24) & 0xFF) * w;
                }

                oR = oR < 0 ? 0 : oR > 255 ? 255 : oR;
                oG = oG < 0 ? 0 : oG > 255 ? 255 : oG;
                oB = oB < 0 ? 0 : oB > 255 ? 255 : oB;
                oA = oA < 0 ? 0 : oA > 255 ? 255 : oA;

                out32[i] = ((oA & 0xFF) << 24) | ((oB & 0xFF) << 16) | ((oG & 0xFF) <<  8) | (oR & 0xFF);
            }
        }

        releaseArray(nzIdx, nzW);

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [MODIFY_OK_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            channelA = 0,
            channelB = 0,
            channelL = 0,
            lineOut,
        } = requirements;

        if (channelL === 0 && channelA === 0 && channelB === 0) out32.set(src32);
        else {

            const libs = colorEngine.getRgbOkCache(),
                getOk = colorEngine.getOkValsForRgb,
                toRgb = colorEngine.getRgbValsForOklab;

            const clamp01 = (v) => (v < 0 ? 0 : (v > 1 ? 1 : v));
            const clampAB = (v) => (v < -0.4 ? -0.4 : (v > 0.4 ? 0.4 : v));

            let p, pz, s, a, r0, g0, b0, ok, L, A, B, rgb;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                s = src32[p];

                a = (s >>> 24) & 0xff;
                if (a === 0) {

                    out32[p] = s;
                    continue;
                }

                r0 = s & 0xff;
                g0 = (s >>> 8) & 0xff;
                b0 = (s >>> 16) & 0xff;

                ok = getOk(r0, g0, b0, libs);

                L = clamp01(ok[0] + channelL);
                A = clampAB(ok[1] + channelA);
                B = clampAB(ok[2] + channelB);

                rgb = toRgb(L, A, B, libs);

                out32[p] = ((a << 24) | (rgb[2] << 16) | (rgb[1] << 8) | rgb[0]) >>> 0;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [MODULATE_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            red = 1,
            green = 1,
            blue = 1,
            alpha = 1,
            saturation = false,
            lineOut,
        } = requirements;

        const rK = (red * 256 + 0.5) | 0,
            gK = (green * 256 + 0.5) | 0,
            bK = (blue * 256 + 0.5) | 0,
            aK = (alpha * 256 + 0.5) | 0;

        let p, pz, rgba, r, g, b, a;

        if (!saturation && rK === 256 && gK === 256 && bK === 256 && aK === 256) out32.set(src32);

        else if (!saturation) {

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                rgba = src32[p];

                r = rgba & 0xff;
                g = (rgba >>> 8) & 0xff;
                b = (rgba >>> 16) & 0xff;
                a = (rgba >>> 24) & 0xff;

                r = (r * rK + 128) >> 8;
                if (r < 0) r = 0;
                else if (r > 255) r = 255;

                g = (g * gK + 128) >> 8;
                if (g < 0) g = 0;
                else if (g > 255) g = 255;

                b = (b * bK + 128) >> 8;
                if (b < 0) b = 0;
                else if (b > 255) b = 255;

                a = (a * aK + 128) >> 8;
                if (a < 0) a = 0;
                else if (a > 255) a = 255;

                out32[p] = ((a << 24) | (b << 16) | (g << 8) | r) >>> 0;
            }
        }
        else {

            let r0, g0, b0, gray;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                rgba = src32[p];

                r0 = rgba & 0xff;
                g0 = (rgba >>> 8) & 0xff;
                b0 = (rgba >>> 16) & 0xff;
                a  = (rgba >>> 24) & 0xff;

                gray = (r0 * 54 + g0 * 183 + b0 * 19) >> 8;

                r = gray + (((r0 - gray) * rK + 128) >> 8);
                g = gray + (((g0 - gray) * gK + 128) >> 8);
                b = gray + (((b0 - gray) * bK + 128) >> 8);
                a = (a * aK + 128) >> 8;

                if (r < 0) r = 0;
                else if (r > 255) r = 255;

                if (g < 0) g = 0;
                else if (g > 255) g = 255;

                if (b < 0) b = 0;
                else if (b > 255) b = 255;

                if (a < 0) a = 0;
                else if (a > 255) a = 255;

                out32[p] = ((a << 24) | (b << 16) | (g << 8) | r) >>> 0;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [MODULATE_OK_CHANNELS]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            channelA = 1,
            channelB = 1,
            channelL = 1,
            lineOut,
        } = requirements;

        if (channelL === 1 && channelA === 1 && channelB === 1) out32.set(src32);
        else {

            const libs = colorEngine.getRgbOkCache(),
                getOk  = colorEngine.getOkValsForRgb,
                toRgb  = colorEngine.getRgbValsForOklab;

            const clamp01 = (v) => (v < 0 ? 0 : (v > 1 ? 1 : v)),
                clampAB = (v) => (v < -0.4 ? -0.4 : (v > 0.4 ? 0.4 : v));

            let p, pz, s, a, r0, g0, b0, ok, L, A, B, rgb;

            for (p = 0, pz = src32.length | 0; p < pz; p++) {

                s = src32[p];

                a = (s >>> 24) & 0xff;

                if (a === 0) {

                    out32[p] = s;
                    continue;
                }

                r0 = s & 0xff;
                g0 = (s >>> 8) & 0xff;
                b0 = (s >>> 16) & 0xff;

                ok = getOk(r0, g0, b0, libs);

                L = clamp01(ok[0] * channelL);
                A = clampAB(ok[1] * channelA);
                B = clampAB(ok[2] * channelB);

                rgb = toRgb(L, A, B, libs);

                out32[p] = ((a << 24) | (rgb[2] << 16) | (rgb[1] << 8) | rgb[0]) >>> 0;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [NEGATIVE]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            lineOut,
        } = requirements;

        const libs = colorEngine.getRgbOkCache(),
            getOk  = colorEngine.getOkValsForRgb,
            toRgb  = colorEngine.getRgbValsForOklab;

        let p, pz, rgba, r, g, b, a, ok, L, A, B, rgb;

        for (p = 0, pz = src32.length | 0; p < pz; p++) {

            rgba = src32[p];

            r = rgba & 0xFF;
            g = (rgba >>> 8) & 0xFF;
            b = (rgba >>> 16) & 0xFF;
            a = (rgba >>> 24) & 0xFF;

            if (a === 0) {

                out32[p] = rgba;
                continue;
            }

            ok = getOk(r, g, b, libs);

            L = 1 - ok[0];
            A = -ok[1];
            B = -ok[2];

            rgb = toRgb(L, A, B, libs);

            out32[p] = ((a << 24) | (rgb[2] << 16) | (rgb[1] << 8) | rgb[0]) >>> 0;
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [NEWSPRINT]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
              oData = output.data;

        const {
            opacity = 1,
            lineOut,
        } = requirements;

        let w = _floor(requirements.width || 1);
        if (w < 1) w = 1;

        const tDim = w << 1,
            width  = input.width | 0,
            rowStride = width << 2;

        const rects = buildTileRects(tDim, tDim, 0, 0, input);

        const gVal = colorEngine.getBestGray,
            patterns = newspaperPatterns;

        let t, x0, x1, y0, y1, tw, th, count, sum, y, idx, end, avg, p, p0, p1, p2, p3, ox, oy, topBand, rowBase, x, leftBand, gray;

        for (t = 0; t < rects.length; t += 4) {

            x0 = rects[t];
            y0 = rects[t + 1];
            x1 = rects[t + 2];
            y1 = rects[t + 3];

            tw = x1 - x0;
            th = y1 - y0;
            count = tw * th;

            sum = 0;

            for (y = y0; y < y1; y++) {

                idx = (y * rowStride) + (x0 << 2);
                end = idx + (tw << 2);

                for (; idx < end; idx += 4) {

                    sum += gVal(iData[idx], iData[idx + 1], iData[idx + 2]);
                }
            }
            avg = sum / count;

            p = patterns[_min(12, _floor((avg / 255) * 13))];

            p0 = p[0];
            p1 = p[1];
            p2 = p[2];
            p3 = p[3];

            ox = _floor(x0 / tDim) * tDim;
            oy = _floor(y0 / tDim) * tDim;

            for (y = y0; y < y1; y++) {

                topBand = ((y - oy) < w);
                rowBase = (y * rowStride);

                for (x = x0; x < x1; x++) {

                    leftBand = ((x - ox) < w);
                    gray = topBand ? (leftBand ? p0 : p1) : (leftBand ? p2 : p3);

                    idx = rowBase + (x << 2);

                    oData[idx] = gray;
                    oData[idx + 1] = gray;
                    oData[idx + 2] = gray;
                    oData[idx + 3] = iData[idx + 3];
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [OFFSET]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data,
            width  = input.width  | 0,
            height = input.height | 0;


        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            offsetRedX = 0,
            offsetRedY = 0,
            offsetGreenX = 0,
            offsetGreenY = 0,
            offsetBlueX = 0,
            offsetBlueY = 0,
            useInputAsMask = false,
            lineOut,
        } = requirements;

        if (!(offsetRedX || offsetGreenX || offsetBlueX || offsetRedY || offsetGreenY || offsetBlueY)) out32.set(src32);

        else {

            const rowStridePx = width | 0;

            const simple = offsetRedX === offsetGreenX && offsetRedX === offsetBlueX && offsetRedY === offsetGreenY && offsetRedY === offsetBlueY;

            if (simple) {

                const dx = offsetRedX | 0,
                    dy = offsetRedY | 0,
                    xStart = dx < 0 ? -dx : 0,
                    xEnd = dx > 0 ? width - dx : width,
                    n = (xEnd - xStart) | 0;

                if (n > 0) {

                    let y, ty, srcRowBase, destRowBase;

                    for (y = 0; y < height; y++) {

                        ty = y + dy;
                        if (ty < 0 || ty >= height) continue;

                        if (n <= 0) continue;

                        srcRowBase = (y  * rowStridePx + xStart) | 0;
                        destRowBase = (ty * rowStridePx + xStart + dx) | 0;

                        out32.set(src32.subarray(srcRowBase, srcRowBase + n), destRowBase);
                    }
                }
            }

            else {

                out32.fill(0);

                const copyChannel = (dx, dy, shift) => {

                    dx |= 0; dy |= 0;

                    if (dx === 0 && dy === 0) {

                        const cm  = (0xFF << shift) >>> 0,
                            ncm = (~cm) >>> 0;

                        let p, pz, s, v, merged, inA, outA, a;

                        for (p = 0, pz = src32.length | 0; p < pz; p++) {

                            s = src32[p];
                            v = out32[p];

                            merged = (v & ncm) | (s & cm);

                            inA  = (s >>> 24) & 0xFF;
                            outA = (v >>> 24) & 0xFF;
                            a    = inA > outA ? inA : outA;

                            out32[p] = (merged & 0x00FFFFFF) | (a << 24);
                        }
                        return;
                    }

                    const cm = (0xFF << shift) >>> 0,
                        ncm = (~cm) >>> 0;

                    let y, ty, xStart, xEnd, n, src, dst, v, s, merged, k, inA, outA, a;

                    for (y = 0; y < height; y++) {

                        ty = y + dy;
                        if (ty < 0 || ty >= height) continue;

                        xStart = dx < 0 ? -dx : 0;
                        xEnd = dx > 0 ? width - dx : width;
                        n = (xEnd - xStart) | 0;

                        if (n <= 0) continue;

                        src = (y * rowStridePx + xStart) | 0;
                        dst = (ty * rowStridePx + xStart + dx) | 0;

                        for (k = 0; k < n; k++, src++, dst++) {

                            v = out32[dst];
                            s = src32[src];

                            merged = (v & ncm) | (s & cm);

                            inA  = (s >>> 24) & 0xFF;
                            outA = (v >>> 24) & 0xFF;
                            a = inA > outA ? inA : outA;

                            out32[dst] = (merged & 0x00FFFFFF) | (a << 24);
                        }
                    }
                };

                copyChannel(offsetRedX, offsetRedY, 0);
                copyChannel(offsetGreenX, offsetGreenY, 8);
                copyChannel(offsetBlueX, offsetBlueY, 16);
            }

            if (useInputAsMask) {

                const pixelCount = src32.length;
                let p, s;

                for (p = 0; p < pixelCount; p++) {

                    s = src32[p];
                    if ((s >>> 24) === 0) out32[p] = 0;
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [PIXELATE]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data,
            len = iData.length;

        const {
            opacity = 1,
            tileWidth = 1,
            tileHeight = 1,
            offsetX = 0,
            offsetY = 0,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            includeAlpha = false,
            lineOut,
        } = requirements;

        const width  = input.width | 0,
            rowStride = width << 2;

        if (!includeRed && !includeGreen && !includeBlue && !includeAlpha) transferDataUnchanged(oData, iData, len);
        else {

            const rects = buildTileRects(tileWidth, tileHeight, offsetX, offsetY, input);

            let t, x0, x1, y0, y1, w, h, count, sumR, sumG, sumB, sumA, idx, end, avgR, avgG, avgB, avgA, y, start, p;

            for (t = 0; t < rects.length; t += 4) {

                x0 = rects[t];
                y0 = rects[t + 1];
                x1 = rects[t+2];
                y1 = rects[t + 3];

                w = x1 - x0;
                h = y1 - y0;
                count = w * h;

                sumR = 0;
                sumG = 0;
                sumB = 0;
                sumA = 0;

                if (includeRed || includeGreen || includeBlue || includeAlpha) {

                    for (y = y0; y < y1; y++) {

                        idx = (y * rowStride) + (x0 << 2);
                        end = idx + (w << 2);

                        if (includeRed && includeGreen && includeBlue && includeAlpha) {

                            for (; idx < end; idx += 4) {

                                sumR += iData[idx];
                                sumG += iData[idx + 1];
                                sumB += iData[idx + 2];
                                sumA += iData[idx + 3];
                            }
                        } else {

                            for (; idx < end; idx += 4) {

                                if (includeRed) sumR += iData[idx];
                                if (includeGreen) sumG += iData[idx + 1];
                                if (includeBlue) sumB += iData[idx + 2];
                                if (includeAlpha) sumA += iData[idx + 3];
                            }
                        }
                    }
                }

                avgR = includeRed ? _floor(sumR / count) : 0;
                avgG = includeGreen ? _floor(sumG / count) : 0;
                avgB = includeBlue ? _floor(sumB / count) : 0;
                avgA = includeAlpha ? _floor(sumA / count) : 0;

                for (y = y0; y < y1; y++) {

                    start = (y * rowStride) + (x0 << 2);
                    end = start + (w << 2);

                    oData.set(iData.subarray(start, end), start);

                    if (includeRed || includeGreen || includeBlue || includeAlpha) {

                        p = start;

                        if (includeRed && includeGreen && includeBlue && includeAlpha) {

                            for (; p < end; p += 4) {

                                oData[p] = avgR;
                                oData[p + 1] = avgG;
                                oData[p + 2] = avgB;
                                oData[p + 3] = avgA;
                            }
                        }
                        else {

                            for (; p < end; p += 4) {

                                if (includeRed) oData[p] = avgR;
                                if (includeGreen) oData[p + 1] = avgG;
                                if (includeBlue) oData[p + 2] = avgB;
                                if (includeAlpha) oData[p + 3] = avgA;
                            }
                        }
                    }
                }
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [PROCESS_IMAGE]: function (requirements) {

        const { identifier, lineOut } = requirements;
        if (!(lineOut && lineOut.substring && lineOut.length)) return;

        const {
            width: hostW,
            height: hostH,
        } = cache.source;

        const specifiedIdentifier = `${identifier}_${hostW}_${hostH}`;

        const item = getWorkstoreItem(specifiedIdentifier);

        if (item && item.width === hostW && item.height === hostH) cache[lineOut] = item;
        else cache[lineOut] = new ImageData(hostW, hostH);
    },

    [RANDOM_NOISE]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data,
            width  = input.width | 0;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            width: boxW = 1,
            height: boxH = 1,
            level = 0.5,
            seed = DEFAULT_SEED,
            noiseType = RANDOM,
            noWrap = false,
            includeRed = true,
            includeGreen = true,
            includeBlue = true,
            includeAlpha = true,
            excludeTransparentPixels = true,
            lineOut,
        } = requirements;

        const totalPx = src32.length | 0;

        const rnd = getRandomNumbers({
            seed,
            length: Math.ceil(totalPx * 3),
            imgWidth: width,
            type: noiseType,
        });

        let rp = 0;

        const halfW = boxW * 0.5,
            halfH = boxH * 0.5;

        const incMask = (includeRed ? 0x000000FF : 0) | (includeGreen ? 0x0000FF00 : 0) | (includeBlue ? 0x00FF0000 : 0) | (includeAlpha ? 0xFF000000 : 0);

        if (incMask === 0xFFFFFFFF >>> 0) {

            let p, pz, rLevel, rWx, rHy, t, sPix, dw, dh, q, aP, aQ;

            for (p = 0, pz = totalPx; p < pz; p++) {

                if (noiseType === RANDOM) {

                    rLevel = rnd[rp++];
                    rWx = rnd[rp++];
                    rHy = rnd[rp++];
                }
                else {

                    t = rnd[rp++];
                    rLevel = t;
                    rWx = t;
                    rHy = t;
                }

                sPix = src32[p];

                if (rLevel >= level) {

                    out32[p] = sPix;
                    continue;
                }

                dw = _floor(rWx * boxW - halfW) | 0;
                dh = _floor(rHy * boxH - halfH) | 0;

                q = p + dh * width + dw;

                if (noWrap) {

                    if (q < 0 || q >= totalPx) {

                        out32[p] = sPix;
                        continue;
                    }
                }
                else {

                    if (q < 0) q += totalPx;
                    else if (q >= totalPx) q -= totalPx;
                }

                if (excludeTransparentPixels) {

                    aP = (sPix >>> 24) & 0xFF;
                    aQ = (src32[q] >>> 24) & 0xFF;

                    if (aP === 0 || aQ === 0) {

                        out32[p] = sPix;
                        continue;
                    }
                }
                out32[p] = src32[q];
            }
        }

        else {

            const notIncMask = (~incMask) >>> 0;

            let p, pz, rLevel, rWx, rHy, t, orig, dw, dh, q, aP, aQ, sampled;

            for (p = 0, pz = totalPx; p < pz; p++) {

                if (noiseType === RANDOM) {

                    rLevel = rnd[rp++];
                    rWx = rnd[rp++];
                    rHy = rnd[rp++];
                }
                else {

                    t = rnd[rp++];
                    rLevel = t;
                    rWx = t;
                    rHy = t;
                }

                orig = src32[p];

                if (rLevel >= level) {

                    out32[p] = orig;
                    continue;
                }

                dw = _floor(rWx * boxW - halfW) | 0;
                dh = _floor(rHy * boxH - halfH) | 0;

                q = p + dh * width + dw;

                if (noWrap) {

                    if (q < 0 || q >= totalPx) {

                        out32[p] = orig;
                        continue;
                    }
                }
                else {

                    if (q < 0) q += totalPx;
                    else if (q >= totalPx) q -= totalPx;
                }

                if (excludeTransparentPixels) {

                    aP = (orig >>> 24) & 0xFF;
                    aQ = (src32[q] >>> 24) & 0xFF;

                    if (aP === 0 || aQ === 0) {

                        out32[p] = orig;
                        continue;
                    }
                }

                sampled = src32[q];

                out32[p] = (orig & notIncMask) | (sampled & incMask);
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [REDUCE_PALETTE]: function (requirements) {

        const getRGBIndex = (r, g, b) => (r * _256_SQUARE) + (g * _256) + b;

        const [input, output] = getInputAndOutputLines(requirements),
            iData = input.data,
            iWidth = input.width,
            oData = output.data,
            len = iData.length;

        const {
            opacity = 1,
            seed = DEFAULT_SEED,
            useBluenoise = false,
            minimumColorDistance = 500,
            lineOut,
        } = requirements;

        let { palette = BLACK_WHITE } = requirements;

        const noiseType = useBluenoise ? BLUENOISE : (requirements.noiseType || RANDOM);

        const libs = colorEngine.getRgbOkCache();

        const rnd = getRandomNumbers({
            seed,
            length: len / 4,
            imgWidth: iWidth,
            type: noiseType,
        });

        let rndCursor = -1;

        if (palette == null) palette = BLACK_WHITE;
        else if (palette.substring && !predefinedPalette[palette]) palette = BLACK_WHITE;
        else if (_isArray(palette) && palette.length < 2) palette = BLACK_WHITE;
        else if (palette.toFixed && (palette < 2 || palette > 256)) palette = BLACK_WHITE;

        const isGray = GRAY_PALETTES.includes(palette);
        const isArrayPalette = _isArray(palette);

        const BTPRes = [0, 0, 0, 0];
        const bestTwoPaletteIndices = (ILi, IAi, IBi, pal) => {

            let i0 = -1,
                i1 = -1,
                d0 = Infinity,
                d1 = Infinity,
                p, pz, e, dL, dA, dB, dsq;

            for (p = 0, pz = pal.length; p < pz; p++) {

                e = pal[p];
                dL = ILi - e[4];
                dA = IAi - e[5];
                dB = IBi - e[6];
                dsq = (dL * dL) + (dA * dA) + (dB * dB);

                if (dsq < d0) {

                    d1 = d0;
                    i1 = i0;
                    d0 = dsq;
                    i0 = p;
                }
                else if (dsq < d1) {

                    d1 = dsq;
                    i1 = p;
                }
            }

            BTPRes[0] = i0;
            BTPRes[1] = i1;
            BTPRes[2] = d0;
            BTPRes[3] = d1;

            return BTPRes;
        }

        if (isGray) {

            const selectedPalette = predefinedPalette[palette],
                P = selectedPalette.length,
                getGray = colorEngine.getBestGray;

            let i, a, alpha, r, g, b, gray, idx0, idx1,
                d0, d1, pi, pv, d, total, propensity, test, chosen;

            for (i = 0; i < len; i += 4) {

                r = i;
                g = r + 1;
                b = g + 1;
                a = b + 1;

                alpha = iData[a];

                if (alpha) {

                    gray = getGray(iData[r], iData[g], iData[b]);

                    idx0 = -1;
                    idx1 = -1;
                    d0 = Infinity;
                    d1 = Infinity;

                    for (pi = 0; pi < P; pi++) {

                        pv = selectedPalette[pi];
                        d = _abs(pv - gray);

                        if (d < d0) {

                            d1 = d0;
                            idx1 = idx0;
                            d0 = d;
                            idx0 = pi;
                        }
                        else if (d < d1) {

                            d1 = d;
                            idx1 = pi;
                        }

                        if (pi && d >= d1) break;
                    }

                    total = d0 + d1;
                    propensity = total - d0;
                    test = rnd[++rndCursor] * total;
                    chosen = (test < propensity) ? selectedPalette[idx0] : selectedPalette[idx1];

                    oData[r] = chosen;
                    oData[g] = chosen;
                    oData[b] = chosen;
                    oData[a] = alpha;
                }
                else {

                    ++rndCursor;
                    oData[r] = iData[r];
                    oData[g] = iData[g];
                    oData[b] = iData[b];
                    oData[a] = 0;
                }
            }

            setLastUsedReducePalette(palette);

            if (lineOut) processResults(output, input, 1 - opacity);
            else processResults(cache.work, output, opacity);

            return;
        }

        if (isArrayPalette) {

            const name = palette.join(ARG_SPLITTER);

            let selectedPalette = predefinedPalette[name];

            let i, iz, a, alpha, r, g, b, ok,
                ILi, IAi, IBi, idx0, idx1, d0, d1,
                total, propensity, test, chosen;

            if (!selectedPalette) {

                selectedPalette = [];

                let eR, eG, eB, PLi, PAi, PBi;

                for (i = 0, iz = palette.length; i < iz; i++) {

                    [eR, eG, eB] = colorEngine.extractRGBfromColorString(palette[i]);

                    ok = colorEngine.getOkValsForRgb(eR, eG, eB, libs);
                    PLi = (ok[0] * 100) | 0;
                    PAi = ((ok[1] + 0.4) * 125) | 0;
                    PBi = ((ok[2] + 0.4) * 125) | 0;

                    selectedPalette.push([0, eR, eG, eB, PLi, PAi, PBi]);
                }
                predefinedPalette[name] = selectedPalette;
            }

            for (i = 0; i < len; i += 4) {

                r = i;
                g = r + 1;
                b = g + 1;
                a = b + 1;

                alpha = iData[a];

                if (alpha) {

                    ok = colorEngine.getOkValsForRgb(iData[r], iData[g], iData[b], libs);

                    ILi = (ok[0] * 100) | 0;
                    IAi = ((ok[1] + 0.4) * 125) | 0;
                    IBi = ((ok[2] + 0.4) * 125) | 0;

                    [idx0, idx1, d0, d1] = bestTwoPaletteIndices(ILi, IAi, IBi, selectedPalette);

                    total = d0 + d1;
                    propensity = total - d0;
                    test = rnd[++rndCursor] * total;

                    chosen = (test < propensity) ? selectedPalette[idx0] : selectedPalette[idx1];

                    oData[r] = chosen[1];
                    oData[g] = chosen[2];
                    oData[b] = chosen[3];
                    oData[a] = alpha;

                }
                else {

                    ++rndCursor;
                    oData[r] = iData[r];
                    oData[g] = iData[g];
                    oData[b] = iData[b];
                    oData[a] = 0;
                }
            }

            setLastUsedReducePalette(palette);

            if (lineOut) processResults(output, input, 1 - opacity);
            else processResults(cache.work, output, opacity);

            return;
        }

        const metadata = new Map(),
            seen = [],
            selectedPalette = [];

        let i, iz, a, r, g, b, rgbIndex, row, ok, ILi, IAi, IBi, red, green, blue, alpha,
            best2, j, jz, p, dL, dA, dB, dsq, idx, idx0, idx1,
            d0, d1, total, propensity, rec, test, chosen;

        for (i = 0; i < len; i += 4) {

            a = i + 3;

            if (!iData[a]) continue;

            red = iData[i];
            green = iData[i + 1];
            blue = iData[i + 2];
            rgbIndex = getRGBIndex(red, green, blue);

            row = metadata.get(rgbIndex);

            if (row) row[0] += 1;
            else {

                ok = colorEngine.getOkValsForRgb(red, green, blue, libs);
                ILi = (ok[0] * 100) | 0;
                IAi = ((ok[1] + 0.4) * 125) | 0;
                IBi = ((ok[2] + 0.4) * 125) | 0;

                metadata.set(rgbIndex, [1, red, green, blue, ILi, IAi, IBi]);

                seen.push(rgbIndex);
            }
        }

        if (seen.length) {

            const filteredSeen = seen.filter(item => metadata.get(item)[0] > 1);
            filteredSeen.sort((item1, item2) => metadata.get(item2)[0] - metadata.get(item1)[0]);

            const mapped = minimumColorDistance * 0.01,
                minDist2 = mapped * mapped;

            selectedPalette.push(requestArray(...metadata.get(filteredSeen[0])));

            for (i = 1, iz = filteredSeen.length; i < iz; i++) {

                if (selectedPalette.length >= palette) break;

                row = metadata.get(filteredSeen[i]);

                best2 = Infinity;

                for (j = 0, jz = selectedPalette.length; j < jz; j++) {

                    p = selectedPalette[j];
                    dL = row[4] - p[4];
                    dA = row[5] - p[5];
                    dB = row[6] - p[6];
                    dsq = (dL * dL) + (dA * dA) + (dB * dB);

                    if (dsq < best2) best2 = dsq;
                }

                if (best2 > minDist2) selectedPalette.push(requestArray(...row));
            }

            if (selectedPalette.length === 1 && filteredSeen.length > 2) selectedPalette.push(requestArray(...metadata.get(filteredSeen[1])));

            setLastUsedReducePalette(selectedPalette.map(item => `rgb(${item[1]} ${item[2]} ${item[3]})`));

            for (i = 0, iz = seen.length; i < iz; i++) {

                idx = seen[i];
                row = metadata.get(idx);

                [idx0, idx1, d0, d1] = bestTwoPaletteIndices(row[4], row[5], row[6], selectedPalette);

                total = d0 + d1;
                propensity = total - d0;

                row[0] = total;
                row[1] = propensity;
                row[2] = selectedPalette[idx0];
                row[3] = selectedPalette[idx1];
            }

            for (i = 0; i < len; i += 4) {

                r = i;
                g = r + 1;
                b = g + 1;
                a = b + 1;

                alpha = iData[a];

                if (alpha) {

                    rgbIndex = getRGBIndex(iData[r], iData[g], iData[b]);

                    rec = metadata.get(rgbIndex);
                    total = rec[0];

                    propensity = rec[1];
                    test = rnd[++rndCursor] * total;
                    chosen = (test < propensity) ? rec[2] : rec[3];

                    oData[r] = chosen[1];
                    oData[g] = chosen[2];
                    oData[b] = chosen[3];
                    oData[a] = alpha;

                } else {

                    ++rndCursor;
                    oData[r] = iData[r];
                    oData[g] = iData[g];
                    oData[b] = iData[b];
                    oData[a] = 0;
                }
            }

            releaseArray(...selectedPalette);
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [ROTATE_HUE]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer,  oData.byteOffset,  oData.byteLength >>> 2);

        const {
            opacity = 1,
            lineOut,
        } = requirements;

        let { angle = 0 } = requirements;

        angle = ((angle % 360) + 360) % 360;

        if (angle === 0) out32.set(src32);
        else {

            const libs = colorEngine.getRgbOkCache(),
                getOk = colorEngine.getOkValsForRgb,
                toRgb = colorEngine.getRgbValsForOklch;

            const CHROMA_EPS = 1e-4;

            let rgba, r, g, b, a, ok, L, C, H, rgb;

            for (let p = 0, pz = src32.length | 0; p < pz; p++) {

                rgba = src32[p];

                a = rgba >>> 24;

                if (a === 0) {

                    out32[p] = rgba;
                    continue;
                }

                r = rgba & 0xFF;
                g = (rgba >>> 8) & 0xFF;
                b = (rgba >>> 16) & 0xFF;

                ok = getOk(r, g, b, libs);

                L = ok[0];
                C = ok[3];

                if (C < CHROMA_EPS) {

                    out32[p] = rgba;
                    continue;
                }

                H = ok[4] + angle;
                if (H >= 360) H -= 360;

                rgb = toRgb(L, C, H, libs);

                out32[p] = ((a << 24) | (rgb[2] << 16) | (rgb[1] << 8) | rgb[0]) >>> 0;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },

    [SET_CHANNEL_TO_LEVEL]: function (requirements) {

        const [input, output] = getInputAndOutputLines(requirements);

        const iData = input.data,
            oData = output.data;

        const src32 = new Uint32Array(iData.buffer, iData.byteOffset, iData.byteLength >>> 2),
            out32 = new Uint32Array(oData.buffer, oData.byteOffset, oData.byteLength >>> 2);

        const {
            opacity = 1,
            includeRed = false,
            includeGreen = false,
            includeBlue = false,
            includeAlpha = false,
            level = 0,
            lineOut,
        } = requirements;

        const L = level < 0 ? 0 : level > 255 ? 255 : (level | 0);

        const Rm = includeRed   ? 0x000000FF : 0,
            Gm = includeGreen ? 0x0000FF00 : 0,
            Bm = includeBlue  ? 0x00FF0000 : 0,
            Am = includeAlpha ? 0xFF000000 : 0;

        const clearMask = (~(Rm | Gm | Bm | Am)) >>> 0;

        const setMask = (includeRed ? (L <<  0) : 0) | (includeGreen ? (L <<  8) : 0) | (includeBlue  ? (L << 16) : 0) | (includeAlpha ? ((L & 255) << 24) : 0);

        if ((Rm | Gm | Bm | Am) === 0) {

            for (let p = 0; p < src32.length; p++) {

                out32[p] = src32[p];
            }
        }
        else if ((Rm | Gm | Bm | Am) === 0xFFFFFFFF >>> 0) {

            const constantPixel = setMask >>> 0;

            for (let p = 0; p < out32.length; p++) {

                out32[p] = constantPixel;
            }
        }
        else {

            for (let p = 0, src; p < src32.length; p++) {

                src = src32[p];
                out32[p] = (src & clearMask) | setMask;
            }
        }

        if (lineOut) processResults(output, input, 1 - opacity);
        else processResults(cache.work, output, opacity);
    },