text:
// If you use this as a template, update the copyright with your own name.

// Sample Node-RED node file

module.exports = function(RED) {
    "use strict";
    // require any external libraries we may need....
    //var foo = require("foo-library");
    var htmlToText = require('html-to-text');
    var emojiStrip = require('emoji-strip');
    const emojiRegex = require('emoji-regex');
    var emoji_replace = require('emoji-replace');
    // The main node definition - most things happen in here
    function HtmltotextWatsonConversation(n) {
        // Create a RED node
        RED.nodes.createNode(this,n);

        // Store local copies of the node configuration (as defined in the .html)
        this.topic = n.topic;

        // copy "this" object in case we need it in context of callbacks of other functions.
        var node = this;

        // Do whatever you need to do in here - declare callbacks etc
        // Note: this sample doesn't do anything much - it will only send
        // this message once at startup...
        // Look at other real nodes for some better ideas of what to do....
        var msg = {};
        msg.topic = this.topic;
        msg.payload = "Hello world !"

        // send out the message to the rest of the workspace.
        // ... this message will get sent at startup so you may not see it in a debug node.
        this.send(msg);

        // respond to inputs....
        this.on('input', function (msg) {
            //node.warn("I saw a payload: "+msg.payload);
            // in this example just send it straight on... should process it here really
            //node.send(msg);
            //var originalPayload = msg.payload;

            //if(msg.payload.output.text[0]!=null){
             //   console.log(msg.payload.output.text[0]);
            //}
            //msg.payload = {chatId : msg.telegramMsg.chat_id,
             //   type : "message",
              //  content : msg.payload.output.text[0]};

            //console.log("msg output init : "+msg.payload.output.text[0]);
            var msgToTranslateToText = msg.payload.output.text[0];
            //console.log("msgToTranslateToText: "+msgToTranslateToText);
            var text = htmlToText.fromString(msgToTranslateToText, {
                wordwrap: 1300
            });
            //console.log("msgToTranslateToText after htmml converter: "+msgToTranslateToText);
            var newtext = emojiStrip(text);

            //console.log("msgToTranslateToText after emojiStrip: "+newtext);
            newtext = newtext.replace("/(]+)>)/ig", "");
            //console.log("msgToTranslateToText after regex: "+newtext);

            var finalText = emoji_replace(newtext);
            msg.payload.output.text[0] = emojiStrip(finalText);

            //console.log("msg output final : "+msg.payload.output.text[0]);
            //msg.payload = originalPayload;

            //console.log(JSON.stringify(msg));
            node.send(msg);
        });

        this.on("close", function() {
            // Called when the node is shutdown - eg on redeploy.
            // Allows ports to be closed, connections dropped etc.
            // eg: node.client.disconnect();
        });
    }

    // Register the node by name. This must be called before overriding any of the
    // Node functions.
    RED.nodes.registerType("HtmltotextWatsonConversation",HtmltotextWatsonConversation);

}


text:
package com.tirthal.learning.helloworld.greeting;

/**
 * Sample greeting service interface
 *
 * @author tirthalp
 *
 */
public interface GreetingService {

	public void sayHello(Message msg);

}

redpajama_set_name: RedPajamaGithub


text:
package mclab.ide.refactoring;

import java.io.IOException;
import java.util.Map;

import mclab.ide.common.TextRange;
import mclint.MatlabProgram;
import mclint.refactoring.Refactoring;
import mclint.refactoring.RefactoringContext;

public class RemoveRedundantEvalTool extends RefactoringTool {
  protected Refactoring createRefactoring(MatlabProgram program, TextRange selection,
      Map<String, String> extraArgs) {
    return new RemoveRedundantEval(
        RefactoringContext.create(program.getProject()),
        program.parse());
  }

  public static void main(String[] args) throws IOException {
    new RemoveRedundantEvalTool().run(args);
  }
}


text:
**pré-requis :**

install typescript & tools

> npm install -g typescript typings

**development :**

execute

> typings install

in this folder to install types definitions (git ignored)

----

**build :**

execute

> tsc

in this folder to produce js files

**tests :**

open *test.html* in a browser


text:
**PNG optimizer, similar to OptiPNG**

[![npm version](https://img.shields.io/npm/v/jspngopt.svg)](https://www.npmjs.com/package/jspngopt)
[![Travis build status](https://api.travis-ci.org/gagern/jspngopt.svg?branch=master)](https://travis-ci.org/gagern/jspngopt)

`jspngopt` is a tool which tries to reduce the file size of a PNG file by

* removing the alpha channel of an opaque image
* converting a grayscale-only image to a grayscale color mode
* trying out different pixel prediction filters
* trying out different zlib compression parameter combinations

This is very similar to the [OptiPNG](http://optipng.sourceforge.net/) tool.
However, there is no shared code, and this implementation is written
*completely in JavaScript*. It will usually make use of the
[zlib bindings](https://nodejs.org/api/zlib.html) provided by node.js,
making use of the performance of native code there.
But it is also possible to use [pako](http://nodeca.github.io/pako/)
or similar libraries to provide a portable all-JavaScript setup.
Using a fixed version of pako on node.js will ensure reproducible results,
but may result in slightly larger files compared to the latest native zlib.

## Installation

On node.js, simply do

```sh
npm install jspngopt
```

A version which supports browserify is planned.
If you need things packaged for some other environment,
please file a ticket explaining your setup.

## Command-line usage

The command line interface of `jspngopt` is intended to be
mostly compatible with the one from `optipng`.
But as this project is in the early stages of development,
currently the only thing accepted on the command line is a list of file names,
which will be optimized with the default settings,
the results overwriting the input files if there was a size reduction.

## API

The central element of the API is the `Optimizer` object.

```js
var jspngopt = require("jspngopt");
var opt = new jspngopt.Optimizer();
var optimized = opt.bufferSync(unoptimized);
```

### Options

The `Optimizer` constructor takes an `options` dictionary.
It may contain the following elements:

* **matrices:** An array of objects, each of which describes a collection of
  possible compression parameters. The keys of each such objects are the same
  described below for parameters, while the values are arrays listing all the
  values which should be tried for a given parameter. The default corresponds
  to the default of `optipng`.
* **pako:** The `pako` module, as returned from `require("pako")`.
  Setting this option will use `pako` instead of `zlib`,
  ensuring reproducible results but possibly sacrificing performance
  and compression rate.
* **deflateSync:** A function which is functionally equivalent
  to `zlib.deflateSync` and which should be used in its stead.
* **maxIdatLength:** Maximal size of an `IDAT` chunk, defaults to `0x7fffffff`.
  This is the length of the raw data payload, excluding header and checksum.
* **log:** Function to call when logging output (at `verbosity` > 0).
  Defaults to `console.log`.
* **verbosity:** Amount of information printed during processing.
  The default of 0 avoids all logging.
  With a setting of 1, the best parameter combination will get printed.
  At a setting of 2, all the parameter combinations will get printed.

### Parameters

Each parameter combination is described by the following numbers:

* **filters:** Which filters to try. Numbers 0 through 4 correspond to the
  filters *None* through *Paeth* described in the PNG specification.
  Filter 5 corresponds to an adaptive choice of filters which minimizes
  the sum of the absolute values in each row.
  Default: `[0, 5]`.
* **interlace:** 0 disables interlacing, while 1 will eventually enable
  Adam7 interlacing. Right now interlacing is not supported yet.
  Default: `[0]`.
* **windowBits:** Base-two logarithm of the size of the sliding window
  used to find redundant data.
  Valid values are in the range from 8 through 15.
  Default: `[15]`.
* **level:** Compression level, in the range from 0 (no compression)
  to 9 (best compression).
  Default: `[9]`.
* **memLevel:** Memory usage level, from 1 (little memory) to 9 (large memory).
  Default: `[8, 9]`.
* **strategy:** Compression strategy.
  * 0 is the `DEFAULT_STRATEGY` used for generic data.
  * 1 is `FILTERED`, optimized for the fact that numbers are likely small.
  * 2 is `HUFFMANN_ONLY` to not match duplicates at all.
  * 3 is `RLE`, performing only run-length encoding.
  * 4 is `FIXED` uses a fixed Huffmann coding table.

  Default: `[0, 1, 2, 3]`.

### Methods of Optimizer instances

#### bufferSync(Buffer) → Buffer

Takes the content of a complete PNG file as input,
and returns an optimized version on output.
Will throw an exception in case of an error.

#### fileSync(String) → void

Takes the name of a PNG file which will be read,
optimized and written to the same location.
Will throw an exception in case of an error.
This method is not available in the browserified version.


text:
package org.datavec.api.split.partition;

import org.datavec.api.conf.Configuration;
import org.datavec.api.split.InputSplit;

import java.io.OutputStream;
import java.net.URI;

/**
 * Partition relative to number of records written per file.
 * This partitioner will ensure that no more than
 * {@link #recordsPerFile} number of records is written per
 * file when outputting to the various locations of the
 * {@link InputSplit} locations.
 *
 * @author Adam Gibson
 */
public class NumberOfRecordsPartitioner implements Partitioner {

    private URI[] locations;
    private int recordsPerFile = DEFAULT_RECORDS_PER_FILE;
    //all records in to 1 file
    public final static int DEFAULT_RECORDS_PER_FILE = -1;

    public final static String RECORDS_PER_FILE_CONFIG = "org.datavec.api.split.partition.numrecordsperfile";
    private int numRecordsSoFar = 0;
    private int currLocation;
    private InputSplit inputSplit;
    private OutputStream current;
    private boolean doneWithCurrentLocation = false;
    private int totalRecordsWritten;

    @Override
    public int totalRecordsWritten() {
        return totalRecordsWritten;
    }

    @Override
    public int numRecordsWritten() {
        return numRecordsSoFar;
    }

    @Override
    public int numPartitions() {
        //possible it's a directory
        if(locations.length < 2) {

            if(locations.length > 0 && locations[0].isAbsolute()) {
                return recordsPerFile;
            }
            //append all results to 1 file when -1
            else {
                return 1;
            }
        }

        //otherwise it's a series of specified files.
        return locations.length / recordsPerFile;
    }

    @Override
    public void init(InputSplit inputSplit) {
        this.locations = inputSplit.locations();
        this.inputSplit = inputSplit;

    }

    @Override
    public void init(Configuration configuration, InputSplit split) {
        init(split);
        this.recordsPerFile = configuration.getInt(RECORDS_PER_FILE_CONFIG,DEFAULT_RECORDS_PER_FILE);
    }

    @Override
    public void updatePartitionInfo(PartitionMetaData metadata) {
        this.numRecordsSoFar += metadata.getNumRecordsUpdated();
        this.totalRecordsWritten += metadata.getNumRecordsUpdated();
        if(numRecordsSoFar >= recordsPerFile && recordsPerFile > 0)  {
            doneWithCurrentLocation = true;
        }
    }

    @Override
    public boolean needsNewPartition() {
        doneWithCurrentLocation = numRecordsSoFar >= recordsPerFile && recordsPerFile > 0;
        return recordsPerFile > 0 && numRecordsSoFar >= recordsPerFile ||  doneWithCurrentLocation;
    }

    @Override
    public OutputStream openNewStream() {
        //reset status of location
        doneWithCurrentLocation = false;
        //ensure count is 0 for records so far for current record
        numRecordsSoFar = 0;

        //only append when directory, also ensure we can bootstrap and we can write to the current location
        if(currLocation >= locations.length - 1 && locations.length >= 1 && needsNewPartition() || inputSplit.needsBootstrapForWrite() ||
                locations.length < 1 ||
                currLocation >= locations.length || !inputSplit.canWriteToLocation(locations[currLocation])
                && needsNewPartition()) {

            String newInput = inputSplit.addNewLocation();
            try {
                OutputStream ret =  inputSplit.openOutputStreamFor(newInput);
                this.current = ret;
                return ret;
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }

        else {
            try {
                OutputStream ret =  inputSplit.openOutputStreamFor(locations[currLocation].toString());
                currLocation++;
                this.current = ret;
                return ret;
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        }

    }

    @Override
    public OutputStream currentOutputStream() {
        if(current == null) {
            current = openNewStream();
        }
        return current;
    }
}


text:
class User < ActiveRecord::Base

  #enable has_secure_password
  #ActiveRecord looks for an "email" column
  #as well as a "password_digest"
  #and works with them...
  #to auto-setup bcrypt
  #and salt/hash for us!

  has_secure_password
end


text:
package com.github.aikivinen.birtdemo.view;

import javax.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;

import com.vaadin.icons.VaadinIcons;
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
import com.vaadin.server.FontAwesome;
import com.vaadin.server.FontIcon;
import com.vaadin.spring.annotation.SpringView;
import com.vaadin.ui.TabSheet;
import com.vaadin.ui.VerticalLayout;

@SpringView(name = ReportsView.VIEW_NAME)
@SuppressWarnings("serial")
public class ReportsView extends VerticalLayout implements View {
	public static final String VIEW_NAME = "reports";
	public static final FontIcon ICON = VaadinIcons.FILE;
	private static final Logger logger = LoggerFactory.getLogger(ReportsView.class);

	@Autowired
	private MessageSource messageSource;

	@Autowired
	private ReportsViewTab1 tab1;

	@Autowired
	private ReportsViewTab2 tab2;

	private TabSheet tabsheet;

	@Override
	public void enter(ViewChangeEvent event) {

	}

	@PostConstruct
	void init() {
		tabsheet = new TabSheet();
		tabsheet.addTab(tab1, messageSource.getMessage("caption.printreports", null, getLocale()));
		tabsheet.addTab(tab2, messageSource.getMessage("caption.editreports", null, getLocale()));
		tabsheet.setSizeFull();
		addComponent(tabsheet);
		setSizeFull();
	}
}


text:
import { Meteor } from 'meteor/meteor';
import { Random } from 'meteor/random';
import { UploadFS } from 'meteor/jalik:ufs';
import _ from 'underscore';

import { canAccessRoom, hasPermission } from '../../authorization';
import { settings } from '../../settings';

UploadFS.config.defaultStorePermissions = new UploadFS.StorePermissions({
	insert(userId, doc) {
		if (userId) {
			return true;
		}

		// allow inserts from slackbridge (message_id = slack-timestamp-milli)
		if (doc && doc.message_id && doc.message_id.indexOf('slack-') === 0) {
			return true;
		}

		// allow inserts to the UserDataFiles store
		if (doc && doc.store && doc.store.split(':').pop() === 'UserDataFiles') {
			return true;
		}

		if (canAccessRoom(null, null, doc)) {
			return true;
		}

		return false;
	},
	update(userId, doc) {
		return hasPermission(Meteor.userId(), 'delete-message', doc.rid) || (settings.get('Message_AllowDeleting') && userId === doc.userId);
	},
	remove(userId, doc) {
		return hasPermission(Meteor.userId(), 'delete-message', doc.rid) || (settings.get('Message_AllowDeleting') && userId === doc.userId);
	},
});

export class FileUploadBase {
	constructor(store, meta, file) {
		this.id = Random.id();
		this.meta = meta;
		this.file = file;
		this.store = store;
	}

	getProgress() {

	}

	getFileName() {
		return this.meta.name;
	}

	start(callback) {
		this.handler = new UploadFS.Uploader({
			store: this.store,
			data: this.file,
			file: this.meta,
			onError: (err) => callback(err),
			onComplete: (fileData) => {
				const file = _.pick(fileData, '_id', 'type', 'size', 'name', 'identify', 'description');

				file.url = fileData.url.replace(Meteor.absoluteUrl(), '/');
				return callback(null, file, this.store.options.name);
			},
		});

		this.handler.onProgress = (file, progress) => {
			this.onProgress(progress);
		};

		return this.handler.start();
	}

	onProgress() {}

	stop() {
		return this.handler.stop();
	}
}


text:
Don't use the `bundle exec rake release` task. It is more convenient,
but it skips the process of signing the version release task.

## Run Tests

```sh
$ rake test_all
```

## Git Push

```sh
$ git push
```

Check for regressions in automated tests:

* [https://travis-ci.org/grempe/tss-rb](https://travis-ci.org/grempe/tss-rb)
* [https://coveralls.io/github/grempe/tss-rb?branch=master](https://coveralls.io/github/grempe/tss-rb?branch=master)
* [https://codeclimate.com/github/grempe/tss-rb](https://codeclimate.com/github/grempe/tss-rb)

## Bump Version Number and edit CHANGELOG.md

```sh
$ vi lib/tss/version.rb
$ git add lib/tss/version.rb
$ vi CHANGELOG.md
$ git add CHANGELOG.md
```

## Local Build and Install w/ Signed Gem

The `build` step should ask for PEM passphrase to sign gem. If it does
not ask it means that the signing cert is not present.

Build:

```sh
$ rake build
Enter PEM pass phrase:
tss 0.5.0 built to pkg/tss-0.5.0.gem.
```

Install locally w/ Cert:

```sh
$ gem uninstall tss
$ rbenv rehash
$ gem install pkg/tss-0.5.0.gem -P MediumSecurity
Successfully installed tss-0.5.0
1 gem installed
```

## Git Commit Version and CHANGELOG Changes, Tag and push to Github

```sh
$ git commit -m 'Bump version v0.5.0'
$ git tag -s v0.5.0 -m "v0.5.0" SHA1_OF_COMMIT
```

Verify last commit and last tag are GPG signed:

```
$ git tag -v v0.5.0
...
gpg: Good signature from "Glenn Rempe (Code Signing Key) <glenn@rempe.us>" [ultimate]
...
```

```
$ git log --show-signature
...
gpg: Good signature from "Glenn Rempe (Code Signing Key) <glenn@rempe.us>" [ultimate]
...
```

Push code and tags to GitHub:

```
$ git push
$ git push --tags
```

## Push gem to Rubygems.org

```sh
$ gem push pkg/tss-0.1.1.gem
```

Verify Gem Push at [https://rubygems.org/gems/tss](https://rubygems.org/gems/tss)

## Create a GitHub Release

Specify the tag we just pushed to attach release to. Copy notes from CHANGELOG.md

[https://github.com/grempe/tss-rb/releases](https://github.com/grempe/tss-rb/releases)

## Announce Release on Twitter

The normal blah, blah, blah.


text:
import re

class IndentParser(object):
    def __init__(self, content, ignore_characters=[]):
        """
        >>> f=open('../resources/test_file.txt')
        >>> content=f.read()
        >>> parser=IndentParser(content)
        >>> len(parser.configs)
        4
        >>> parser.configs[0]['line']
        'indent1'
        >>> parser.configs[1]['line']
        'indent2'
        >>> parser.configs[2]['line']
        'indent3'
        >>> parser.configs[3]['line']
        'indent4'
        >>> len(parser.configs[0]['children'])
        0
        >>> len(parser.configs[1]['children'])
        0
        >>> len(parser.configs[2]['children'])
        3
        >>> len(parser.configs[3]['children'])
        2
        >>> parser.configs[2]['children'][0]['line']
        'indent31'
        >>> parser.configs[2]['children'][1]['line']
        'indent32'
        >>> parser.configs[2]['children'][2]['line']
        'indent33'
        >>> parser.configs[3]['children'][0]['line']
        'indent41'
        >>> parser.configs[3]['children'][1]['line']
        'indent42'
        >>> len(parser.configs[2]['children'][0]['children'])
        0
        >>> len(parser.configs[2]['children'][1]['children'])
        0
        >>> len(parser.configs[2]['children'][2]['children'])
        0
        >>> len(parser.configs[3]['children'][0]['children'])
        0
        >>> len(parser.configs[3]['children'][1]['children'])
        3
        >>> parser.configs[3]['children'][1]['children'][0]['line']
        'indent421'
        >>> parser.configs[3]['children'][1]['children'][1]['line']
        'indent422'
        >>> parser.configs[3]['children'][1]['children'][2]['line']
        'indent423'
        """
        self.configs = self.parse_lines(content, ignore_characters=ignore_characters)

    def parse_lines(self, content, indent_count=0, ignore_characters=[]):

        configs = []
        line_content_pattern = re.compile('^\s{%(indent_count)s}[^%(ignore_characters)s\s][\S\s]+?(?=\Z|^\s{0,%(indent_count)s}[^%(ignore_characters)s\s])' % {'indent_count': indent_count,
                                                                                'ignore_characters': ''.join(
                                                                                ignore_characters)},
                                          re.M | re.DOTALL)
        line_pattern = re.compile('^\s{%(indent_count)s}(?P<line>[^\n]+)' % {'indent_count': indent_count}, re.M)
        indent_count += 1
        for grp in line_content_pattern.findall(content, re.M):
            match = line_pattern.search(grp)
            config = {'line': match.group('line'), 'children': self.parse_lines(grp, indent_count=indent_count)}
            configs.append(config)
        return configs

    def find_line(self, nested_lines, exactmatch=False, configs=None, ):
        configs = configs is not None and configs or self.configs
        if not nested_lines:
            return None
        results = []
        nested_line = nested_lines[0]
        for config in configs:
            if (exactmatch and config['line'] == nested_line) or (not exactmatch and nested_line in config['line']):
                if len(nested_lines) == 1:
                    results.append(config['line'])
                else:
                    result = self.find_line(nested_lines[1:], exactmatch=exactmatch, configs=config['children'])
                    if result:
                        results.extend(result)
            else:
                if config['children']:
                    result = self.find_line(nested_lines, exactmatch=exactmatch, configs=config['children'])
                    if result:
                        results.extend(result)
        return results

    def find_children(self, nested_lines, exactmatch=False, configs=None, ):
        configs = configs is not None and configs or self.configs
        if not nested_lines:
            return None

        nested_line = nested_lines[0]
        for config in configs:
            if (exactmatch and config['line'] == nested_line) or (not exactmatch and nested_line in config['line']):
                if len(nested_lines) == 1:
                    return config['children']
                else:
                    result = self.find_children(nested_lines[1:], exactmatch=exactmatch, configs=config['children'])
                    if result:
                        return result
            else:
                if config['children']:
                    result = self.find_children(nested_lines, exactmatch=exactmatch, configs=config['children'])
                    if result:
                        return result


text:
(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){
'use strict';

self.MemePlayer = require('./browser');

},{"./browser":2}],2:[function(require,module,exports){
'use strict';

var MemePlayer = require('./src/MemePlayer');

module.exports = MemePlayer;

},{"./src/MemePlayer":9}],3:[function(require,module,exports){
'use strict';

exports.atob = self.atob.bind(self);
exports.btoa = self.btoa.bind(self);

},{}],4:[function(require,module,exports){
'use strict';

var Encoder = require('./src/GIFEncoder.js'),
  Decoder = require('./src/GifReader.js');

module.exports = {
  Encoder: Encoder,
  Decoder: Decoder
};

},{"./src/GIFEncoder.js":5,"./src/GifReader.js":6}],5:[function(require,module,exports){
/**
 * This class lets you encode animated GIF files
 * Base class :  http://www.java2s.com/Code/Java/2D-Graphics-GUI/AnimatedGifEncoder.htm
 * @author Kevin Weiner (original Java version - kweiner@fmsware.com)
 * @author Thibault Imbert (AS3 version - bytearray.org)
 * @author Kevin Kwok (JavaScript version - https://github.com/antimatter15/jsgif)
 * @version 0.1 AS3 implementation
 */

var LZWEncoder = require('./LZWEncoder'),
  NeuQuant = require('./NeuQuant');

var GIFEncoder = function() {

  for (var i = 0, chr = {}; i < 256; i++)
    chr[i] = String.fromCharCode(i);

  function ByteArray() {
    this.bin = [];
  }

  ByteArray.prototype.getData = function() {
    for (var v = '', l = this.bin.length, i = 0; i < l; i++)
      v += chr[this.bin[i]];
    return v;
  };

  ByteArray.prototype.writeByte = function(val) {
    this.bin.push(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]);
  };

  var exports = {};
  var width; // image size
  var height;
  var transparent = null; // transparent color if given
  var transIndex; // transparent index in color table
  var repeat = -1; // no repeat
  var delay = 0; // frame delay (hundredths)
  var started = false; // ready to output frames
  var out;
  var image; // current frame
  var pixels; // BGR byte array from frame
  var indexedPixels; // converted frame indexed to palette
  var colorDepth; // number of bit planes
  var colorTab; // RGB palette
  var usedEntry = []; // active palette entries
  var palSize = 7; // color table size (bits-1)
  var dispose = -1; // disposal code (-1 = use default)
  var closeStream = false; // close stream when finished
  var firstFrame = true;
  var sizeSet = false; // if false, get size from first frame
  var sample = 10; // default sample interval for quantizer
  var comment = "Generated by jsgif (https://github.com/antimatter15/jsgif/)"; // default comment for generated gif

  /**
   * Sets the delay time between each frame, or changes it for subsequent frames
   * (applies to last frame added)
   * int delay time in milliseconds
   * @param ms
   */

  var setDelay = exports.setDelay = function setDelay(ms) {
    delay = Math.round(ms / 10);
  };

  /**
   * Sets the GIF frame disposal code for the last added frame and any
   *
   * subsequent frames. Default is 0 if no transparent color has been set,
   * otherwise 2.
   * @param code
   * int disposal code.
   */

  var setDispose = exports.setDispose = function setDispose(code) {
    if (code >= 0) dispose = code;
  };

  /**
   * Sets the number of times the set of GIF frames should be played. Default is
   * 1; 0 means play indefinitely. Must be invoked before the first image is
   * added.
   *
   * @param iter
   * int number of iterations.
   * @return
   */

  var setRepeat = exports.setRepeat = function setRepeat(iter) {
    if (iter >= 0) repeat = iter;
  };

  /**
   * Sets the transparent color for the last added frame and any subsequent
   * frames. Since all colors are subject to modification in the quantization
   * process, the color in the final palette for each frame closest to the given
   * color becomes the transparent color for that frame. May be set to null to
   * indicate no transparent color.
   * @param
   * Color to be treated as transparent on display.
   */

  var setTransparent = exports.setTransparent = function setTransparent(c) {
    transparent = c;
  };

  /**
   * Sets the comment for the block comment
   * @param
   * string to be insterted as comment
   */

  var setComment = exports.setComment = function setComment(c) {
    comment = c;
  };

  /**
   * The addFrame method takes an incoming BitmapData object to create each frames
   * @param
   * BitmapData object to be treated as a GIF's frame
   */

  var addFrame = exports.addFrame = function addFrame(im, is_imageData) {

    if ((im === null) || !started || out === null) {
      throw new Error("Please call start method before calling addFrame");
    }

    var ok = true;

    try {
      if (!is_imageData) {
        image = im.getImageData(0, 0, im.canvas.width, im.canvas.height).data;
        if (!sizeSet) setSize(im.canvas.width, im.canvas.height);
      } else {
        image = im;
      }
      getImagePixels(); // convert to correct format if necessary
      analyzePixels(); // build color table & map pixels

      if (firstFrame) {
        writeLSD(); // logical screen descriptior
        writePalette(); // global color table
        if (repeat >= 0) {
          // use NS app extension to indicate reps
          writeNetscapeExt();
        }
      }

      writeGraphicCtrlExt(); // write graphic control extension
      if (comment !== '') {
        writeCommentExt(); // write comment extension
      }
      writeImageDesc(); // image descriptor
      if (!firstFrame) writePalette(); // local color table
      writePixels(); // encode and write pixel data
      firstFrame = false;
    } catch (e) {
      ok = false;
    }

    return ok;
  };

  /**
   * Adds final trailer to the GIF stream, if you don't call the finish method
   * the GIF stream will not be valid.
   */

  var finish = exports.finish = function finish() {

    if (!started) return false;

    var ok = true;
    started = false;

    try {
      out.writeByte(0x3b); // gif trailer
    } catch (e) {
      ok = false;
    }

    return ok;
  };

  /**
   * Resets some members so that a new stream can be started.
   * This method is actually called by the start method
   */

  var reset = function reset() {

    // reset for subsequent use
    transIndex = 0;
    image = null;
    pixels = null;
    indexedPixels = null;
    colorTab = null;
    closeStream = false;
    firstFrame = true;
  };

  /**
   * * Sets frame rate in frames per second. Equivalent to
   * setDelay(1000/fps).
   * @param fps
   * float frame rate (frames per second)
   */

  var setFrameRate = exports.setFrameRate = function setFrameRate(fps) {
    if (fps != 0xf) delay = Math.round(100 / fps);
  };

  /**
   * Sets quality of color quantization (conversion of images to the maximum 256
   * colors allowed by the GIF specification). Lower values (minimum = 1)
   * produce better colors, but slow processing significantly. 10 is the
   * default, and produces good color mapping at reasonable speeds. Values
   * greater than 20 do not yield significant improvements in speed.
   * @param quality
   * int greater than 0.
   * @return
   */

  var setQuality = exports.setQuality = function setQuality(quality) {
    if (quality < 1) quality = 1;
    sample = quality;
  };

  /**
   * Sets the GIF frame size. The default size is the size of the first frame
   * added if this method is not invoked.
   * @param w
   * int frame width.
   * @param h
   * int frame width.
   */

  var setSize = exports.setSize = function setSize(w, h) {

    if (started && !firstFrame) return;
    width = w;
    height = h;
    if (width < 1) width = 320;
    if (height < 1) height = 240;
    sizeSet = true;
  };

  /**
   * Initiates GIF file creation on the given stream.
   * @param os
   * OutputStream on which GIF images are written.
   * @return false if initial write failed.
   */

  var start = exports.start = function start() {

    reset();
    var ok = true;
    closeStream = false;
    out = new ByteArray();
    try {
      out.writeUTFBytes("GIF89a"); // header
    } catch (e) {
      ok = false;
    }

    return started = ok;
  };

  var cont = exports.cont = function cont() {

    reset();
    var ok = true;
    closeStream = false;
    out = new ByteArray();

    return started = ok;
  };

  /**
   * Analyzes image colors and creates color map.
   */

  var analyzePixels = function analyzePixels() {

    var len = pixels.length;
    var nPix = len / 3;
    indexedPixels = [];
    var nq = new NeuQuant(pixels, len, sample);

    // initialize quantizer
    colorTab = nq.process(); // create reduced palette

    // map image pixels to new palette
    var k = 0;
    for (var j = 0; j < nPix; j++) {
      var index = nq.map(pixels[k++] & 0xff, pixels[k++] & 0xff, pixels[k++] & 0xff);
      usedEntry[index] = true;
      indexedPixels[j] = index;
    }

    pixels = null;
    colorDepth = 8;
    palSize = 7;

    // get closest match to transparent color if specified
    if (transparent !== null) {
      transIndex = findClosest(transparent);
    }
  };

  /**
   * Returns index of palette color closest to c
   */

  var findClosest = function findClosest(c) {

    if (colorTab === null) return -1;
    var r = (c & 0xFF0000) >> 16;
    var g = (c & 0x00FF00) >> 8;
    var b = (c & 0x0000FF);
    var minpos = 0;
    var dmin = 256 * 256 * 256;
    var len = colorTab.length;

    for (var i = 0; i < len;) {
      var dr = r - (colorTab[i++] & 0xff);
      var dg = g - (colorTab[i++] & 0xff);
      var db = b - (colorTab[i] & 0xff);
      var d = dr * dr + dg * dg + db * db;
      var index = i / 3;
      if (usedEntry[index] && (d < dmin)) {
        dmin = d;
        minpos = index;
      }
      i++;
    }
    return minpos;
  };

  /**
   * Extracts image pixels into byte array "pixels
   */

  var getImagePixels = function getImagePixels() {
    var w = width;
    var h = height;
    pixels = [];
    var data = image;
    var count = 0;

    for (var i = 0; i < h; i++) {

      for (var j = 0; j < w; j++) {

        var b = (i * w * 4) + j * 4;
        pixels[count++] = data[b];
        pixels[count++] = data[b + 1];
        pixels[count++] = data[b + 2];

      }

    }
  };

  /**
   * Writes Graphic Control Extension
   */

  var writeGraphicCtrlExt = function writeGraphicCtrlExt() {
    out.writeByte(0x21); // extension introducer
    out.writeByte(0xf9); // GCE label
    out.writeByte(4); // data block size
    var transp;
    var disp;
    if (transparent === null) {
      transp = 0;
      disp = 0; // dispose = no action
    } else {
      transp = 1;
      disp = 2; // force clear if using transparent color
    }
    if (dispose >= 0) {
      disp = dispose & 7; // user override
    }
    disp <<= 2;
    // packed fields
    out.writeByte(0 | // 1:3 reserved
        disp | // 4:6 disposal
        0 | // 7 user input - 0 = none
        transp); // 8 transparency flag

    WriteShort(delay); // delay x 1/100 sec
    out.writeByte(transIndex); // transparent color index
    out.writeByte(0); // block terminator
  };

  /**
   * Writes Comment Extention
   */

  var writeCommentExt = function writeCommentExt() {
    out.writeByte(0x21); // extension introducer
    out.writeByte(0xfe); // comment label
    out.writeByte(comment.length); // Block Size (s)
    out.writeUTFBytes(comment);
    out.writeByte(0); // block terminator
  };

  /**
   * Writes Image Descriptor
   */

  var writeImageDesc = function writeImageDesc() {

    out.writeByte(0x2c); // image separator
    WriteShort(0); // image position x,y = 0,0
    WriteShort(0);
    WriteShort(width); // image size
    WriteShort(height);

    // packed fields
    if (firstFrame) {
      // no LCT - GCT is used for first (or only) frame
      out.writeByte(0);
    } else {
      // specify normal LCT
      out.writeByte(0x80 | // 1 local color table 1=yes
          0 | // 2 interlace - 0=no
          0 | // 3 sorted - 0=no
          0 | // 4-5 reserved
          palSize); // 6-8 size of color table
    }
  };

  /**
   * Writes Logical Screen Descriptor
   */

  var writeLSD = function writeLSD() {

    // logical screen size
    WriteShort(width);
    WriteShort(height);
    // packed fields
    out.writeByte((0x80 | // 1 : global color table flag = 1 (gct used)
          0x70 | // 2-4 : color resolution = 7
          0x00 | // 5 : gct sort flag = 0
          palSize)); // 6-8 : gct size

    out.writeByte(0); // background color index
    out.writeByte(0); // pixel aspect ratio - assume 1:1
  };

  /**
   * Writes Netscape application extension to define repeat count.
   */

  var writeNetscapeExt = function writeNetscapeExt() {
    out.writeByte(0x21); // extension introducer
    out.writeByte(0xff); // app extension label
    out.writeByte(11); // block size
    out.writeUTFBytes("NETSCAPE" + "2.0"); // app id + auth code
    out.writeByte(3); // sub-block size
    out.writeByte(1); // loop sub-block id
    WriteShort(repeat); // loop count (extra iterations, 0=repeat forever)
    out.writeByte(0); // block terminator
  };

  /**
   * Writes color table
   */

  var writePalette = function writePalette() {
    out.writeBytes(colorTab);
    var n = (3 * 256) - colorTab.length;
    for (var i = 0; i < n; i++) out.writeByte(0);
  };

  var WriteShort = function WriteShort(pValue) {
    out.writeByte(pValue & 0xFF);
    out.writeByte((pValue >> 8) & 0xFF);
  };

  /**
   * Encodes and writes pixel data
   */

  var writePixels = function writePixels() {
    var myencoder = new LZWEncoder(width, height, indexedPixels, colorDepth);
    myencoder.encode(out);
  };

  /**
   * Retrieves the GIF stream
   */

  var stream = exports.stream = function stream() {
    return out;
  };

  var setProperties = exports.setProperties = function setProperties(has_start, is_first) {
    started = has_start;
    firstFrame = is_first;
  };

  return exports;

};

module.exports = GIFEncoder;

},{"./LZWEncoder":7,"./NeuQuant":8}],6:[function(require,module,exports){
// (c) Dean McNamee <dean@gmail.com>, 2013.
//
// https://github.com/deanm/omggif
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
// omggif is a JavaScript implementation of a GIF 89a encoder and decoder,
// including animation and compression.  It does not rely on any specific
// underlying system, so should run in the browser, Node, or Plask.

function GifReader(buf) {
  var p = 0;

  // - Header.
  if (buf[p++] !== 0x47 || buf[p++] !== 0x49 || buf[p++] !== 0x46 ||  // GIF
      buf[p++] !== 0x38 || buf[p++] !== 0x39 || buf[p++] !== 0x61) {  // 89a
    throw "Invalid GIF 89a header.";
  }

  // - Logical Screen Descriptor.
  var width = buf[p++] | buf[p++] << 8;
  var height = buf[p++] | buf[p++] << 8;
  var pf0 = buf[p++];  // <Packed Fields>.
  var global_palette_flag = pf0 >> 7;
  var num_global_colors_pow2 = pf0 & 0x7;
  var num_global_colors = 1 << (num_global_colors_pow2 + 1);
  var background = buf[p++];
  buf[p++];  // Pixel aspect ratio (unused?).

  var global_palette_offset = null;

  if (global_palette_flag) {
    global_palette_offset = p;
    p += num_global_colors * 3;  // Seek past palette.
  }

  var loop_count = null;

  var no_eof = true;

  var frames = [ ];

  var delay = 0;
  var transparent_index = null;
  var disposal = 0;  // 0 - No disposal specified.
  var loop_count = null;

  this.width = width;
  this.height = height;

  while (no_eof && p < buf.length) {
    switch (buf[p++]) {
      case 0x21:  // Graphics Control Extension Block
        switch (buf[p++]) {
          case 0xff:  // Application specific block
            // Try if it's a Netscape block (with animation loop counter).
            if (buf[p   ] !== 0x0b ||  // 21 FF already read, check block size.
                // NETSCAPE2.0
                buf[p+1 ] == 0x4e && buf[p+2 ] == 0x45 && buf[p+3 ] == 0x54 &&
                buf[p+4 ] == 0x53 && buf[p+5 ] == 0x43 && buf[p+6 ] == 0x41 &&
                buf[p+7 ] == 0x50 && buf[p+8 ] == 0x45 && buf[p+9 ] == 0x32 &&
                buf[p+10] == 0x2e && buf[p+11] == 0x30 &&
                // Sub-block
                buf[p+12] == 0x03 && buf[p+13] == 0x01 && buf[p+16] == 0) {
              p += 14;
              loop_count = buf[p++] | buf[p++] << 8;
              p++;  // Skip terminator.
            } else {  // We don't know what it is, just try to get past it.
              p += 12;
              while (true) {  // Seek through subblocks.
                var block_size = buf[p++];
                if (block_size === 0) break;
                p += block_size;
              }
            }
            break;

          case 0xf9:  // Graphics Control Extension
            if (buf[p++] !== 0x4 || buf[p+4] !== 0)
              throw "Invalid graphics extension block.";
            var pf1 = buf[p++];
            delay = buf[p++] | buf[p++] << 8;
            transparent_index = buf[p++];
            if ((pf1 & 1) === 0) transparent_index = null;
            disposal = pf1 >> 2 & 0x7;
            p++;  // Skip terminator.
            break;

          case 0xfe:  // Comment Extension.
            while (true) {  // Seek through subblocks.
              var block_size = buf[p++];
              if (block_size === 0) break;
              // console.log(buf.slice(p, p+block_size).toString('ascii'));
              p += block_size;
            }
            break;

          default:
            throw "Unknown graphic control label: 0x" + buf[p-1].toString(16);
        }
        break;

      case 0x2c:  // Image Descriptor.
        var x = buf[p++] | buf[p++] << 8;
        var y = buf[p++] | buf[p++] << 8;
        var w = buf[p++] | buf[p++] << 8;
        var h = buf[p++] | buf[p++] << 8;
        var pf2 = buf[p++];
        var local_palette_flag = pf2 >> 7;
        var interlace_flag = pf2 >> 6 & 1;
        var num_local_colors_pow2 = pf2 & 0x7;
        var num_local_colors = 1 << (num_local_colors_pow2 + 1);
        var palette_offset = global_palette_offset;
        var has_local_palette = false;
        if (local_palette_flag) {
          var has_local_palette = true;
          palette_offset = p;  // Override with local palette.
          p += num_local_colors * 3;  // Seek past palette.
        }

        var data_offset = p;

        p++;  // codesize
        while (true) {
          var block_size = buf[p++];
          if (block_size === 0) break;
          p += block_size;
        }

        frames.push({x: x, y: y, width: w, height: h,
                     has_local_palette: has_local_palette,
                     palette_offset: palette_offset,
                     data_offset: data_offset,
                     data_length: p - data_offset,
                     transparent_index: transparent_index,
                     interlaced: !!interlace_flag,
                     delay: delay,
                     disposal: disposal});
        break;

      case 0x3b:  // Trailer Marker (end of file).
        no_eof = false;
        break;

      default:
        throw "Unknown gif block: 0x" + buf[p-1].toString(16);
        break;
    }
  }

  this.numFrames = function() {
    return frames.length;
  };

  this.frameInfo = function(frame_num) {
    if (frame_num < 0 || frame_num >= frames.length)
      throw "Frame index out of range.";
    return frames[frame_num];
  }

  this.decodeAndBlitFrameBGRA = function(frame_num, pixels) {
    var frame = this.frameInfo(frame_num);
    var num_pixels = frame.width * frame.height;
    var index_stream = new Uint8Array(num_pixels);  // At most 8-bit indices.
    GifReaderLZWOutputIndexStream(
        buf, frame.data_offset, index_stream, num_pixels);
    var palette_offset = frame.palette_offset;

    // NOTE(deanm): It seems to be much faster to compare index to 256 than
    // to === null.  Not sure why, but CompareStub_EQ_STRICT shows up high in
    // the profile, not sure if it's related to using a Uint8Array.
    var trans = frame.transparent_index;
    if (trans === null) trans = 256;

    // We are possibly just blitting to a portion of the entire frame.
    // That is a subrect within the framerect, so the additional pixels
    // must be skipped over after we finished a scanline.
    var framewidth  = frame.width;
    var framestride = width - framewidth;
    var xleft       = framewidth;  // Number of subrect pixels left in scanline.

    // Output indicies of the top left and bottom right corners of the subrect.
    var opbeg = ((frame.y * width) + frame.x) * 4;
    var opend = ((frame.y + frame.height) * width + frame.x) * 4;
    var op    = opbeg;

    var scanstride = framestride * 4;

    // Use scanstride to skip past the rows when interlacing.  This is skipping
    // 7 rows for the first two passes, then 3 then 1.
    if (frame.interlaced === true) {
      scanstride += (framewidth + framestride) * 4 * 7;  // Pass 1.
    }

    var interlaceskip = 8;  // Tracking the row interval in the current pass.

    for (var i = 0, il = index_stream.length; i < il; ++i) {
      var index = index_stream[i];

      if (xleft === 0) {  // Beginning of new scan line
        op += scanstride;
        xleft = framewidth;
        if (op >= opend) { // Catch the wrap to switch passes when interlacing.
          scanstride =
              framestride + (framewidth + framestride) * 4 * (interlaceskip-1);
          // interlaceskip / 2 * 4 is interlaceskip << 1.
          op = opbeg + (framewidth + framestride) * (interlaceskip << 1);
          interlaceskip >>= 1;
        }
      }

      if (index === trans) {
        op += 4;
      } else {
        var r = buf[palette_offset + index * 3];
        var g = buf[palette_offset + index * 3 + 1];
        var b = buf[palette_offset + index * 3 + 2];
        pixels[op++] = b;
        pixels[op++] = g;
        pixels[op++] = r;
        pixels[op++] = 255;
      }
      --xleft;
    }
  };

  // I will go to copy and paste hell one day...
  this.decodeAndBlitFrameRGBA = function(frame_num, pixels) {
    var frame = this.frameInfo(frame_num);
    var num_pixels = frame.width * frame.height;
    var index_stream = new Uint8Array(num_pixels);  // At most 8-bit indices.
    GifReaderLZWOutputIndexStream(
        buf, frame.data_offset, index_stream, num_pixels);
    var palette_offset = frame.palette_offset;

    // NOTE(deanm): It seems to be much faster to compare index to 256 than
    // to === null.  Not sure why, but CompareStub_EQ_STRICT shows up high in
    // the profile, not sure if it's related to using a Uint8Array.
    var trans = frame.transparent_index;
    if (trans === null) trans = 256;

    // We are possibly just blitting to a portion of the entire frame.
    // That is a subrect within the framerect, so the additional pixels
    // must be skipped over after we finished a scanline.
    var framewidth  = frame.width;
    var framestride = width - framewidth;
    var xleft       = framewidth;  // Number of subrect pixels left in scanline.

    // Output indicies of the top left and bottom right corners of the subrect.
    var opbeg = ((frame.y * width) + frame.x) * 4;
    var opend = ((frame.y + frame.height) * width + frame.x) * 4;
    var op    = opbeg;

    var scanstride = framestride * 4;

    // Use scanstride to skip past the rows when interlacing.  This is skipping
    // 7 rows for the first two passes, then 3 then 1.
    if (frame.interlaced === true) {
      scanstride += (framewidth + framestride) * 4 * 7;  // Pass 1.
    }

    var interlaceskip = 8;  // Tracking the row interval in the current pass.

    for (var i = 0, il = index_stream.length; i < il; ++i) {
      var index = index_stream[i];

      if (xleft === 0) {  // Beginning of new scan line
        op += scanstride;
        xleft = framewidth;
        if (op >= opend) { // Catch the wrap to switch passes when interlacing.
          scanstride =
              framestride + (framewidth + framestride) * 4 * (interlaceskip-1);
          // interlaceskip / 2 * 4 is interlaceskip << 1.
          op = opbeg + (framewidth + framestride) * (interlaceskip << 1);
          interlaceskip >>= 1;
        }
      }

      if (index === trans) {
        op += 4;
      } else {
        var r = buf[palette_offset + index * 3];
        var g = buf[palette_offset + index * 3 + 1];
        var b = buf[palette_offset + index * 3 + 2];
        pixels[op++] = r;
        pixels[op++] = g;
        pixels[op++] = b;
        pixels[op++] = 255;
      }
      --xleft;
    }
  };
}

function GifReaderLZWOutputIndexStream(code_stream, p, output, output_length) {
  var min_code_size = code_stream[p++];

  var clear_code = 1 << min_code_size;
  var eoi_code = clear_code + 1;
  var next_code = eoi_code + 1;

  var cur_code_size = min_code_size + 1;  // Number of bits per code.
  // NOTE: This shares the same name as the encoder, but has a different
  // meaning here.  Here this masks each code coming from the code stream.
  var code_mask = (1 << cur_code_size) - 1;
  var cur_shift = 0;
  var cur = 0;

  var op = 0;  // Output pointer.

  var subblock_size = code_stream[p++];

  // TODO(deanm): Would using a TypedArray be any faster?  At least it would
  // solve the fast mode / backing store uncertainty.
  // var code_table = Array(4096);
  var code_table = new Int32Array(4096);  // Can be signed, we only use 20 bits.

  var prev_code = null;  // Track code-1.

  while (true) {
    // Read up to two bytes, making sure we always 12-bits for max sized code.
    while (cur_shift < 16) {
      if (subblock_size === 0) break;  // No more data to be read.

      cur |= code_stream[p++] << cur_shift;
      cur_shift += 8;

      if (subblock_size === 1) {  // Never let it get to 0 to hold logic above.
        subblock_size = code_stream[p++];  // Next subblock.
      } else {
        --subblock_size;
      }
    }

    // TODO(deanm): We should never really get here, we should have received
    // and EOI.
    if (cur_shift < cur_code_size)
      break;

    var code = cur & code_mask;
    cur >>= cur_code_size;
    cur_shift -= cur_code_size;

    // TODO(deanm): Maybe should check that the first code was a clear code,
    // at least this is what you're supposed to do.  But actually our encoder
    // now doesn't emit a clear code first anyway.
    if (code === clear_code) {
      // We don't actually have to clear the table.  This could be a good idea
      // for greater error checking, but we don't really do any anyway.  We
      // will just track it with next_code and overwrite old entries.

      next_code = eoi_code + 1;
      cur_code_size = min_code_size + 1;
      code_mask = (1 << cur_code_size) - 1;

      // Don't update prev_code ?
      prev_code = null;
      continue;
    } else if (code === eoi_code) {
      break;
    }

    // We have a similar situation as the decoder, where we want to store
    // variable length entries (code table entries), but we want to do in a
    // faster manner than an array of arrays.  The code below stores sort of a
    // linked list within the code table, and then "chases" through it to
    // construct the dictionary entries.  When a new entry is created, just the
    // last byte is stored, and the rest (prefix) of the entry is only
    // referenced by its table entry.  Then the code chases through the
    // prefixes until it reaches a single byte code.  We have to chase twice,
    // first to compute the length, and then to actually copy the data to the
    // output (backwards, since we know the length).  The alternative would be
    // storing something in an intermediate stack, but that doesn't make any
    // more sense.  I implemented an approach where it also stored the length
    // in the code table, although it's a bit tricky because you run out of
    // bits (12 + 12 + 8), but I didn't measure much improvements (the table
    // entries are generally not the long).  Even when I created benchmarks for
    // very long table entries the complexity did not seem worth it.
    // The code table stores the prefix entry in 12 bits and then the suffix
    // byte in 8 bits, so each entry is 20 bits.

    var chase_code = code < next_code ? code : prev_code;

    // Chase what we will output, either {CODE} or {CODE-1}.
    var chase_length = 0;
    var chase = chase_code;
    while (chase > clear_code) {
      chase = code_table[chase] >> 8;
      ++chase_length;
    }

    var k = chase;

    var op_end = op + chase_length + (chase_code !== code ? 1 : 0);
    if (op_end > output_length) {
      console.log("Warning, gif stream longer than expected.");
      return;
    }

    // Already have the first byte from the chase, might as well write it fast.
    output[op++] = k;

    op += chase_length;
    var b = op;  // Track pointer, writing backwards.

    if (chase_code !== code)  // The case of emitting {CODE-1} + k.
      output[op++] = k;

    chase = chase_code;
    while (chase_length--) {
      chase = code_table[chase];
      output[--b] = chase & 0xff;  // Write backwards.
      chase >>= 8;  // Pull down to the prefix code.
    }

    if (prev_code !== null && next_code < 4096) {
      code_table[next_code++] = prev_code << 8 | k;
      // TODO(deanm): Figure out this clearing vs code growth logic better.  I
      // have an feeling that it should just happen somewhere else, for now it
      // is awkward between when we grow past the max and then hit a clear code.
      // For now just check if we hit the max 12-bits (then a clear code should
      // follow, also of course encoded in 12-bits).
      if (next_code >= code_mask+1 && cur_code_size < 12) {
        ++cur_code_size;
        code_mask = code_mask << 1 | 1;
      }
    }

    prev_code = code;
  }

  if (op !== output_length) {
    console.log("Warning, gif stream shorter than expected.");
  }

  return output;
}

module.exports = GifReader;

},{}],7:[function(require,module,exports){
/**
 * This class handles LZW encoding
 * Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
 * @author Kevin Weiner (original Java version - kweiner@fmsware.com)
 * @author Thibault Imbert (AS3 version - bytearray.org)
 * @author Kevin Kwok (JavaScript version - https://github.com/antimatter15/jsgif)
 * @version 0.1 AS3 implementation
 */

var LZWEncoder = function() {

  var exports = {};
  var EOF = -1;
  var imgW;
  var imgH;
  var pixAry;
  var initCodeSize;
  var remaining;
  var curPixel;

  // GIFCOMPR.C - GIF Image compression routines
  // Lempel-Ziv compression based on 'compress'. GIF modifications by
  // David Rowley (mgardi@watdcsu.waterloo.edu)
  // General DEFINEs

  var BITS = 12;
  var HSIZE = 5003; // 80% occupancy

  // GIF Image compression - modified 'compress'
  // Based on: compress.c - File compression ala IEEE Computer, June 1984.
  // By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
  // Jim McKie (decvax!mcvax!jim)
  // Steve Davies (decvax!vax135!petsd!peora!srd)
  // Ken Turkowski (decvax!decwrl!turtlevax!ken)
  // James A. Woods (decvax!ihnp4!ames!jaw)
  // Joe Orost (decvax!vax135!petsd!joe)

  var n_bits; // number of bits/code
  var maxbits = BITS; // user settable max # bits/code
  var maxcode; // maximum code, given n_bits
  var maxmaxcode = 1 << BITS; // should NEVER generate this code
  var htab = [];
  var codetab = [];
  var hsize = HSIZE; // for dynamic table sizing
  var free_ent = 0; // first unused entry

  // block compression parameters -- after all codes are used up,
  // and compression rate changes, start over.

  var clear_flg = false;

  // Algorithm: use open addressing double hashing (no chaining) on the
  // prefix code / next character combination. We do a variant of Knuth's
  // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
  // secondary probe. Here, the modular division first probe is gives way
  // to a faster exclusive-or manipulation. Also do block compression with
  // an adaptive reset, whereby the code table is cleared when the compression
  // ratio decreases, but after the table fills. The variable-length output
  // codes are re-sized at this point, and a special CLEAR code is generated
  // for the decompressor. Late addition: construct the table according to
  // file size for noticeable speed improvement on small files. Please direct
  // questions about this implementation to ames!jaw.

  var g_init_bits;
  var ClearCode;
  var EOFCode;

  // output
  // Output the given code.
  // Inputs:
  // code: A n_bits-bit integer. If == -1, then EOF. This assumes
  // that n_bits =< wordsize - 1.
  // Outputs:
  // Outputs code to the file.
  // Assumptions:
  // Chars are 8 bits long.
  // Algorithm:
  // Maintain a BITS character long buffer (so that 8 codes will
  // fit in it exactly). Use the VAX insv instruction to insert each
  // code in turn. When the buffer fills up empty it and start over.

  var cur_accum = 0;
  var cur_bits = 0;
  var masks = [0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF];

  // Number of characters so far in this 'packet'
  var a_count;

  // Define the storage for the packet accumulator
  var accum = [];

  var LZWEncoder = exports.LZWEncoder = function LZWEncoder(width, height, pixels, color_depth) {
    imgW = width;
    imgH = height;
    pixAry = pixels;
    initCodeSize = Math.max(2, color_depth);
  };

  // Add a character to the end of the current packet, and if it is 254
  // characters, flush the packet to disk.
  var char_out = function char_out(c, outs) {
    accum[a_count++] = c;
    if (a_count >= 254) flush_char(outs);
  };

  // Clear out the hash table
  // table clear for block compress

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

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

  var compress = exports.compress = function compress(init_bits, outs) {

    var fcode;
    var i; /* = 0 */
    var c;
    var ent;
    var disp;
    var hsize_reg;
    var hshift;

    // Set up the globals: g_init_bits - initial number of bits
    g_init_bits = init_bits;

    // Set up the necessary values
    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; // clear packet

    ent = nextPixel();

    hshift = 0;
    for (fcode = hsize; fcode < 65536; fcode *= 2)
      ++hshift;
    hshift = 8 - hshift; // set hash code range bound

    hsize_reg = hsize;
    cl_hash(hsize_reg); // clear hash table

    output(ClearCode, outs);

    outer_loop: while ((c = nextPixel()) != EOF) {
      fcode = (c << maxbits) + ent;
      i = (c << hshift) ^ ent; // xor hashing

      if (htab[i] == fcode) {
        ent = codetab[i];
        continue;
      }

      else if (htab[i] >= 0) { // non-empty slot

        disp = hsize_reg - i; // secondary hash (after G. Knott)
        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 < maxmaxcode) {
        codetab[i] = free_ent++; // code -> hashtable
        htab[i] = fcode;
      }
      else cl_block(outs);
    }

                // Put out the final code.
                output(ent, outs);
                output(EOFCode, outs);
  };

  // ----------------------------------------------------------------------------
  var encode = exports.encode = function encode(os) {
    os.writeByte(initCodeSize); // write "initial code size" byte
    remaining = imgW * imgH; // reset navigation variables
    curPixel = 0;
    compress(initCodeSize + 1, os); // compress and write the pixel data
    os.writeByte(0); // write block terminator
  };

  // Flush the packet to disk, and reset the accumulator
  var flush_char = function flush_char(outs) {
    if (a_count > 0) {
      outs.writeByte(a_count);
      outs.writeBytes(accum, 0, a_count);
      a_count = 0;
    }
  };

  var MAXCODE = function MAXCODE(n_bits) {
    return (1 << n_bits) - 1;
  };

  // ----------------------------------------------------------------------------
  // Return the next pixel from the image
  // ----------------------------------------------------------------------------

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

  var output = 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 & 0xff), outs);
      cur_accum >>= 8;
      cur_bits -= 8;
    }

    // If the next entry is going to be too big for the code size,
    // then increase it, if possible.

    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 == maxbits) maxcode = maxmaxcode;
        else maxcode = MAXCODE(n_bits);
      }
    }

    if (code == EOFCode) {

      // At EOF, write the rest of the buffer.
      while (cur_bits > 0) {
        char_out((cur_accum & 0xff), outs);
        cur_accum >>= 8;
        cur_bits -= 8;
      }

      flush_char(outs);
    }
  };

  LZWEncoder.apply(this, arguments);
  return exports;
};

module.exports = LZWEncoder;

},{}],8:[function(require,module,exports){
/*
 * NeuQuant Neural-Net Quantization Algorithm
 * ------------------------------------------
 *
 * Copyright (c) 1994 Anthony Dekker
 *
 * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
 * "Kohonen neural networks for optimal colour quantization" in "Network:
 * Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
 * the algorithm.
 *
 * Any party obtaining a copy of these files from the author, directly or
 * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
 * world-wide, paid up, royalty-free, nonexclusive right and license to deal in
 * this software and documentation files (the "Software"), including without
 * limitation the rights to use, copy, modify, merge, publish, distribute,
 * sublicense, and/or sell copies of the Software, and to permit persons who
 * receive copies from any such party to do so, with the only requirement being
 * that this copyright notice remain intact.
 */

/*
 * This class handles Neural-Net quantization algorithm
 * @author Kevin Weiner (original Java version - kweiner@fmsware.com)
 * @author Thibault Imbert (AS3 version - bytearray.org)
 * @author Kevin Kwok (JavaScript version - https://github.com/antimatter15/jsgif)
 * @version 0.1 AS3 implementation
 */

var NeuQuant = function() {

  var exports = {};
  var netsize = 256; /* number of colours used */

  /* four primes near 500 - assume no image has a length so large */
  /* that it is divisible by all four primes */

  var prime1 = 499;
  var prime2 = 491;
  var prime3 = 487;
  var prime4 = 503;
  var minpicturebytes = (3 * prime4); /* minimum size for input image */

  /*
   * Program Skeleton ---------------- [select samplefac in range 1..30] [read
   * image from input file] pic = (unsigned char*) malloc(3*width*height);
   * initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output
   * image header, using writecolourmap(f)] inxbuild(); write output image using
   * inxsearch(b,g,r)
   */

  /*
   * Network Definitions -------------------
   */

  var maxnetpos = (netsize - 1);
  var netbiasshift = 4; /* bias for colour values */
  var ncycles = 100; /* no. of learning cycles */

  /* defs for freq and bias */
  var intbiasshift = 16; /* bias for fractions */
  var intbias = (1 << intbiasshift);
  var gammashift = 10; /* gamma = 1024 */
  var gamma = (1 << gammashift);
  var betashift = 10;
  var beta = (intbias >> betashift); /* beta = 1/1024 */
  var betagamma = (intbias << (gammashift - betashift));

  /* defs for decreasing radius factor */
  var initrad = (netsize >> 3); /* for 256 cols, radius starts */
  var radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
  var radiusbias = (1 << radiusbiasshift);
  var initradius = (initrad * radiusbias); /* and decreases by a */
  var radiusdec = 30; /* factor of 1/30 each cycle */

  /* defs for decreasing alpha factor */
  var alphabiasshift = 10; /* alpha starts at 1.0 */
  var initalpha = (1 << alphabiasshift);
  var alphadec; /* biased by 10 bits */

  /* radbias and alpharadbias used for radpower calculation */
  var radbiasshift = 8;
  var radbias = (1 << radbiasshift);
  var alpharadbshift = (alphabiasshift + radbiasshift);
  var alpharadbias = (1 << alpharadbshift);

  /*
   * Types and Global Variables --------------------------
   */

  var thepicture; /* the input image itself */
  var lengthcount; /* lengthcount = H*W*3 */
  var samplefac; /* sampling factor 1..30 */

  // typedef int pixel[4]; /* BGRc */
  var network; /* the network itself - [netsize][4] */
  var netindex = [];

  /* for network lookup - really 256 */
  var bias = [];

  /* bias and freq arrays for learning */
  var freq = [];
  var radpower = [];

  var NeuQuant = exports.NeuQuant = function NeuQuant(thepic, len, sample) {

    var i;
    var p;

    thepicture = thepic;
    lengthcount = len;
    samplefac = sample;

    network = new Array(netsize);

    for (i = 0; i < netsize; i++) {

      network[i] = new Array(4);
      p = network[i];
      p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
      freq[i] = intbias / netsize; /* 1/netsize */
      bias[i] = 0;
    }
  };

  var colorMap = function colorMap() {

    var map = [];
    var index = new Array(netsize);

    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;
  };

  /*
   * Insertion sort of network and building of netindex[0..255] (to do after
   * unbias)
   * -------------------------------------------------------------------------------
   */

  var inxbuild = function inxbuild() {

    var i;
    var j;
    var smallpos;
    var smallval;
    var p;
    var q;
    var previouscol;
    var startpos;

    previouscol = 0;
    startpos = 0;
    for (i = 0; i < netsize; i++) {

      p = network[i];
      smallpos = i;
      smallval = p[1]; /* index on g */

      /* find smallest in i..netsize-1 */
      for (j = i + 1; j < netsize; j++) {

        q = network[j];
        if (q[1] < smallval) { /* index on g */
          smallpos = j;
          smallval = q[1]; /* index on g */
        }
      }
      q = network[smallpos];

      /* swap p (i) and q (smallpos) entries */
      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;
      }

      /* smallval entry is now in position i */

      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; /* really 256 */
  };

  /*
   * Main Learning Loop ------------------
   */

  var learn = function learn() {

    var i;
    var j;
    var b;
    var g;
    var r;
    var radius;
    var rad;
    var alpha;
    var step;
    var delta;
    var samplepixels;
    var p;
    var pix;
    var lim;

    if (lengthcount < minpicturebytes) samplefac = 1;

    alphadec = 30 + ((samplefac - 1) / 3);
    p = thepicture;
    pix = 0;
    lim = lengthcount;
    samplepixels = lengthcount / (3 * samplefac);
    delta = (samplepixels / ncycles) | 0;
    alpha = initalpha;
    radius = initradius;

    rad = radius >> radiusbiasshift;
    if (rad <= 1) rad = 0;

    for (i = 0; i < rad; i++) radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));

    if (lengthcount < minpicturebytes) 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;
      }
    }

    i = 0;
    while (i < samplepixels) {

      b = (p[pix + 0] & 0xff) << netbiasshift;
      g = (p[pix + 1] & 0xff) << netbiasshift;
      r = (p[pix + 2] & 0xff) << netbiasshift;
      j = contest(b, g, r);

      altersingle(alpha, j, b, g, r);
      if (rad !== 0) alterneigh(rad, j, b, g, r); /* alter neighbours */

      pix += step;
      if (pix >= lim) 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));
      }
    }
  };

  /*
   ** Search for BGR values 0..255 (after net is unbiased) and return colour
   * index
   * ----------------------------------------------------------------------------
   */

  var map = exports.map = function map(b, g, r) {

    var i;
    var j;
    var dist;
    var a;
    var bestd;
    var p;
    var best;

    bestd = 1000; /* biggest possible dist is 256*3 */
    best = -1;
    i = netindex[g]; /* index on g */
    j = i - 1; /* start at netindex[g] and work outwards */

    while ((i < netsize) || (j >= 0)) {

      if (i < netsize) {
        p = network[i];
        dist = p[1] - g; /* inx key */

        if (dist >= bestd) i = netsize; /* stop iter */

        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]; /* inx key - reverse dif */

        if (dist >= bestd) j = -1; /* stop iter */

        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);
  };

  var process = exports.process = function process() {
    learn();
    unbiasnet();
    inxbuild();
    return colorMap();
  };

  /*
   * Unbias network to give byte values 0..255 and record position i to prepare
   * for sort
   * -----------------------------------------------------------------------------------
   */

  var unbiasnet = function unbiasnet() {

    var i;
    var j;

    for (i = 0; i < netsize; i++) {
      network[i][0] >>= netbiasshift;
      network[i][1] >>= netbiasshift;
      network[i][2] >>= netbiasshift;
      network[i][3] = i; /* record colour no */
    }
  };

  /*
   * Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in
   * radpower[|i-j|]
   * ---------------------------------------------------------------------------------
   */

  var alterneigh = function alterneigh(rad, i, b, g, r) {

    var j;
    var k;
    var lo;
    var hi;
    var a;
    var m;
    var p;

    lo = i - rad;
    if (lo < -1) lo = -1;

    hi = i + rad;
    if (hi > netsize) hi = netsize;

    j = i + 1;
    k = i - 1;
    m = 1;

    while ((j < hi) || (k > lo)) {
      a = radpower[m++];

      if (j < hi) {
        p = network[j++];

        try {
          p[0] -= (a * (p[0] - b)) / alpharadbias;
          p[1] -= (a * (p[1] - g)) / alpharadbias;
          p[2] -= (a * (p[2] - r)) / alpharadbias;
        } catch (e) {} // prevents 1.3 miscompilation
      }

      if (k > lo) {
        p = network[k--];

        try {
          p[0] -= (a * (p[0] - b)) / alpharadbias;
          p[1] -= (a * (p[1] - g)) / alpharadbias;
          p[2] -= (a * (p[2] - r)) / alpharadbias;
        } catch (e) {}
      }
    }
  };

  /*
   * Move neuron i towards biased (b,g,r) by factor alpha
   * ----------------------------------------------------
   */

  var altersingle = function altersingle(alpha, i, b, g, r) {

    /* alter hit neuron */
    var n = network[i];
    n[0] -= (alpha * (n[0] - b)) / initalpha;
    n[1] -= (alpha * (n[1] - g)) / initalpha;
    n[2] -= (alpha * (n[2] - r)) / initalpha;
  };

  /*
   * Search for biased BGR values ----------------------------
   */

  var contest = function contest(b, g, r) {

    /* finds closest neuron (min dist) and updates freq */
    /* finds best neuron (min dist-bias) and returns position */
    /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
    /* bias[i] = gamma*((1/netsize)-freq[i]) */

    var i;
    var dist;
    var a;
    var biasdist;
    var betafreq;
    var bestpos;
    var bestbiaspos;
    var bestd;
    var bestbiasd;
    var n;

    bestd = ~ (1 << 31);
    bestbiasd = bestd;
    bestpos = -1;
    bestbiaspos = bestpos;

    for (i = 0; i < netsize; i++) {
      n = network[i];
      dist = n[0] - b;
      if (dist < 0) dist = -dist;
      a = n[1] - g;
      if (a < 0) a = -a;
      dist += a;
      a = n[2] - r;
      if (a < 0) a = -a;
      dist += a;

      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);
  };

  NeuQuant.apply(this, arguments);
  return exports;
};

module.exports = NeuQuant;

},{}],9:[function(require,module,exports){
'use strict';

var GIF = require('readwrite-gif'),
  btoa = require('isomorphic-base64').btoa;

function isGIF(url) {
  return /\.gif$/i.test(url);
}

function isDefined(value) {
  return typeof value !== 'undefined';
}

function isString(value) {
  return typeof value === 'string';
}

var BASE64_DATAURI_REGEX = /^data:(\w+\/\w+);base64,(.*)$/;

function dataURLtoBase64(dataUrl) {
  var match = dataUrl.match(BASE64_DATAURI_REGEX);

  if (!match) {
    throw new Error("[MemePlayer:nodatauri] Can't match url: " + dataUrl +
      " to regex: " + BASE64_DATAURI_REGEX);
  }
  return match[2];
}

function getHttpAsArrayBuffer(url) {
  return fetch(url).then(function (response) {
    if (response.status >= 400) {
      return Promise.reject(
        new Error('[MemePlayer:http] HTTP request returned ' + response.status));
    }
    return response.arrayBuffer();
  });
}

function createImageInstance(canvasInstance) {
  // Hack: We want to use a native browser Image if we are in a browser.
  //       But if we are using node-canvas, we need to use it's Image
  //       implementation, ideally without require'ing it because that
  //       would make working with browserify difficult.
  if (typeof Image !== 'undefined') {
    // Browsers.
    return new Image();
  } else {
    // node-canvas.
    return new canvasInstance.constructor.Image();
  }
}

function createFrames(player, url) {
  var img, promise;

  if (isGIF(url)) {
    return getHttpAsArrayBuffer(url).then(function (data) {
      var decoder = new GIF.Decoder(new Uint8Array(data)),
        gif = { frames: [] },
        nFrames = decoder.numFrames(),
        imageData,
        lastImageRawData,
        frameInfo;

      player.$$ctx.fillStyle = "white";
      player.$$ctx.fillRect(0, 0, player.$$width, player.$$height);
      if (nFrames > 0) {
        imageData = player.$$ctx.createImageData(decoder.width, decoder.height);
        decoder.decodeAndBlitFrameRGBA(0, imageData.data);
        frameInfo = decoder.frameInfo(0);
        gif.frames.push({
          delay: frameInfo.delay,
          frame: imageData
        });
        lastImageRawData = imageData.data;
      }
      for (var i = 1; i < nFrames; i++) {
        imageData = player.$$ctx.createImageData(decoder.width, decoder.height);
        for (var j = 0; j < imageData.data.length; j++) {
          imageData.data[j] = lastImageRawData[j];
        }
        decoder.decodeAndBlitFrameRGBA(i, imageData.data);
        frameInfo = decoder.frameInfo(i);
        gif.frames.push({
          delay: frameInfo.delay,
          frame: imageData
        });
        lastImageRawData = imageData.data;
      }
      return gif;
    });
  } else {
    img = createImageInstance(player.$$canvas);
    img.crossOrigin = 'anonymous';
    promise = new Promise(function (resolve) {
      img.addEventListener('load', function () {
        var imageData;

        player.$$ctx.fillStyle = "white";
        player.$$ctx.fillRect(0, 0, player.$$width, player.$$height);
        player.$$ctx.drawImage(img, 0, 0);
        imageData = player.$$ctx.getImageData(0, 0, player.$$width, player.$$height);
        resolve({
          frames: [{ frame: imageData }]
        });
      });
    });
    img.src = url;
    return promise;
  }
}

function bestSplit (ctx, value) {
  var words = value.split(/\s+/),
      i,
      metrics,
      upperWidth,
      lowerWidth,
      renderWidth,
      minWidth,
      upperText,
      lowerText,
      bestValue;

  metrics = ctx.measureText(value);
  minWidth = metrics.width;
  bestValue = value;

  for (i = 1; i < words.length; i++) {
    upperText = words.slice(0, i).join(' ');
    metrics = ctx.measureText(upperText);
    upperWidth = metrics.width;
    lowerText = words.slice(i).join(' ');
    metrics = ctx.measureText(lowerText);
    lowerWidth = metrics.width;
    renderWidth = Math.max(upperWidth, lowerWidth);
    if (renderWidth < minWidth) {
      minWidth = renderWidth;
      bestValue = [upperText, lowerText];
    }
  }

  return {
    width: minWidth,
    value: bestValue
  };
}

function renderText (ctx, text, img) {
  var renderLine, xPos, yPos, upperOffset, lowerOffset;

  xPos = {
    left: 0,
    center: img.width/2,
    right: img.width
  };

  yPos = {
    top: 0,
    middle: img.height/2,
    bottom: img.height
  };

  upperOffset = {
    top: 0,
    middle: -30,
    bottom: -60
  };

  lowerOffset = {
    top: 60,
    middle: 30,
    bottom: 0
  };

  renderLine = function (value, align, baseline) {
    var metrics, scale, opt;

    ctx.textAlign = align;
    ctx.textBaseline = baseline;
    metrics = ctx.measureText(value);
    scale = Math.min(1.0, img.width / metrics.width);
    if (scale <= 0.5) {
      opt = bestSplit(ctx, value);
      scale = Math.min(1.0, img.width / opt.width);
      value = opt.value;
    }

    ctx.save();
    ctx.translate(xPos[align], yPos[baseline]);
    ctx.scale(scale, scale);
    if (isString(value)) {
      ctx.fillText(value, 0, 0);
      ctx.strokeText(value, 0, 0);
    } else {
      ctx.save();
      ctx.translate(0, upperOffset[baseline]);
      ctx.fillText(value[0], 0, 0);
      ctx.strokeText(value[0], 0, 0);
      ctx.restore();
      ctx.translate(0, lowerOffset[baseline]);
      ctx.fillText(value[1], 0, 0);
      ctx.strokeText(value[1], 0, 0);
    }
    ctx.restore();
  };

  ctx.font = "60px Impact";
  ctx.fillStyle = "white";
  ctx.strokeStyle = "black";
  ctx.lineWidth = 2;

  renderLine(text.top.value, text.top.align, 'top');
  renderLine(text.middle.value, text.middle.align, 'middle');
  renderLine(text.bottom.value, text.bottom.align, 'bottom');
}

function createContentData(canvas, ctx, text, image) {
  var encoder,
    frame,
    frameIndex;

  if (image.frames.length > 1) {
    // animated GIF
    frameIndex = 0;
    encoder = new GIF.Encoder();
    encoder.setRepeat(0);
    encoder.start();
    return new Promise(function (resolve) {
      var renderNextFrame = function () {
        frame = image.frames[frameIndex++];
        encoder.setDelay(frame.delay * 10); // 1/100ths sec -> ms
        ctx.fillStyle = "white";
        ctx.fillRect(0, 0, frame.frame.width, frame.frame.height);
        ctx.putImageData(frame.frame, 0, 0);
        renderText(ctx, text, frame.frame);
        encoder.addFrame(ctx);

        if (frameIndex === image.frames.length) {
          encoder.finish();
          resolve({
            data: btoa(encoder.stream().getData()),
            contentType: 'image/gif'
          });
        } else {
          // perf: don't bog down the event loop.
          setTimeout(renderNextFrame, 0);
        }
      };

      renderNextFrame();
    });
  } else {
    // JPG
    frame = image.frames[0];
    ctx.fillStyle = "white";
    ctx.fillRect(0, 0, frame.frame.width, frame.frame.height);
    ctx.putImageData(frame.frame, 0, 0);
    renderText(ctx, text, frame.frame);
    return Promise.resolve({
      data: dataURLtoBase64(canvas.toDataURL('image/jpeg')),
      contentType: 'image/jpeg'
    });
  }
}

/**
 * @class MemePlayer
 * @description
 * Enhances a canvas with meme viewing and editing capabilities.
 *
 * @param {!HTMLCanvasElement} canvas The canvas element to render into.
 * @param {!number} width The width of the canvas, in pixels.
 * @param {!number} height The height of the canvas, in pixels.
 */
function MemePlayer(canvas, width, height) {
  this.$$canvas = canvas;
  this.$$ctx = canvas.getContext('2d');
  this.$$image = null;
  this.$$text = {
    top: { value: '', align: 'center' },
    middle: { value: '', align: 'center' },
    bottom: { value: '', align: 'center' }
  };
  this.$$width = width;
  this.$$height = height;
  canvas.setAttribute('width', width);
  canvas.setAttribute('height', height);
}

/**
 * @method MemePlayer#setWidth
 * @description
 * Sets the width of the canvas.
 *
 * @param {number} width The new width of the canvas, in pixels.
 */
MemePlayer.prototype.setWidth = function (width) {
  this.$$width = width;
  this.$$canvas.setAttribute('width', width);
  this.$$redraw();
};

/**
 * @method MemePlayer#setHeight
 * @description
 * Sets the height of the canvas.
 *
 * @param {number} height The new height of the canvas, in pixels.
 */
MemePlayer.prototype.setHeight = function (height) {
  this.$$height = height;
  this.$$canvas.setAttribute('height', height);
  this.$$redraw();
};

/**
 * @method MemePlayer#loadTemplate
 * @description
 * Loads a template image and starts displaying it on the canvas.
 *
 * @param {!string} url The URL of the image to display. JPG, PNG and GIF are
 *    supported image formats.
 * @returns {Promise<Template>}
 */
MemePlayer.prototype.loadTemplate = function (url) {
  return createFrames(this, url).then(function (image) {
    this.$$image = image;
    this.$$frameIndex = 0;
    this.$$redraw();
    return image;
  }.bind(this));
};

/**
 * @private
 */
MemePlayer.prototype.$$redraw = function () {
  var ctx = this.$$ctx,
    image = this.$$image,
    text = this.$$text,
    timeout = this.$$timeout,
    frame;

  if (image) {
    frame = image.frames[this.$$frameIndex].frame;
    if (timeout) {
      clearTimeout(timeout);
      this.$$timeout = null;
    }
    ctx.fillStyle = 'white';
    ctx.fillRect(0, 0, frame.width, frame.height);
    ctx.putImageData(frame, 0, 0);
    renderText(ctx, text, frame);

    if (isDefined(image.frames[this.$$frameIndex].delay)) {
      this.$$timeout = setTimeout(function () {
        this.$$timeout = null;
        if (this.$$image) {
          this.$$frameIndex = (this.$$frameIndex + 1) % image.frames.length;
          this.$$redraw();
        }
      }.bind(this), image.frames[this.$$frameIndex].delay * 10);
    }
  }
};

/**
 * An object containing meme text to render over an image.
 * @typedef {Object} MemePlayer~MemeText
 * @property {Object} top An object representing the top line of text, if any.
 * @property {string} top.value The actual text content of the top line.
 * @property {string} top.align The alignment of the top line. Must be one of
 *    'left', 'right' or 'center'.
 * @property {Object} middle An object representing the middle line of text, if any.
 * @property {string} middle.value The actual text content of the middle line.
 * @property {string} middle.align The alignment of the middle line. Must be one of
 *    'left', 'right' or 'center'.
 * @property {Object} bottom An object representing the bottom line of text, if any.
 * @property {string} bottom.value The actual text content of the bottom line.
 * @property {string} bottom.align The alignment of the bottom line. Must be one of
 *    'left', 'right' or 'center'.
 */

/**
 * @method MemePlayer#setText
 * @description
 * Sets the meme text and re-renders the meme.
 *
 * @param {MemeText} text The new meme text to render.
 */
MemePlayer.prototype.setText = function (text) {
  this.$$text.top.value = text.top.value || '';
  this.$$text.top.align = text.top.align || 'center';
  this.$$text.middle.value = text.middle.value || '';
  this.$$text.middle.align = text.middle.align || 'center';
  this.$$text.bottom.value = text.bottom.value || '';
  this.$$text.bottom.align = text.bottom.align || 'center';
  this.$$redraw();
};

/**
 * @typedef {Object} MemePlayer~MemeData
 * @property {string} data The base64 encoded meme data.
 * @property {string} contentType The MIME type of the base64 encoded data.
 *    Guaranteed to be an image type, and if the loaded template was an animated
 *    GIF with multiple frames it's also guaranteed to be 'image/gif'.
 */

/**
 * @method MemePlayer#export
 * @description
 * Exports the content of the player to a data URL.
 *
 * @returns {Promise<MemeData>}
 */
MemePlayer.prototype.export = function () {
  return createContentData(this.$$canvas, this.$$ctx, this.$$text, this.$$image);
};

module.exports = MemePlayer;

},{"isomorphic-base64":3,"readwrite-gif":4}]},{},[1]);


text:
.class Landroid/support/v4/view/ViewConfigurationCompat$HoneycombViewConfigurationVersionImpl;
.super Landroid/support/v4/view/ViewConfigurationCompat$BaseViewConfigurationVersionImpl;
.source "ViewConfigurationCompat.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/support/v4/view/ViewConfigurationCompat;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x8
    name = "HoneycombViewConfigurationVersionImpl"
.end annotation

# direct methods
.method constructor <init>()V
    .locals 0

    .prologue
    .line 47
    invoke-direct {p0}, Landroid/support/v4/view/ViewConfigurationCompat$BaseViewConfigurationVersionImpl;-><init>()V

    return-void
.end method

# virtual methods
.method public hasPermanentMenuKey(Landroid/view/ViewConfiguration;)Z
    .locals 1
    .param p1, "config"    # Landroid/view/ViewConfiguration;

    .prologue
    .line 51
    const/4 v0, 0x0

    return v0
.end method


text:
namespace segmatch {

/// \brief Utility function for swapping two values.
template<typename T>
bool swap_if_gt(T& a, T& b) {
  if (a > b) {
    std::swap(a, b);
    return true;
  }
  return false;
}

// EigenvalueBasedDescriptor methods definition
EigenvalueBasedDescriptor::EigenvalueBasedDescriptor(const DescriptorsParameters& parameters) {}

void EigenvalueBasedDescriptor::describe(const Segment& segment, Features* features) {
  CHECK_NOTNULL(features);
  std::feclearexcept(FE_ALL_EXCEPT);

  // Find the variances.
  const SegmentView& segment_view = segment.getLastView();
  const size_t kNPoints = segment_view.point_cloud.points.size();
  PointCloud variances;
  for (size_t i = 0u; i < kNPoints; ++i) {
    variances.push_back(PclPoint());
    variances.points[i].x = segment_view.point_cloud.points[i].x - segment_view.centroid.x;
    variances.points[i].y = segment_view.point_cloud.points[i].y - segment_view.centroid.y;
    variances.points[i].z = segment_view.point_cloud.points[i].z - segment_view.centroid.z;
  }

  // Find the covariance matrix. Since it is symmetric, we only bother with the upper diagonal.
  const std::vector<size_t> row_indices_to_access = {0,0,0,1,1,2};
  const std::vector<size_t> col_indices_to_access = {0,1,2,1,2,2};
  Eigen::Matrix3f covariance_matrix;
  for (size_t i = 0u; i < row_indices_to_access.size(); ++i) {
    const size_t row = row_indices_to_access[i];
    const size_t col = col_indices_to_access[i];
    double covariance = 0;
    for (size_t k = 0u; k < kNPoints; ++k) {
      covariance += variances.points[k].data[row] * variances.points[k].data[col];
    }
    covariance /= kNPoints;
    covariance_matrix(row,col) = covariance;
    covariance_matrix(col,row) = covariance;
  }

  // Compute eigenvalues of covariance matrix.
  constexpr bool compute_eigenvectors = false;
  Eigen::EigenSolver<Eigen::Matrix3f> eigenvalues_solver(covariance_matrix, compute_eigenvectors);
  std::vector<float> eigenvalues(3, 0.0);
  eigenvalues.at(0) = eigenvalues_solver.eigenvalues()[0].real();
  eigenvalues.at(1) = eigenvalues_solver.eigenvalues()[1].real();
  eigenvalues.at(2) = eigenvalues_solver.eigenvalues()[2].real();
  if (eigenvalues_solver.eigenvalues()[0].imag() != 0.0 ||
      eigenvalues_solver.eigenvalues()[1].imag() != 0.0 ||
      eigenvalues_solver.eigenvalues()[2].imag() != 0.0 ) {
    LOG(ERROR) << "Eigenvalues should not have non-zero imaginary component.";
  }

  // Sort eigenvalues from smallest to largest.
  swap_if_gt(eigenvalues.at(0), eigenvalues.at(1));
  swap_if_gt(eigenvalues.at(0), eigenvalues.at(2));
  swap_if_gt(eigenvalues.at(1), eigenvalues.at(2));

  // Normalize eigenvalues.
  double sum_eigenvalues = eigenvalues.at(0) + eigenvalues.at(1) + eigenvalues.at(2);
  double e1 = eigenvalues.at(0) / sum_eigenvalues;
  double e2 = eigenvalues.at(1) / sum_eigenvalues;
  double e3 = eigenvalues.at(2) / sum_eigenvalues;
  LOG_IF(ERROR, e1 == e2 || e2 == e3 || e1 == e3) << "Eigenvalues should not be equal.";

  // Store inside features.
  const double sum_of_eigenvalues = e1 + e2 + e3;
  constexpr double kOneThird = 1.0/3.0;
  CHECK_NE(e1, 0.0);
  CHECK_NE(sum_of_eigenvalues, 0.0);

  const double kNormalizationPercentile = 1.0;

  const double kLinearityMax = 28890.9 * kNormalizationPercentile;
  const double kPlanarityMax = 95919.2 * kNormalizationPercentile;
  const double kScatteringMax = 124811 * kNormalizationPercentile;
  const double kOmnivarianceMax = 0.278636 * kNormalizationPercentile;
  const double kAnisotropyMax = 124810 * kNormalizationPercentile;
  const double kEigenEntropyMax = 0.956129 * kNormalizationPercentile;
  const double kChangeOfCurvatureMax = 0.99702 * kNormalizationPercentile;

  const double kNPointsMax = 13200 * kNormalizationPercentile;

  Feature eigenvalue_feature("eigenvalue");
  eigenvalue_feature.push_back(FeatureValue("linearity", (e1 - e2) / e1 / kLinearityMax));
  eigenvalue_feature.push_back(FeatureValue("planarity", (e2 - e3) / e1 / kPlanarityMax));
  eigenvalue_feature.push_back(FeatureValue("scattering", e3 / e1 / kScatteringMax));
  eigenvalue_feature.push_back(FeatureValue("omnivariance", std::pow(e1 * e2 * e3, kOneThird) / kOmnivarianceMax));
  eigenvalue_feature.push_back(FeatureValue("anisotropy", (e1 - e3) / e1 / kAnisotropyMax));
  eigenvalue_feature.push_back(FeatureValue("eigen_entropy",
                                            (e1 * std::log(e1)) + (e2 * std::log(e2)) + (e3 * std::log(e3)) / kEigenEntropyMax));
  eigenvalue_feature.push_back(FeatureValue("change_of_curvature", e3 / sum_of_eigenvalues / kChangeOfCurvatureMax));

  PclPoint point_min, point_max;

  pcl::getMinMax3D(segment.getLastView().point_cloud, point_min, point_max);

  double diff_x, diff_y, diff_z;

  diff_x = point_max.x - point_min.x;
  diff_y = point_max.y - point_min.y;
  diff_z = point_max.z - point_min.z;

  if (diff_z < diff_x && diff_z < diff_y) {
    eigenvalue_feature.push_back(FeatureValue("pointing_up", 0.2));
  } else {
    eigenvalue_feature.push_back(FeatureValue("pointing_up", 0.0));
  }

  CHECK_EQ(eigenvalue_feature.size(), kDimension) << "Feature has the wrong dimension";
  features->replaceByName(eigenvalue_feature);

  // Check that there were no overflows, underflows, or invalid float operations.
  if (std::fetestexcept(FE_OVERFLOW)) {
    LOG(ERROR) << "Overflow error in eigenvalue feature computation.";
  } else if (std::fetestexcept(FE_UNDERFLOW)) {
    LOG(ERROR) << "Underflow error in eigenvalue feature computation.";
  } else if (std::fetestexcept(FE_INVALID)) {
    LOG(ERROR) << "Invalid Flag error in eigenvalue feature computation.";
  } else if (std::fetestexcept(FE_DIVBYZERO)) {
    LOG(ERROR) << "Divide by zero error in eigenvalue feature computation.";
  }
}

} // namespace segmatch