/* eslint-disable */

// gif.js 0.2.0 - https://github.com/jnordberg/gif.js
(function (f) {
  if (typeof exports === 'object' && typeof module !== 'undefined') {
    module.exports = f();
  } else if (typeof define === 'function' && define.amd) {
    define([], f);
  } else {
    var g;
    if (typeof window !== 'undefined') {
      g = window;
    } else if (typeof global !== 'undefined') {
      g = global;
    } else if (typeof self !== 'undefined') {
      g = self;
    } else {
      g = this;
    }
    g.GIF = f();
  }
})(function () {
  var define, module, exports;
  return (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) {
          function EventEmitter() {
            this._events = this._events || {};
            this._maxListeners = this._maxListeners || undefined;
          }
          module.exports = EventEmitter;
          EventEmitter.EventEmitter = EventEmitter;
          EventEmitter.prototype._events = undefined;
          EventEmitter.prototype._maxListeners = undefined;
          EventEmitter.defaultMaxListeners = 10;
          EventEmitter.prototype.setMaxListeners = function (n) {
            if (!isNumber(n) || n < 0 || isNaN(n))
              throw TypeError('n must be a positive number');
            this._maxListeners = n;
            return this;
          };
          EventEmitter.prototype.emit = function (type) {
            var er, handler, len, args, i, listeners;
            if (!this._events) this._events = {};
            if (type === 'error') {
              if (
                !this._events.error ||
                (isObject(this._events.error) && !this._events.error.length)
              ) {
                er = arguments[1];
                if (er instanceof Error) {
                  throw er;
                } else {
                  var err = new Error(
                    'Uncaught, unspecified "error" event. (' + er + ')'
                  );
                  err.context = er;
                  throw err;
                }
              }
            }
            handler = this._events[type];
            if (isUndefined(handler)) return false;
            if (isFunction(handler)) {
              switch (arguments.length) {
                case 1:
                  handler.call(this);
                  break;
                case 2:
                  handler.call(this, arguments[1]);
                  break;
                case 3:
                  handler.call(this, arguments[1], arguments[2]);
                  break;
                default:
                  args = Array.prototype.slice.call(arguments, 1);
                  handler.apply(this, args);
              }
            } else if (isObject(handler)) {
              args = Array.prototype.slice.call(arguments, 1);
              listeners = handler.slice();
              len = listeners.length;
              for (i = 0; i < len; i++) listeners[i].apply(this, args);
            }
            return true;
          };
          EventEmitter.prototype.addListener = function (type, listener) {
            var m;
            if (!isFunction(listener))
              throw TypeError('listener must be a function');
            if (!this._events) this._events = {};
            if (this._events.newListener)
              this.emit(
                'newListener',
                type,
                isFunction(listener.listener) ? listener.listener : listener
              );
            if (!this._events[type]) this._events[type] = listener;
            else if (isObject(this._events[type]))
              this._events[type].push(listener);
            else this._events[type] = [this._events[type], listener];
            if (isObject(this._events[type]) && !this._events[type].warned) {
              if (!isUndefined(this._maxListeners)) {
                m = this._maxListeners;
              } else {
                m = EventEmitter.defaultMaxListeners;
              }
              if (m && m > 0 && this._events[type].length > m) {
                this._events[type].warned = true;
                console.error(
                  '(node) warning: possible EventEmitter memory ' +
                    'leak detected. %d listeners added. ' +
                    'Use emitter.setMaxListeners() to increase limit.',
                  this._events[type].length
                );
                if (typeof console.trace === 'function') {
                  console.trace();
                }
              }
            }
            return this;
          };
          EventEmitter.prototype.on = EventEmitter.prototype.addListener;
          EventEmitter.prototype.once = function (type, listener) {
            if (!isFunction(listener))
              throw TypeError('listener must be a function');
            var fired = false;

            function g() {
              this.removeListener(type, g);
              if (!fired) {
                fired = true;
                listener.apply(this, arguments);
              }
            }
            g.listener = listener;
            this.on(type, g);
            return this;
          };
          EventEmitter.prototype.removeListener = function (type, listener) {
            var list, position, length, i;
            if (!isFunction(listener))
              throw TypeError('listener must be a function');
            if (!this._events || !this._events[type]) return this;
            list = this._events[type];
            length = list.length;
            position = -1;
            if (
              list === listener ||
              (isFunction(list.listener) && list.listener === listener)
            ) {
              delete this._events[type];
              if (this._events.removeListener)
                this.emit('removeListener', type, listener);
            } else if (isObject(list)) {
              for (i = length; i-- > 0; ) {
                if (
                  list[i] === listener ||
                  (list[i].listener && list[i].listener === listener)
                ) {
                  position = i;
                  break;
                }
              }
              if (position < 0) return this;
              if (list.length === 1) {
                list.length = 0;
                delete this._events[type];
              } else {
                list.splice(position, 1);
              }
              if (this._events.removeListener)
                this.emit('removeListener', type, listener);
            }
            return this;
          };
          EventEmitter.prototype.removeAllListeners = function (type) {
            var key, listeners;
            if (!this._events) return this;
            if (!this._events.removeListener) {
              if (arguments.length === 0) this._events = {};
              else if (this._events[type]) delete this._events[type];
              return this;
            }
            if (arguments.length === 0) {
              for (key in this._events) {
                if (key === 'removeListener') continue;
                this.removeAllListeners(key);
              }
              this.removeAllListeners('removeListener');
              this._events = {};
              return this;
            }
            listeners = this._events[type];
            if (isFunction(listeners)) {
              this.removeListener(type, listeners);
            } else if (listeners) {
              while (listeners.length)
                this.removeListener(type, listeners[listeners.length - 1]);
            }
            delete this._events[type];
            return this;
          };
          EventEmitter.prototype.listeners = function (type) {
            var ret;
            if (!this._events || !this._events[type]) ret = [];
            else if (isFunction(this._events[type])) ret = [this._events[type]];
            else ret = this._events[type].slice();
            return ret;
          };
          EventEmitter.prototype.listenerCount = function (type) {
            if (this._events) {
              var evlistener = this._events[type];
              if (isFunction(evlistener)) return 1;
              else if (evlistener) return evlistener.length;
            }
            return 0;
          };
          EventEmitter.listenerCount = function (emitter, type) {
            return emitter.listenerCount(type);
          };

          function isFunction(arg) {
            return typeof arg === 'function';
          }

          function isNumber(arg) {
            return typeof arg === 'number';
          }

          function isObject(arg) {
            return typeof arg === 'object' && arg !== null;
          }

          function isUndefined(arg) {
            return arg === void 0;
          }
        },
        {},
      ],
      2: [
        function (require, module, exports) {
          var UA, browser, mode, platform, ua;
          ua = navigator.userAgent.toLowerCase();
          platform = navigator.platform.toLowerCase();
          UA = ua.match(
            /(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/
          ) || [null, 'unknown', 0];
          mode = UA[1] === 'ie' && document.documentMode;
          browser = {
            name: UA[1] === 'version' ? UA[3] : UA[1],
            version:
              mode || parseFloat(UA[1] === 'opera' && UA[4] ? UA[4] : UA[2]),
            platform: {
              name: ua.match(/ip(?:ad|od|hone)/)
                ? 'ios'
                : (ua.match(/(?:webos|android)/) ||
                    platform.match(/mac|win|linux/) || ['other'])[0],
            },
          };
          browser[browser.name] = true;
          browser[browser.name + parseInt(browser.version, 10)] = true;
          browser.platform[browser.platform.name] = true;
          module.exports = browser;
        },
        {},
      ],
      3: [
        function (require, module, exports) {
          var EventEmitter,
            GIF,
            browser,
            extend = function (child, parent) {
              for (var key in parent) {
                if (hasProp.call(parent, key)) child[key] = parent[key];
              }

              function ctor() {
                this.constructor = child;
              }
              ctor.prototype = parent.prototype;
              child.prototype = new ctor();
              child.__super__ = parent.prototype;
              return child;
            },
            hasProp = {}.hasOwnProperty,
            indexOf =
              [].indexOf ||
              function (item) {
                for (var i = 0, l = this.length; i < l; i++) {
                  if (i in this && this[i] === item) return i;
                }
                return -1;
              },
            slice = [].slice;
          EventEmitter = require('events').EventEmitter;
          browser = require('./browser.coffee');
          GIF = (function (superClass) {
            var defaults, frameDefaults;
            extend(GIF, superClass);
            defaults = {
              workerScript: 'gif.worker.js',
              workers: 2,
              repeat: 0,
              background: '#fff',
              quality: 10,
              width: null,
              height: null,
              transparent: null,
              debug: false,
              dither: false,
            };
            frameDefaults = {
              delay: 500,
              copy: false,
            };

            function GIF(options) {
              var base, key, value;
              this.running = false;
              this.options = {};
              this.frames = [];
              this.freeWorkers = [];
              this.activeWorkers = [];
              this.setOptions(options);
              for (key in defaults) {
                value = defaults[key];
                if ((base = this.options)[key] == null) {
                  base[key] = value;
                }
              }
            }
            GIF.prototype.setOption = function (key, value) {
              this.options[key] = value;
              if (
                this._canvas != null &&
                (key === 'width' || key === 'height')
              ) {
                return (this._canvas[key] = value);
              }
            };
            GIF.prototype.setOptions = function (options) {
              var key, results, value;
              results = [];
              for (key in options) {
                if (!hasProp.call(options, key)) continue;
                value = options[key];
                results.push(this.setOption(key, value));
              }
              return results;
            };
            GIF.prototype.addFrame = function (image, options) {
              var frame, key;
              if (options == null) {
                options = {};
              }
              frame = {};
              frame.transparent = this.options.transparent;
              for (key in frameDefaults) {
                frame[key] = options[key] || frameDefaults[key];
              }
              if (this.options.width == null) {
                this.setOption('width', image.width);
              }
              if (this.options.height == null) {
                this.setOption('height', image.height);
              }
              if (
                typeof ImageData !== 'undefined' &&
                ImageData !== null &&
                image instanceof ImageData
              ) {
                frame.data = image.data;
              } else if (
                (typeof CanvasRenderingContext2D !== 'undefined' &&
                  CanvasRenderingContext2D !== null &&
                  image instanceof CanvasRenderingContext2D) ||
                (typeof WebGLRenderingContext !== 'undefined' &&
                  WebGLRenderingContext !== null &&
                  image instanceof WebGLRenderingContext)
              ) {
                if (options.copy) {
                  frame.data = this.getContextData(image);
                } else {
                  frame.context = image;
                }
              } else if (image.childNodes != null) {
                if (options.copy) {
                  frame.data = this.getImageData(image);
                } else {
                  frame.image = image;
                }
              } else {
                throw new Error('Invalid image');
              }
              return this.frames.push(frame);
            };
            GIF.prototype.render = function () {
              var i, j, numWorkers, ref;
              if (this.running) {
                throw new Error('Already running');
              }
              if (this.options.width == null || this.options.height == null) {
                throw new Error(
                  'Width and height must be set prior to rendering'
                );
              }
              this.running = true;
              this.nextFrame = 0;
              this.finishedFrames = 0;
              this.imageParts = function () {
                var j, ref, results;
                results = [];
                for (
                  i = j = 0, ref = this.frames.length;
                  0 <= ref ? j < ref : j > ref;
                  i = 0 <= ref ? ++j : --j
                ) {
                  results.push(null);
                }
                return results;
              }.call(this);
              numWorkers = this.spawnWorkers();
              if (this.options.globalPalette === true) {
                this.renderNextFrame();
              } else {
                for (
                  i = j = 0, ref = numWorkers;
                  0 <= ref ? j < ref : j > ref;
                  i = 0 <= ref ? ++j : --j
                ) {
                  this.renderNextFrame();
                }
              }
              this.emit('start');
              return this.emit('progress', 0);
            };
            GIF.prototype.abort = function () {
              var worker;
              while (true) {
                worker = this.activeWorkers.shift();
                if (worker == null) {
                  break;
                }
                this.log('killing active worker');
                worker.terminate();
              }
              this.running = false;
              return this.emit('abort');
            };
            GIF.prototype.spawnWorkers = function () {
              var j, numWorkers, ref, results;
              numWorkers = Math.min(this.options.workers, this.frames.length);
              (function () {
                results = [];
                for (
                  var j = (ref = this.freeWorkers.length);
                  ref <= numWorkers ? j < numWorkers : j > numWorkers;
                  ref <= numWorkers ? j++ : j--
                ) {
                  results.push(j);
                }
                return results;
              }
                .apply(this)
                .forEach(
                  (function (_this) {
                    return function (i) {
                      var worker;
                      _this.log('spawning worker ' + i);
                      worker = new Worker(_this.options.workerScript);
                      worker.onmessage = function (event) {
                        _this.activeWorkers.splice(
                          _this.activeWorkers.indexOf(worker),
                          1
                        );
                        _this.freeWorkers.push(worker);
                        return _this.frameFinished(event.data);
                      };
                      return _this.freeWorkers.push(worker);
                    };
                  })(this)
                ));
              return numWorkers;
            };
            GIF.prototype.frameFinished = function (frame) {
              var i, j, ref;
              this.log(
                'frame ' +
                  frame.index +
                  ' finished - ' +
                  this.activeWorkers.length +
                  ' active'
              );
              this.finishedFrames++;
              this.emit('progress', this.finishedFrames / this.frames.length);
              this.imageParts[frame.index] = frame;
              if (this.options.globalPalette === true) {
                this.options.globalPalette = frame.globalPalette;
                this.log('global palette analyzed');
                if (this.frames.length > 2) {
                  for (
                    i = j = 1, ref = this.freeWorkers.length;
                    1 <= ref ? j < ref : j > ref;
                    i = 1 <= ref ? ++j : --j
                  ) {
                    this.renderNextFrame();
                  }
                }
              }
              if (indexOf.call(this.imageParts, null) >= 0) {
                return this.renderNextFrame();
              } else {
                return this.finishRendering();
              }
            };
            GIF.prototype.finishRendering = function () {
              var data,
                frame,
                i,
                image,
                j,
                k,
                l,
                len,
                len1,
                len2,
                len3,
                offset,
                page,
                ref,
                ref1,
                ref2;
              len = 0;
              ref = this.imageParts;
              for (j = 0, len1 = ref.length; j < len1; j++) {
                frame = ref[j];
                len += (frame.data.length - 1) * frame.pageSize + frame.cursor;
              }
              len += frame.pageSize - frame.cursor;
              this.log(
                'rendering finished - filesize ' + Math.round(len / 1e3) + 'kb'
              );
              data = new Uint8Array(len);
              offset = 0;
              ref1 = this.imageParts;
              for (k = 0, len2 = ref1.length; k < len2; k++) {
                frame = ref1[k];
                ref2 = frame.data;
                for (i = l = 0, len3 = ref2.length; l < len3; i = ++l) {
                  page = ref2[i];
                  data.set(page, offset);
                  if (i === frame.data.length - 1) {
                    offset += frame.cursor;
                  } else {
                    offset += frame.pageSize;
                  }
                }
              }
              image = new Blob([data], {
                type: 'image/gif',
              });
              return this.emit('finished', image, data);
            };
            GIF.prototype.renderNextFrame = function () {
              var frame, task, worker;
              if (this.freeWorkers.length === 0) {
                throw new Error('No free workers');
              }
              if (this.nextFrame >= this.frames.length) {
                return;
              }
              frame = this.frames[this.nextFrame++];
              worker = this.freeWorkers.shift();
              task = this.getTask(frame);
              this.log(
                'starting frame ' +
                  (task.index + 1) +
                  ' of ' +
                  this.frames.length
              );
              this.activeWorkers.push(worker);
              return worker.postMessage(task);
            };
            GIF.prototype.getContextData = function (ctx) {
              return ctx.getImageData(
                0,
                0,
                this.options.width,
                this.options.height
              ).data;
            };
            GIF.prototype.getImageData = function (image) {
              var ctx;
              if (this._canvas == null) {
                this._canvas = document.createElement('canvas');
                this._canvas.width = this.options.width;
                this._canvas.height = this.options.height;
              }
              ctx = this._canvas.getContext('2d');
              ctx.fillStyle = this.options.background;
              ctx.fillRect(0, 0, this.options.width, this.options.height);
              ctx.drawImage(image, 0, 0);
              return this.getContextData(ctx);
            };
            GIF.prototype.getTask = function (frame) {
              var index, task;
              index = this.frames.indexOf(frame);
              task = {
                index: index,
                last: index === this.frames.length - 1,
                delay: frame.delay,
                transparent: frame.transparent,
                width: this.options.width,
                height: this.options.height,
                quality: this.options.quality,
                dither: this.options.dither,
                globalPalette: this.options.globalPalette,
                repeat: this.options.repeat,
                canTransfer: browser.name === 'chrome',
              };
              if (frame.data != null) {
                task.data = frame.data;
              } else if (frame.context != null) {
                task.data = this.getContextData(frame.context);
              } else if (frame.image != null) {
                task.data = this.getImageData(frame.image);
              } else {
                throw new Error('Invalid frame');
              }
              return task;
            };
            GIF.prototype.log = function () {
              var args;
              args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
              if (!this.options.debug) {
                return;
              }
              return console.log.apply(console, args);
            };
            return GIF;
          })(EventEmitter);
          module.exports = GIF;
        },
        {
          './browser.coffee': 2,
          events: 1,
        },
      ],
    },
    {},
    [3]
  )(3);
});
//# sourceMappingURL=gif.js.map