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