/* eslint-disable */
// gif.worker.js 0.2.0 - https://github.com/jnordberg/gif.js
(function e(t, n, r) {
    function s(o, u) {
        if (!n[o]) {
            if (!t[o]) {
                var a = typeof require == "function" && require;
                if (!u && a) return a(o, !0);
                if (i) return i(o, !0);
                var f = new Error("Cannot find module '" + o + "'");
                throw f.code = "MODULE_NOT_FOUND", f
            }
            var l = n[o] = {
                exports: {}
            };
            t[o][0].call(l.exports, function(e) {
                var n = t[o][1][e];
                return s(n ? n : e)
            }, l, l.exports, e, t, n, r)
        }
        return n[o].exports
    }
    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++) s(r[o]);
    return s
})({
    1: [function(require, module, exports) {
        var NeuQuant = require("./TypedNeuQuant.js");
        var LZWEncoder = require("./LZWEncoder.js");

        function ByteArray() {
            this.page = -1;
            this.pages = [];
            this.newPage()
        }
        ByteArray.pageSize = 4096;
        ByteArray.charMap = {};
        for (var i = 0; i < 256; i++) ByteArray.charMap[i] = String.fromCharCode(i);
        ByteArray.prototype.newPage = function() {
            this.pages[++this.page] = new Uint8Array(ByteArray.pageSize);
            this.cursor = 0
        };
        ByteArray.prototype.getData = function() {
            var rv = "";
            for (var p = 0; p < this.pages.length; p++) {
                for (var i = 0; i < ByteArray.pageSize; i++) {
                    rv += ByteArray.charMap[this.pages[p][i]]
                }
            }
            return rv
        };
        ByteArray.prototype.writeByte = function(val) {
            if (this.cursor >= ByteArray.pageSize) this.newPage();
            this.pages[this.page][this.cursor++] = val
        };
        ByteArray.prototype.writeUTFBytes = function(string) {
            for (var l = string.length, i = 0; i < l; i++) this.writeByte(string.charCodeAt(i))
        };
        ByteArray.prototype.writeBytes = function(array, offset, length) {
            for (var l = length || array.length, i = offset || 0; i < l; i++) this.writeByte(array[i])
        };

        function GIFEncoder(width, height) {
            this.width = ~~width;
            this.height = ~~height;
            this.transparent = null;
            this.transIndex = 0;
            this.repeat = -1;
            this.delay = 0;
            this.image = null;
            this.pixels = null;
            this.indexedPixels = null;
            this.colorDepth = null;
            this.colorTab = null;
            this.neuQuant = null;
            this.usedEntry = new Array;
            this.palSize = 7;
            this.dispose = -1;
            this.firstFrame = true;
            this.sample = 10;
            this.dither = false;
            this.globalPalette = false;
            this.out = new ByteArray
        }
        GIFEncoder.prototype.setDelay = function(milliseconds) {
            this.delay = Math.round(milliseconds / 10)
        };
        GIFEncoder.prototype.setFrameRate = function(fps) {
            this.delay = Math.round(100 / fps)
        };
        GIFEncoder.prototype.setDispose = function(disposalCode) {
            if (disposalCode >= 0) this.dispose = disposalCode
        };
        GIFEncoder.prototype.setRepeat = function(repeat) {
            this.repeat = repeat
        };
        GIFEncoder.prototype.setTransparent = function(color) {
            this.transparent = color
        };
        GIFEncoder.prototype.addFrame = function(imageData) {
            this.image = imageData;
            this.colorTab = this.globalPalette && this.globalPalette.slice ? this.globalPalette : null;
            this.getImagePixels();
            this.analyzePixels();
            if (this.globalPalette === true) this.globalPalette = this.colorTab;
            if (this.firstFrame) {
                this.writeLSD();
                this.writePalette();
                if (this.repeat >= 0) {
                    this.writeNetscapeExt()
                }
            }
            this.writeGraphicCtrlExt();
            this.writeImageDesc();
            if (!this.firstFrame && !this.globalPalette) this.writePalette();
            this.writePixels();
            this.firstFrame = false
        };
        GIFEncoder.prototype.finish = function() {
            this.out.writeByte(59)
        };
        GIFEncoder.prototype.setQuality = function(quality) {
            if (quality < 1) quality = 1;
            this.sample = quality
        };
        GIFEncoder.prototype.setDither = function(dither) {
            if (dither === true) dither = "FloydSteinberg";
            this.dither = dither
        };
        GIFEncoder.prototype.setGlobalPalette = function(palette) {
            this.globalPalette = palette
        };
        GIFEncoder.prototype.getGlobalPalette = function() {
            return this.globalPalette && this.globalPalette.slice && this.globalPalette.slice(0) || this.globalPalette
        };
        GIFEncoder.prototype.writeHeader = function() {
            this.out.writeUTFBytes("GIF89a")
        };
        GIFEncoder.prototype.analyzePixels = function() {
            if (!this.colorTab) {
                this.neuQuant = new NeuQuant(this.pixels, this.sample);
                this.neuQuant.buildColormap();
                this.colorTab = this.neuQuant.getColormap()
            }
            if (this.dither) {
                this.ditherPixels(this.dither.replace("-serpentine", ""), this.dither.match(/-serpentine/) !== null)
            } else {
                this.indexPixels()
            }
            this.pixels = null;
            this.colorDepth = 8;
            this.palSize = 7;
            if (this.transparent !== null) {
                this.transIndex = this.findClosest(this.transparent, true)
            }
        };
        GIFEncoder.prototype.indexPixels = function(imgq) {
            var nPix = this.pixels.length / 3;
            this.indexedPixels = new Uint8Array(nPix);
            var k = 0;
            for (var j = 0; j < nPix; j++) {
                var index = this.findClosestRGB(this.pixels[k++] & 255, this.pixels[k++] & 255, this.pixels[k++] & 255);
                this.usedEntry[index] = true;
                this.indexedPixels[j] = index
            }
        };
        GIFEncoder.prototype.ditherPixels = function(kernel, serpentine) {
            var kernels = {
                FalseFloydSteinberg: [
                    [3 / 8, 1, 0],
                    [3 / 8, 0, 1],
                    [2 / 8, 1, 1]
                ],
                FloydSteinberg: [
                    [7 / 16, 1, 0],
                    [3 / 16, -1, 1],
                    [5 / 16, 0, 1],
                    [1 / 16, 1, 1]
                ],
                Stucki: [
                    [8 / 42, 1, 0],
                    [4 / 42, 2, 0],
                    [2 / 42, -2, 1],
                    [4 / 42, -1, 1],
                    [8 / 42, 0, 1],
                    [4 / 42, 1, 1],
                    [2 / 42, 2, 1],
                    [1 / 42, -2, 2],
                    [2 / 42, -1, 2],
                    [4 / 42, 0, 2],
                    [2 / 42, 1, 2],
                    [1 / 42, 2, 2]
                ],
                Atkinson: [
                    [1 / 8, 1, 0],
                    [1 / 8, 2, 0],
                    [1 / 8, -1, 1],
                    [1 / 8, 0, 1],
                    [1 / 8, 1, 1],
                    [1 / 8, 0, 2]
                ]
            };
            if (!kernel || !kernels[kernel]) {
                throw "Unknown dithering kernel: " + kernel
            }
            var ds = kernels[kernel];
            var index = 0,
                height = this.height,
                width = this.width,
                data = this.pixels;
            var direction = serpentine ? -1 : 1;
            this.indexedPixels = new Uint8Array(this.pixels.length / 3);
            for (var y = 0; y < height; y++) {
                if (serpentine) direction = direction * -1;
                for (var x = direction == 1 ? 0 : width - 1, xend = direction == 1 ? width : 0; x !== xend; x += direction) {
                    index = y * width + x;
                    var idx = index * 3;
                    var r1 = data[idx];
                    var g1 = data[idx + 1];
                    var b1 = data[idx + 2];
                    idx = this.findClosestRGB(r1, g1, b1);
                    this.usedEntry[idx] = true;
                    this.indexedPixels[index] = idx;
                    idx *= 3;
                    var r2 = this.colorTab[idx];
                    var g2 = this.colorTab[idx + 1];
                    var b2 = this.colorTab[idx + 2];
                    var er = r1 - r2;
                    var eg = g1 - g2;
                    var eb = b1 - b2;
                    for (var i = direction == 1 ? 0 : ds.length - 1, end = direction == 1 ? ds.length : 0; i !== end; i += direction) {
                        var x1 = ds[i][1];
                        var y1 = ds[i][2];
                        if (x1 + x >= 0 && x1 + x < width && y1 + y >= 0 && y1 + y < height) {
                            var d = ds[i][0];
                            idx = index + x1 + y1 * width;
                            idx *= 3;
                            data[idx] = Math.max(0, Math.min(255, data[idx] + er * d));
                            data[idx + 1] = Math.max(0, Math.min(255, data[idx + 1] + eg * d));
                            data[idx + 2] = Math.max(0, Math.min(255, data[idx + 2] + eb * d))
                        }
                    }
                }
            }
        };
        GIFEncoder.prototype.findClosest = function(c, used) {
            return this.findClosestRGB((c & 16711680) >> 16, (c & 65280) >> 8, c & 255, used)
        };
        GIFEncoder.prototype.findClosestRGB = function(r, g, b, used) {
            if (this.colorTab === null) return -1;
            if (this.neuQuant && !used) {
                return this.neuQuant.lookupRGB(r, g, b)
            }
            var c = b | g << 8 | r << 16;
            var minpos = 0;
            var dmin = 256 * 256 * 256;
            var len = this.colorTab.length;
            for (var i = 0, index = 0; i < len; index++) {
                var dr = r - (this.colorTab[i++] & 255);
                var dg = g - (this.colorTab[i++] & 255);
                var db = b - (this.colorTab[i++] & 255);
                var d = dr * dr + dg * dg + db * db;
                if ((!used || this.usedEntry[index]) && d < dmin) {
                    dmin = d;
                    minpos = index
                }
            }
            return minpos
        };
        GIFEncoder.prototype.getImagePixels = function() {
            var w = this.width;
            var h = this.height;
            this.pixels = new Uint8Array(w * h * 3);
            var data = this.image;
            var srcPos = 0;
            var count = 0;
            for (var i = 0; i < h; i++) {
                for (var j = 0; j < w; j++) {
                    this.pixels[count++] = data[srcPos++];
                    this.pixels[count++] = data[srcPos++];
                    this.pixels[count++] = data[srcPos++];
                    srcPos++
                }
            }
        };
        GIFEncoder.prototype.writeGraphicCtrlExt = function() {
            this.out.writeByte(33);
            this.out.writeByte(249);
            this.out.writeByte(4);
            var transp, disp;
            if (this.transparent === null) {
                transp = 0;
                disp = 0
            } else {
                transp = 1;
                disp = 2
            }
            if (this.dispose >= 0) {
                disp = dispose & 7
            }
            disp <<= 2;
            this.out.writeByte(0 | disp | 0 | transp);
            this.writeShort(this.delay);
            this.out.writeByte(this.transIndex);
            this.out.writeByte(0)
        };
        GIFEncoder.prototype.writeImageDesc = function() {
            this.out.writeByte(44);
            this.writeShort(0);
            this.writeShort(0);
            this.writeShort(this.width);
            this.writeShort(this.height);
            if (this.firstFrame || this.globalPalette) {
                this.out.writeByte(0)
            } else {
                this.out.writeByte(128 | 0 | 0 | 0 | this.palSize)
            }
        };
        GIFEncoder.prototype.writeLSD = function() {
            this.writeShort(this.width);
            this.writeShort(this.height);
            this.out.writeByte(128 | 112 | 0 | this.palSize);
            this.out.writeByte(0);
            this.out.writeByte(0)
        };
        GIFEncoder.prototype.writeNetscapeExt = function() {
            this.out.writeByte(33);
            this.out.writeByte(255);
            this.out.writeByte(11);
            this.out.writeUTFBytes("NETSCAPE2.0");
            this.out.writeByte(3);
            this.out.writeByte(1);
            this.writeShort(this.repeat);
            this.out.writeByte(0)
        };
        GIFEncoder.prototype.writePalette = function() {
            this.out.writeBytes(this.colorTab);
            var n = 3 * 256 - this.colorTab.length;
            for (var i = 0; i < n; i++) this.out.writeByte(0)
        };
        GIFEncoder.prototype.writeShort = function(pValue) {
            this.out.writeByte(pValue & 255);
            this.out.writeByte(pValue >> 8 & 255)
        };
        GIFEncoder.prototype.writePixels = function() {
            var enc = new LZWEncoder(this.width, this.height, this.indexedPixels, this.colorDepth);
            enc.encode(this.out)
        };
        GIFEncoder.prototype.stream = function() {
            return this.out
        };
        module.exports = GIFEncoder
    }, {
        "./LZWEncoder.js": 2,
        "./TypedNeuQuant.js": 3
    }],
    2: [function(require, module, exports) {
        var EOF = -1;
        var BITS = 12;
        var HSIZE = 5003;
        var masks = [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535];

        function LZWEncoder(width, height, pixels, colorDepth) {
            var initCodeSize = Math.max(2, colorDepth);
            var accum = new Uint8Array(256);
            var htab = new Int32Array(HSIZE);
            var codetab = new Int32Array(HSIZE);
            var cur_accum, cur_bits = 0;
            var a_count;
            var free_ent = 0;
            var maxcode;
            var clear_flg = false;
            var g_init_bits, ClearCode, EOFCode;

            function char_out(c, outs) {
                accum[a_count++] = c;
                if (a_count >= 254) flush_char(outs)
            }

            function cl_block(outs) {
                cl_hash(HSIZE);
                free_ent = ClearCode + 2;
                clear_flg = true;
                output(ClearCode, outs)
            }

            function cl_hash(hsize) {
                for (var i = 0; i < hsize; ++i) htab[i] = -1
            }

            function compress(init_bits, outs) {
                var fcode, c, i, ent, disp, hsize_reg, hshift;
                g_init_bits = init_bits;
                clear_flg = false;
                n_bits = g_init_bits;
                maxcode = MAXCODE(n_bits);
                ClearCode = 1 << init_bits - 1;
                EOFCode = ClearCode + 1;
                free_ent = ClearCode + 2;
                a_count = 0;
                ent = nextPixel();
                hshift = 0;
                for (fcode = HSIZE; fcode < 65536; fcode *= 2) ++hshift;
                hshift = 8 - hshift;
                hsize_reg = HSIZE;
                cl_hash(hsize_reg);
                output(ClearCode, outs);
                outer_loop: while ((c = nextPixel()) != EOF) {
                    fcode = (c << BITS) + ent;
                    i = c << hshift ^ ent;
                    if (htab[i] === fcode) {
                        ent = codetab[i];
                        continue
                    } else if (htab[i] >= 0) {
                        disp = hsize_reg - i;
                        if (i === 0) disp = 1;
                        do {
                            if ((i -= disp) < 0) i += hsize_reg;
                            if (htab[i] === fcode) {
                                ent = codetab[i];
                                continue outer_loop
                            }
                        } while (htab[i] >= 0)
                    }
                    output(ent, outs);
                    ent = c;
                    if (free_ent < 1 << BITS) {
                        codetab[i] = free_ent++;
                        htab[i] = fcode
                    } else {
                        cl_block(outs)
                    }
                }
                output(ent, outs);
                output(EOFCode, outs)
            }

            function encode(outs) {
                outs.writeByte(initCodeSize);
                remaining = width * height;
                curPixel = 0;
                compress(initCodeSize + 1, outs);
                outs.writeByte(0)
            }

            function flush_char(outs) {
                if (a_count > 0) {
                    outs.writeByte(a_count);
                    outs.writeBytes(accum, 0, a_count);
                    a_count = 0
                }
            }

            function MAXCODE(n_bits) {
                return (1 << n_bits) - 1
            }

            function nextPixel() {
                if (remaining === 0) return EOF;
                --remaining;
                var pix = pixels[curPixel++];
                return pix & 255
            }

            function output(code, outs) {
                cur_accum &= masks[cur_bits];
                if (cur_bits > 0) cur_accum |= code << cur_bits;
                else cur_accum = code;
                cur_bits += n_bits;
                while (cur_bits >= 8) {
                    char_out(cur_accum & 255, outs);
                    cur_accum >>= 8;
                    cur_bits -= 8
                }
                if (free_ent > maxcode || clear_flg) {
                    if (clear_flg) {
                        maxcode = MAXCODE(n_bits = g_init_bits);
                        clear_flg = false
                    } else {
                        ++n_bits;
                        if (n_bits == BITS) maxcode = 1 << BITS;
                        else maxcode = MAXCODE(n_bits)
                    }
                }
                if (code == EOFCode) {
                    while (cur_bits > 0) {
                        char_out(cur_accum & 255, outs);
                        cur_accum >>= 8;
                        cur_bits -= 8
                    }
                    flush_char(outs)
                }
            }
            this.encode = encode
        }
        module.exports = LZWEncoder
    }, {}],
    3: [function(require, module, exports) {
        var ncycles = 100;
        var netsize = 256;
        var maxnetpos = netsize - 1;
        var netbiasshift = 4;
        var intbiasshift = 16;
        var intbias = 1 << intbiasshift;
        var gammashift = 10;
        var gamma = 1 << gammashift;
        var betashift = 10;
        var beta = intbias >> betashift;
        var betagamma = intbias << gammashift - betashift;
        var initrad = netsize >> 3;
        var radiusbiasshift = 6;
        var radiusbias = 1 << radiusbiasshift;
        var initradius = initrad * radiusbias;
        var radiusdec = 30;
        var alphabiasshift = 10;
        var initalpha = 1 << alphabiasshift;
        var alphadec;
        var radbiasshift = 8;
        var radbias = 1 << radbiasshift;
        var alpharadbshift = alphabiasshift + radbiasshift;
        var alpharadbias = 1 << alpharadbshift;
        var prime1 = 499;
        var prime2 = 491;
        var prime3 = 487;
        var prime4 = 503;
        var minpicturebytes = 3 * prime4;

        function NeuQuant(pixels, samplefac) {
            var network;
            var netindex;
            var bias;
            var freq;
            var radpower;

            function init() {
                network = [];
                netindex = new Int32Array(256);
                bias = new Int32Array(netsize);
                freq = new Int32Array(netsize);
                radpower = new Int32Array(netsize >> 3);
                var i, v;
                for (i = 0; i < netsize; i++) {
                    v = (i << netbiasshift + 8) / netsize;
                    network[i] = new Float64Array([v, v, v, 0]);
                    freq[i] = intbias / netsize;
                    bias[i] = 0
                }
            }

            function unbiasnet() {
                for (var i = 0; i < netsize; i++) {
                    network[i][0] >>= netbiasshift;
                    network[i][1] >>= netbiasshift;
                    network[i][2] >>= netbiasshift;
                    network[i][3] = i
                }
            }

            function altersingle(alpha, i, b, g, r) {
                network[i][0] -= alpha * (network[i][0] - b) / initalpha;
                network[i][1] -= alpha * (network[i][1] - g) / initalpha;
                network[i][2] -= alpha * (network[i][2] - r) / initalpha
            }

            function alterneigh(radius, i, b, g, r) {
                var lo = Math.abs(i - radius);
                var hi = Math.min(i + radius, netsize);
                var j = i + 1;
                var k = i - 1;
                var m = 1;
                var p, a;
                while (j < hi || k > lo) {
                    a = radpower[m++];
                    if (j < hi) {
                        p = network[j++];
                        p[0] -= a * (p[0] - b) / alpharadbias;
                        p[1] -= a * (p[1] - g) / alpharadbias;
                        p[2] -= a * (p[2] - r) / alpharadbias
                    }
                    if (k > lo) {
                        p = network[k--];
                        p[0] -= a * (p[0] - b) / alpharadbias;
                        p[1] -= a * (p[1] - g) / alpharadbias;
                        p[2] -= a * (p[2] - r) / alpharadbias
                    }
                }
            }

            function contest(b, g, r) {
                var bestd = ~(1 << 31);
                var bestbiasd = bestd;
                var bestpos = -1;
                var bestbiaspos = bestpos;
                var i, n, dist, biasdist, betafreq;
                for (i = 0; i < netsize; i++) {
                    n = network[i];
                    dist = Math.abs(n[0] - b) + Math.abs(n[1] - g) + Math.abs(n[2] - r);
                    if (dist < bestd) {
                        bestd = dist;
                        bestpos = i
                    }
                    biasdist = dist - (bias[i] >> intbiasshift - netbiasshift);
                    if (biasdist < bestbiasd) {
                        bestbiasd = biasdist;
                        bestbiaspos = i
                    }
                    betafreq = freq[i] >> betashift;
                    freq[i] -= betafreq;
                    bias[i] += betafreq << gammashift
                }
                freq[bestpos] += beta;
                bias[bestpos] -= betagamma;
                return bestbiaspos
            }

            function inxbuild() {
                var i, j, p, q, smallpos, smallval, previouscol = 0,
                    startpos = 0;
                for (i = 0; i < netsize; i++) {
                    p = network[i];
                    smallpos = i;
                    smallval = p[1];
                    for (j = i + 1; j < netsize; j++) {
                        q = network[j];
                        if (q[1] < smallval) {
                            smallpos = j;
                            smallval = q[1]
                        }
                    }
                    q = network[smallpos];
                    if (i != smallpos) {
                        j = q[0];
                        q[0] = p[0];
                        p[0] = j;
                        j = q[1];
                        q[1] = p[1];
                        p[1] = j;
                        j = q[2];
                        q[2] = p[2];
                        p[2] = j;
                        j = q[3];
                        q[3] = p[3];
                        p[3] = j
                    }
                    if (smallval != previouscol) {
                        netindex[previouscol] = startpos + i >> 1;
                        for (j = previouscol + 1; j < smallval; j++) netindex[j] = i;
                        previouscol = smallval;
                        startpos = i
                    }
                }
                netindex[previouscol] = startpos + maxnetpos >> 1;
                for (j = previouscol + 1; j < 256; j++) netindex[j] = maxnetpos
            }

            function inxsearch(b, g, r) {
                var a, p, dist;
                var bestd = 1e3;
                var best = -1;
                var i = netindex[g];
                var j = i - 1;
                while (i < netsize || j >= 0) {
                    if (i < netsize) {
                        p = network[i];
                        dist = p[1] - g;
                        if (dist >= bestd) i = netsize;
                        else {
                            i++;
                            if (dist < 0) dist = -dist;
                            a = p[0] - b;
                            if (a < 0) a = -a;
                            dist += a;
                            if (dist < bestd) {
                                a = p[2] - r;
                                if (a < 0) a = -a;
                                dist += a;
                                if (dist < bestd) {
                                    bestd = dist;
                                    best = p[3]
                                }
                            }
                        }
                    }
                    if (j >= 0) {
                        p = network[j];
                        dist = g - p[1];
                        if (dist >= bestd) j = -1;
                        else {
                            j--;
                            if (dist < 0) dist = -dist;
                            a = p[0] - b;
                            if (a < 0) a = -a;
                            dist += a;
                            if (dist < bestd) {
                                a = p[2] - r;
                                if (a < 0) a = -a;
                                dist += a;
                                if (dist < bestd) {
                                    bestd = dist;
                                    best = p[3]
                                }
                            }
                        }
                    }
                }
                return best
            }

            function learn() {
                var i;
                var lengthcount = pixels.length;
                var alphadec = 30 + (samplefac - 1) / 3;
                var samplepixels = lengthcount / (3 * samplefac);
                var delta = ~~(samplepixels / ncycles);
                var alpha = initalpha;
                var radius = initradius;
                var rad = radius >> radiusbiasshift;
                if (rad <= 1) rad = 0;
                for (i = 0; i < rad; i++) radpower[i] = alpha * ((rad * rad - i * i) * radbias / (rad * rad));
                var step;
                if (lengthcount < minpicturebytes) {
                    samplefac = 1;
                    step = 3
                } else if (lengthcount % prime1 !== 0) {
                    step = 3 * prime1
                } else if (lengthcount % prime2 !== 0) {
                    step = 3 * prime2
                } else if (lengthcount % prime3 !== 0) {
                    step = 3 * prime3
                } else {
                    step = 3 * prime4
                }
                var b, g, r, j;
                var pix = 0;
                i = 0;
                while (i < samplepixels) {
                    b = (pixels[pix] & 255) << netbiasshift;
                    g = (pixels[pix + 1] & 255) << netbiasshift;
                    r = (pixels[pix + 2] & 255) << netbiasshift;
                    j = contest(b, g, r);
                    altersingle(alpha, j, b, g, r);
                    if (rad !== 0) alterneigh(rad, j, b, g, r);
                    pix += step;
                    if (pix >= lengthcount) pix -= lengthcount;
                    i++;
                    if (delta === 0) delta = 1;
                    if (i % delta === 0) {
                        alpha -= alpha / alphadec;
                        radius -= radius / radiusdec;
                        rad = radius >> radiusbiasshift;
                        if (rad <= 1) rad = 0;
                        for (j = 0; j < rad; j++) radpower[j] = alpha * ((rad * rad - j * j) * radbias / (rad * rad))
                    }
                }
            }

            function buildColormap() {
                init();
                learn();
                unbiasnet();
                inxbuild()
            }
            this.buildColormap = buildColormap;

            function getColormap() {
                var map = [];
                var index = [];
                for (var i = 0; i < netsize; i++) index[network[i][3]] = i;
                var k = 0;
                for (var l = 0; l < netsize; l++) {
                    var j = index[l];
                    map[k++] = network[j][0];
                    map[k++] = network[j][1];
                    map[k++] = network[j][2]
                }
                return map
            }
            this.getColormap = getColormap;
            this.lookupRGB = inxsearch
        }
        module.exports = NeuQuant
    }, {}],
    4: [function(require, module, exports) {
        var GIFEncoder, renderFrame;
        GIFEncoder = require("./GIFEncoder.js");
        renderFrame = function(frame) {
            var encoder, page, stream, transfer;
            encoder = new GIFEncoder(frame.width, frame.height);
            if (frame.index === 0) {
                encoder.writeHeader()
            } else {
                encoder.firstFrame = false
            }
            encoder.setTransparent(frame.transparent);
            encoder.setRepeat(frame.repeat);
            encoder.setDelay(frame.delay);
            encoder.setQuality(frame.quality);
            encoder.setDither(frame.dither);
            encoder.setGlobalPalette(frame.globalPalette);
            encoder.addFrame(frame.data);
            if (frame.last) {
                encoder.finish()
            }
            if (frame.globalPalette === true) {
                frame.globalPalette = encoder.getGlobalPalette()
            }
            stream = encoder.stream();
            frame.data = stream.pages;
            frame.cursor = stream.cursor;
            frame.pageSize = stream.constructor.pageSize;
            if (frame.canTransfer) {
                transfer = function() {
                    var i, len, ref, results;
                    ref = frame.data;
                    results = [];
                    for (i = 0, len = ref.length; i < len; i++) {
                        page = ref[i];
                        results.push(page.buffer)
                    }
                    return results
                }();
                return self.postMessage(frame, transfer)
            } else {
                return self.postMessage(frame)
            }
        };
        self.onmessage = function(event) {
            return renderFrame(event.data)
        }
    }, {
        "./GIFEncoder.js": 1
    }]
}, {}, [4]);
//# sourceMappingURL=gif.worker.js.map