// 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,
				(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: [
			(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 = [];
					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: [
			(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: [
			(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: [
			(require, module, exports) => {
				var GIFEncoder, renderFrame;
				GIFEncoder = require("./GIFEncoder.js");
				renderFrame = (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 = (() => {
							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 = (event) => renderFrame(event.data);
			},
			{ "./GIFEncoder.js": 1 },
		],
	},
	{},
	[4],
);
//# sourceMappingURL=gif.worker.js.map
