/* 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