(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) {
        window.h2m = require('./index')

    }, {"./index": 5}],
    2: [function (require, module, exports) {
        /**
         * http://commonmark.org/help/
         */

        var LI_HEADER = 'H2M_LI_HEADER'

        module.exports = {
            em: function (node) {
                if (node.md) {
                    return `*${node.md}*`
                }
            },
            strong: function (node) {
                if (node.md) {
                    return `**${node.md}**`
                }
            },
            h1: function (node) {
                if (node.md) {
                    return `\n# ${node.md}\n`
                }
            },
            h2: function (node) {
                if (node.md) {
                    return `\n## ${node.md}\n`
                }
            },
            h3: function (node) {
                if (node.md) {
                    return `\n### ${node.md}\n`
                }
            },
            h4: function (node) {
                if (node.md) {
                    return `\n#### ${node.md}\n`
                }
            },
            h5: function (node) {
                if (node.md) {
                    return `\n##### ${node.md}\n`
                }
            },
            h6: function (node) {
                if (node.md) {
                    return `\n###### ${node.md}\n`
                }
            },
            a: function (node) {
                var text = node.md || node.attrs.href
                var href = node.attrs.href || text
                if (text) {
                    return `[${text}](${href})`
                }
            },
            img: function (node) {
                var src = node.attrs.src
                if (src) {
                    return `![${(node.attrs.title || node.attrs.alt || '').trim()}](${src})`
                }
            },
            blockquote: function (node) {
                var md = node.md
                if (md) {
                    md = md.replace(/(^\n+|\n+$)/g, '')
                    md = md.split('\n').map(function (line) {
                        return `> ${line}\n`
                    }).join('')
                    return `\n${md}\n`
                }
            },
            ul: function (node) {
                if (node.md) {
                    return `\n${node.md.replace(new RegExp(LI_HEADER, 'ig'), '-')}\n`
                }
            },
            ol: function (node) {
                var index = 1
                if (node.md) {
                    return `\n${node.md.replace(new RegExp(LI_HEADER, 'ig'), function () {
                        return `${index++}.`
                    })}\n`
                }
            },
            li: function (node) {
                if (node.md) {
                    return `${LI_HEADER} ${node.md}\n`
                }
            },
            hr: function () {
                return '\n---\n'
            },
            code: function (node) {
                if (node.md) {
                    if (node.isInPreNode) {
                        return node.md
                    }
                    return `\`${node.md}\``
                }
            },
            br: function () {
                return '\n'
            },
            pre: function (node) {
                var md = node.md
                if (md) {
                    md = md.split('\n').map(function (line) {
                        return `    ${line}\n`
                    }).join('')
                    return `\n${md}\n`
                }
            },
            p: function (node) {
                var md = node.md
                if (md) {
                    return `\n${md}\n`
                }
            },
            div: function (node) {
                var md = node.md
                if (md) {
                    return `\n${md}\n`
                }
            },
            'default': function (node) {
                return node.md
            },
            cleanup: function (result) {
                // remove leading or tailing break
                // convert \n\n\n... to \n\n
                return result.replace(/(^\n+|\n+$)/g, '')
                    .replace(/\n{3,}/g, '\n\n')
            }
        }

    }, {}],
    3: [function (require, module, exports) {
        module.exports = {
            'CommonMark': require('./commonmark'),
            'MarkdownExtra': require('./markdown-extra')
        }

    }, {"./commonmark": 2, "./markdown-extra": 4}],
    4: [function (require, module, exports) {
        /**
         * implement based on https://michelf.ca/projects/php-markdown/extra/
         */

        var CommonMark = require('./commonmark')

        var ignoreAttributes = ['id', 'class', 'href', 'src', 'alt']

        function getSpecialAttributes(node) {
            var specialAttributes = []
            var value = node.attrs['id']
            if (value) {
                specialAttributes.push(`#${value}`)
            }
            value = node.attrs['class']
            if (value) {
                specialAttributes.push(value.split(/\s+/).map(function (klass) {
                    return `.${klass}`
                }).join(' '))
            }
            Object.keys(node.attrs).forEach(function (key) {
                if (ignoreAttributes.indexOf(key) == -1) {
                    specialAttributes.push(`${key}=${value}`)
                }
            })
            specialAttributes = specialAttributes.join(' ')

            if (specialAttributes.length <= 0) {
                return ''
            } else {
                return ` (${specialAttributes})`
            }
        }

        var Extra = Object.create(CommonMark)

// Special Attributes
// headers
        var hx
        for (var i = 0; i < 6; i++) {
            (function (j) {
                hx = `h${j}`
                Extra[hx] = function (node) {
                    var hashes = '#'.repeat(j)
                    return `\n${hashes} ${node.md} ${hashes}${getSpecialAttributes(node)}\n`
                }
            })(i + 1)

        }
// links
        Extra['a'] = function (node) {
            return `${CommonMark['a'](node)}${getSpecialAttributes(node)}`
        }
// images
        Extra['img'] = function (node) {
            return `${CommonMark['img'](node)}${getSpecialAttributes(node)}`
        }


// Fenced Code Blocks
        Extra['pre'] = function (node) {
            return `\n\`\`\`\n${node.md}\n\`\`\`\n`
        }

// Abbreviations
        var abbrs = []

        Extra['abbr'] = function (node) {
            if (node.attrs.title != '') {
                abbrs.push({
                    word: node.md,
                    title: node.attrs.title
                })
            }
            return node.md
        }

        var isHandleTheadChar = false;
        var isTh = false;
        var trCount = 0;
        var thCount = 0;

// Tables
        Extra['table'] = function (node) {
            var theadChar = '';
            if (!isHandleTheadChar) {
                theadChar = getTeadChar() + '\n';
            }
            if (!isTh) {
                resetTable();
                return '';
            }
            resetTable();
            return `\n${node.md}\n${theadChar}`;
        }

        Extra['tr'] = function (node) {
            var trStr = '';
            trCount++;

            trStr = `\n|${node.md}`;

            if (!isHandleTheadChar && trCount == 2) {
                var theadChar = getTeadChar();
                isHandleTheadChar = true;
                return `\n${theadChar}${trStr}`;
            } else {

                return `${trStr}`;
            }

        }
        Extra['th'] = function (node) {
            isTh = true;
            thCount++;
            return `${node.md}|`;
        }
        Extra['td'] = function (node) {
            isTh = true;
            if (trCount == 0) {
                thCount++;
            }
            var md = replaceBr(node.md);
            return `${md}|`;
        }

// Definition Lists
        Extra['dl'] = function (node) {
            var md = node.md
            if (md) {
                return `\n${md}\n`
            }
        }
        Extra['dt'] = function (node) {
            // console.log(node)
            var md = node.md
            if (md) {
                return `${md}\n`
            }
        }
        Extra['dd'] = function (node) {
            var md = node.md
            if (md) {
                return `:   ${md}\n\n`
            }
        }

        function resetTable() {
            isTr = false;
            isTh = false;
            thCount = 0;
            trCount = 0;
            isHandleTheadChar = false;
        }

        function getTeadChar() {
            var theadChar = '|';
            for (var i = thCount; i > 0; i--) {
                theadChar += '--------|';
            }
            return theadChar;
        }

        function replaceBr(content) {
            return content.replace(/(<br>)|(<br\/>)|(\n)|(\r\n)/g, '');
        }

        function generateAbbreviations() {
            var results = abbrs.map(function (abbr) {
                return `*[${abbr.word}]: ${abbr.title}`
            }).join('\n')
            // clean up
            abbrs = []
            return results
        }

        Extra.cleanup = function (result) {
            // append abbreviations to tail of markdown
            return CommonMark.cleanup(`${result}\n\n${generateAbbreviations()}`)
        }

        module.exports = Extra
    }, {"./commonmark": 2}],
    5: [function (require, module, exports) {
        var htmlparser = require("htmlparser2")
        var converters = require('./converters/')

        var escapeMap = {
            "&amp;": "&",
            "&lt;": "<",
            "&gt;": ">",
            "&quot;": "\"",
            "&#x27;": "'",
            "&#x60;": "`",
            "&nbsp;": " ",
            "&#8202;": " "
        }

        var unescape = (function () {
            var source = `(?:${Object.keys(escapeMap).join('|')})`
            var testRegexp = RegExp(source)
            var replaceRegexp = RegExp(source, 'g')
            var escaper = function (match) {
                return escapeMap[match]
            }
            return function (string) {
                string = string || ''
                return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string
            }
        })()

        /**
         * @param html {String} the html to be onverted
         * @param options {Object}
         *   {
 *      converter {String} which converter you choose
 *      overides {Object<String, Function>} override converter behavior, for example:
 *          {
 *              br: function (node) {
 *                  return `\n\n` // let br tag break twice
 *              }
 *          }
 *   }
         */
        module.exports = function (html, options) {
            options = Object.assign({
                converter: 'CommonMark'
            }, options)

            var converter = Object.assign(
                Object.create(converters[options.converter]),
                options.overides || {}
            )

            var nodeBuffer = []
            var results = []
            var isInPreNode = false

            function convert(node) {
                node.md = (node.md && node.md.join('')) || ''
                return (converter[node.name] || converter['default'])(node) || ''
            }

            var parser = new htmlparser.Parser({
                onopentag: function (name, attributes) {
                    var node = {
                        name: name,
                        attrs: attributes,
                        isInPreNode: isInPreNode
                    }
                    if (name === 'pre') {
                        isInPreNode = true
                    }
                    nodeBuffer.push(node)
                },
                ontext: function (text) {
                    if (/^\s+$/.test(text)) {
                        return
                    }
                    text = unescape(text)
                    var last = nodeBuffer[nodeBuffer.length - 1]
                    if (last) {
                        last.md = last.md || []
                        last.md.push(text)
                    } else {
                        results.push(text)
                    }
                },
                onclosetag: function (name) {
                    var last = nodeBuffer.pop()
                    var md = convert(last)

                    if (name === 'pre') {
                        isInPreNode = false
                    }

                    if (nodeBuffer.length === 0) {
                        return results.push(md)
                    }

                    var tail = nodeBuffer[nodeBuffer.length - 1]
                    tail.md = tail.md || []
                    tail.md.push(md)
                }
            }, {decodeEntities: false})
            parser.write(html)
            parser.end()
            // remove the \n on head or tail
            return typeof converter.cleanup == 'function'
                ? converter.cleanup(results.join(''))
                : results.join('')
        }

    }, {"./converters/": 3, "htmlparser2": 13}],
    6: [function (require, module, exports) {
        module.exports = CollectingHandler;

        function CollectingHandler(cbs) {
            this._cbs = cbs || {};
            this.events = [];
        }

        var EVENTS = require("./").EVENTS;
        Object.keys(EVENTS).forEach(function (name) {
            if (EVENTS[name] === 0) {
                name = "on" + name;
                CollectingHandler.prototype[name] = function () {
                    this.events.push([name]);
                    if (this._cbs[name]) this._cbs[name]();
                };
            } else if (EVENTS[name] === 1) {
                name = "on" + name;
                CollectingHandler.prototype[name] = function (a) {
                    this.events.push([name, a]);
                    if (this._cbs[name]) this._cbs[name](a);
                };
            } else if (EVENTS[name] === 2) {
                name = "on" + name;
                CollectingHandler.prototype[name] = function (a, b) {
                    this.events.push([name, a, b]);
                    if (this._cbs[name]) this._cbs[name](a, b);
                };
            } else {
                throw Error("wrong number of arguments");
            }
        });

        CollectingHandler.prototype.onreset = function () {
            this.events = [];
            if (this._cbs.onreset) this._cbs.onreset();
        };

        CollectingHandler.prototype.restart = function () {
            if (this._cbs.onreset) this._cbs.onreset();

            for (var i = 0, len = this.events.length; i < len; i++) {
                if (this._cbs[this.events[i][0]]) {

                    var num = this.events[i].length;

                    if (num === 1) {
                        this._cbs[this.events[i][0]]();
                    } else if (num === 2) {
                        this._cbs[this.events[i][0]](this.events[i][1]);
                    } else {
                        this._cbs[this.events[i][0]](this.events[i][1], this.events[i][2]);
                    }
                }
            }
        };

    }, {"./": 13}],
    7: [function (require, module, exports) {
        var index = require("./index.js"),
            DomHandler = index.DomHandler,
            DomUtils = index.DomUtils;

//TODO: make this a streamable handler
        function FeedHandler(callback, options) {
            this.init(callback, options);
        }

        require("util").inherits(FeedHandler, DomHandler);

        FeedHandler.prototype.init = DomHandler;

        function getElements(what, where) {
            return DomUtils.getElementsByTagName(what, where, true);
        }

        function getOneElement(what, where) {
            return DomUtils.getElementsByTagName(what, where, true, 1)[0];
        }

        function fetch(what, where, recurse) {
            return DomUtils.getText(
                DomUtils.getElementsByTagName(what, where, recurse, 1)
            ).trim();
        }

        function addConditionally(obj, prop, what, where, recurse) {
            var tmp = fetch(what, where, recurse);
            if (tmp) obj[prop] = tmp;
        }

        var isValidFeed = function (value) {
            return value === "rss" || value === "feed" || value === "rdf:RDF";
        };

        FeedHandler.prototype.onend = function () {
            var feed = {},
                feedRoot = getOneElement(isValidFeed, this.dom),
                tmp, childs;

            if (feedRoot) {
                if (feedRoot.name === "feed") {
                    childs = feedRoot.children;

                    feed.type = "atom";
                    addConditionally(feed, "id", "id", childs);
                    addConditionally(feed, "title", "title", childs);
                    if ((tmp = getOneElement("link", childs)) && (tmp = tmp.attribs) && (tmp = tmp.href)) feed.link = tmp;
                    addConditionally(feed, "description", "subtitle", childs);
                    if ((tmp = fetch("updated", childs))) feed.updated = new Date(tmp);
                    addConditionally(feed, "author", "email", childs, true);

                    feed.items = getElements("entry", childs).map(function (item) {
                        var entry = {}, tmp;

                        item = item.children;

                        addConditionally(entry, "id", "id", item);
                        addConditionally(entry, "title", "title", item);
                        if ((tmp = getOneElement("link", item)) && (tmp = tmp.attribs) && (tmp = tmp.href)) entry.link = tmp;
                        if ((tmp = fetch("summary", item) || fetch("content", item))) entry.description = tmp;
                        if ((tmp = fetch("updated", item))) entry.pubDate = new Date(tmp);
                        return entry;
                    });
                } else {
                    childs = getOneElement("channel", feedRoot.children).children;

                    feed.type = feedRoot.name.substr(0, 3);
                    feed.id = "";
                    addConditionally(feed, "title", "title", childs);
                    addConditionally(feed, "link", "link", childs);
                    addConditionally(feed, "description", "description", childs);
                    if ((tmp = fetch("lastBuildDate", childs))) feed.updated = new Date(tmp);
                    addConditionally(feed, "author", "managingEditor", childs, true);

                    feed.items = getElements("item", feedRoot.children).map(function (item) {
                        var entry = {}, tmp;

                        item = item.children;

                        addConditionally(entry, "id", "guid", item);
                        addConditionally(entry, "title", "title", item);
                        addConditionally(entry, "link", "link", item);
                        addConditionally(entry, "description", "description", item);
                        if ((tmp = fetch("pubDate", item))) entry.pubDate = new Date(tmp);
                        return entry;
                    });
                }
            }
            this.dom = feed;
            DomHandler.prototype._handleCallback.call(
                this, feedRoot ? null : Error("couldn't find root of feed")
            );
        };

        module.exports = FeedHandler;

    }, {"./index.js": 13, "util": 61}],
    8: [function (require, module, exports) {
        var Tokenizer = require("./Tokenizer.js");

        /*
	Options:

	xmlMode: Disables the special behavior for script/style tags (false by default)
	lowerCaseAttributeNames: call .toLowerCase for each attribute name (true if xmlMode is `false`)
	lowerCaseTags: call .toLowerCase for each tag name (true if xmlMode is `false`)
*/

        /*
	Callbacks:

	oncdataend,
	oncdatastart,
	onclosetag,
	oncomment,
	oncommentend,
	onerror,
	onopentag,
	onprocessinginstruction,
	onreset,
	ontext
*/

        var formTags = {
            input: true,
            option: true,
            optgroup: true,
            select: true,
            button: true,
            datalist: true,
            textarea: true
        };

        var openImpliesClose = {
            tr: {tr: true, th: true, td: true},
            th: {th: true},
            td: {thead: true, th: true, td: true},
            body: {head: true, link: true, script: true},
            li: {li: true},
            p: {p: true},
            h1: {p: true},
            h2: {p: true},
            h3: {p: true},
            h4: {p: true},
            h5: {p: true},
            h6: {p: true},
            select: formTags,
            input: formTags,
            output: formTags,
            button: formTags,
            datalist: formTags,
            textarea: formTags,
            option: {option: true},
            optgroup: {optgroup: true}
        };

        var voidElements = {
            __proto__: null,
            area: true,
            base: true,
            basefont: true,
            br: true,
            col: true,
            command: true,
            embed: true,
            frame: true,
            hr: true,
            img: true,
            input: true,
            isindex: true,
            keygen: true,
            link: true,
            meta: true,
            param: true,
            source: true,
            track: true,
            wbr: true,

            //common self closing svg elements
            path: true,
            circle: true,
            ellipse: true,
            line: true,
            rect: true,
            use: true,
            stop: true,
            polyline: true,
            polygon: true
        };

        var re_nameEnd = /\s|\//;

        function Parser(cbs, options) {
            this._options = options || {};
            this._cbs = cbs || {};

            this._tagname = "";
            this._attribname = "";
            this._attribvalue = "";
            this._attribs = null;
            this._stack = [];

            this.startIndex = 0;
            this.endIndex = null;

            this._lowerCaseTagNames = "lowerCaseTags" in this._options ?
                !!this._options.lowerCaseTags :
                !this._options.xmlMode;
            this._lowerCaseAttributeNames = "lowerCaseAttributeNames" in this._options ?
                !!this._options.lowerCaseAttributeNames :
                !this._options.xmlMode;
            if (!!this._options.Tokenizer) {
                Tokenizer = this._options.Tokenizer;
            }
            this._tokenizer = new Tokenizer(this._options, this);

            if (this._cbs.onparserinit) this._cbs.onparserinit(this);
        }

        require("util").inherits(Parser, require("events").EventEmitter);

        Parser.prototype._updatePosition = function (initialOffset) {
            if (this.endIndex === null) {
                if (this._tokenizer._sectionStart <= initialOffset) {
                    this.startIndex = 0;
                } else {
                    this.startIndex = this._tokenizer._sectionStart - initialOffset;
                }
            }
            else this.startIndex = this.endIndex + 1;
            this.endIndex = this._tokenizer.getAbsoluteIndex();
        };

//Tokenizer event handlers
        Parser.prototype.ontext = function (data) {
            this._updatePosition(1);
            this.endIndex--;

            if (this._cbs.ontext) this._cbs.ontext(data);
        };

        Parser.prototype.onopentagname = function (name) {
            if (this._lowerCaseTagNames) {
                name = name.toLowerCase();
            }

            this._tagname = name;

            if (!this._options.xmlMode && name in openImpliesClose) {
                for (
                    var el;
                    (el = this._stack[this._stack.length - 1]) in openImpliesClose[name];
                    this.onclosetag(el)
                ) ;
            }

            if (this._options.xmlMode || !(name in voidElements)) {
                this._stack.push(name);
            }

            if (this._cbs.onopentagname) this._cbs.onopentagname(name);
            if (this._cbs.onopentag) this._attribs = {};
        };

        Parser.prototype.onopentagend = function () {
            this._updatePosition(1);

            if (this._attribs) {
                if (this._cbs.onopentag) this._cbs.onopentag(this._tagname, this._attribs);
                this._attribs = null;
            }

            if (!this._options.xmlMode && this._cbs.onclosetag && this._tagname in voidElements) {
                this._cbs.onclosetag(this._tagname);
            }

            this._tagname = "";
        };

        Parser.prototype.onclosetag = function (name) {
            this._updatePosition(1);

            if (this._lowerCaseTagNames) {
                name = name.toLowerCase();
            }

            if (this._stack.length && (!(name in voidElements) || this._options.xmlMode)) {
                var pos = this._stack.lastIndexOf(name);
                if (pos !== -1) {
                    if (this._cbs.onclosetag) {
                        pos = this._stack.length - pos;
                        while (pos--) this._cbs.onclosetag(this._stack.pop());
                    }
                    else this._stack.length = pos;
                } else if (name === "p" && !this._options.xmlMode) {
                    this.onopentagname(name);
                    this._closeCurrentTag();
                }
            } else if (!this._options.xmlMode && (name === "br" || name === "p")) {
                this.onopentagname(name);
                this._closeCurrentTag();
            }
        };

        Parser.prototype.onselfclosingtag = function () {
            if (this._options.xmlMode || this._options.recognizeSelfClosing) {
                this._closeCurrentTag();
            } else {
                this.onopentagend();
            }
        };

        Parser.prototype._closeCurrentTag = function () {
            var name = this._tagname;

            this.onopentagend();

            //self-closing tags will be on the top of the stack
            //(cheaper check than in onclosetag)
            if (this._stack[this._stack.length - 1] === name) {
                if (this._cbs.onclosetag) {
                    this._cbs.onclosetag(name);
                }
                this._stack.pop();
            }
        };

        Parser.prototype.onattribname = function (name) {
            if (this._lowerCaseAttributeNames) {
                name = name.toLowerCase();
            }
            this._attribname = name;
        };

        Parser.prototype.onattribdata = function (value) {
            this._attribvalue += value;
        };

        Parser.prototype.onattribend = function () {
            if (this._cbs.onattribute) this._cbs.onattribute(this._attribname, this._attribvalue);
            if (
                this._attribs &&
                !Object.prototype.hasOwnProperty.call(this._attribs, this._attribname)
            ) {
                this._attribs[this._attribname] = this._attribvalue;
            }
            this._attribname = "";
            this._attribvalue = "";
        };

        Parser.prototype._getInstructionName = function (value) {
            var idx = value.search(re_nameEnd),
                name = idx < 0 ? value : value.substr(0, idx);

            if (this._lowerCaseTagNames) {
                name = name.toLowerCase();
            }

            return name;
        };

        Parser.prototype.ondeclaration = function (value) {
            if (this._cbs.onprocessinginstruction) {
                var name = this._getInstructionName(value);
                this._cbs.onprocessinginstruction("!" + name, "!" + value);
            }
        };

        Parser.prototype.onprocessinginstruction = function (value) {
            if (this._cbs.onprocessinginstruction) {
                var name = this._getInstructionName(value);
                this._cbs.onprocessinginstruction("?" + name, "?" + value);
            }
        };

        Parser.prototype.oncomment = function (value) {
            this._updatePosition(4);

            if (this._cbs.oncomment) this._cbs.oncomment(value);
            if (this._cbs.oncommentend) this._cbs.oncommentend();
        };

        Parser.prototype.oncdata = function (value) {
            this._updatePosition(1);

            if (this._options.xmlMode || this._options.recognizeCDATA) {
                if (this._cbs.oncdatastart) this._cbs.oncdatastart();
                if (this._cbs.ontext) this._cbs.ontext(value);
                if (this._cbs.oncdataend) this._cbs.oncdataend();
            } else {
                this.oncomment("[CDATA[" + value + "]]");
            }
        };

        Parser.prototype.onerror = function (err) {
            if (this._cbs.onerror) this._cbs.onerror(err);
        };

        Parser.prototype.onend = function () {
            if (this._cbs.onclosetag) {
                for (
                    var i = this._stack.length;
                    i > 0;
                    this._cbs.onclosetag(this._stack[--i])
                ) ;
            }
            if (this._cbs.onend) this._cbs.onend();
        };


//Resets the parser to a blank state, ready to parse a new HTML document
        Parser.prototype.reset = function () {
            if (this._cbs.onreset) this._cbs.onreset();
            this._tokenizer.reset();

            this._tagname = "";
            this._attribname = "";
            this._attribs = null;
            this._stack = [];

            if (this._cbs.onparserinit) this._cbs.onparserinit(this);
        };

//Parses a complete HTML document and pushes it to the handler
        Parser.prototype.parseComplete = function (data) {
            this.reset();
            this.end(data);
        };

        Parser.prototype.write = function (chunk) {
            this._tokenizer.write(chunk);
        };

        Parser.prototype.end = function (chunk) {
            this._tokenizer.end(chunk);
        };

        Parser.prototype.pause = function () {
            this._tokenizer.pause();
        };

        Parser.prototype.resume = function () {
            this._tokenizer.resume();
        };

//alias for backwards compat
        Parser.prototype.parseChunk = Parser.prototype.write;
        Parser.prototype.done = Parser.prototype.end;

        module.exports = Parser;

    }, {"./Tokenizer.js": 11, "events": 40, "util": 61}],
    9: [function (require, module, exports) {
        module.exports = ProxyHandler;

        function ProxyHandler(cbs) {
            this._cbs = cbs || {};
        }

        var EVENTS = require("./").EVENTS;
        Object.keys(EVENTS).forEach(function (name) {
            if (EVENTS[name] === 0) {
                name = "on" + name;
                ProxyHandler.prototype[name] = function () {
                    if (this._cbs[name]) this._cbs[name]();
                };
            } else if (EVENTS[name] === 1) {
                name = "on" + name;
                ProxyHandler.prototype[name] = function (a) {
                    if (this._cbs[name]) this._cbs[name](a);
                };
            } else if (EVENTS[name] === 2) {
                name = "on" + name;
                ProxyHandler.prototype[name] = function (a, b) {
                    if (this._cbs[name]) this._cbs[name](a, b);
                };
            } else {
                throw Error("wrong number of arguments");
            }
        });
    }, {"./": 13}],
    10: [function (require, module, exports) {
        module.exports = Stream;

        var Parser = require("./WritableStream.js");

        function Stream(options) {
            Parser.call(this, new Cbs(this), options);
        }

        require("util").inherits(Stream, Parser);

        Stream.prototype.readable = true;

        function Cbs(scope) {
            this.scope = scope;
        }

        var EVENTS = require("../").EVENTS;

        Object.keys(EVENTS).forEach(function (name) {
            if (EVENTS[name] === 0) {
                Cbs.prototype["on" + name] = function () {
                    this.scope.emit(name);
                };
            } else if (EVENTS[name] === 1) {
                Cbs.prototype["on" + name] = function (a) {
                    this.scope.emit(name, a);
                };
            } else if (EVENTS[name] === 2) {
                Cbs.prototype["on" + name] = function (a, b) {
                    this.scope.emit(name, a, b);
                };
            } else {
                throw Error("wrong number of arguments!");
            }
        });
    }, {"../": 13, "./WritableStream.js": 12, "util": 61}],
    11: [function (require, module, exports) {
        module.exports = Tokenizer;

        var decodeCodePoint = require("entities/lib/decode_codepoint.js"),
            entityMap = require("entities/maps/entities.json"),
            legacyMap = require("entities/maps/legacy.json"),
            xmlMap = require("entities/maps/xml.json"),

            i = 0,

            TEXT = i++,
            BEFORE_TAG_NAME = i++, //after <
            IN_TAG_NAME = i++,
            IN_SELF_CLOSING_TAG = i++,
            BEFORE_CLOSING_TAG_NAME = i++,
            IN_CLOSING_TAG_NAME = i++,
            AFTER_CLOSING_TAG_NAME = i++,

            //attributes
            BEFORE_ATTRIBUTE_NAME = i++,
            IN_ATTRIBUTE_NAME = i++,
            AFTER_ATTRIBUTE_NAME = i++,
            BEFORE_ATTRIBUTE_VALUE = i++,
            IN_ATTRIBUTE_VALUE_DQ = i++, // "
            IN_ATTRIBUTE_VALUE_SQ = i++, // '
            IN_ATTRIBUTE_VALUE_NQ = i++,

            //declarations
            BEFORE_DECLARATION = i++, // !
            IN_DECLARATION = i++,

            //processing instructions
            IN_PROCESSING_INSTRUCTION = i++, // ?

            //comments
            BEFORE_COMMENT = i++,
            IN_COMMENT = i++,
            AFTER_COMMENT_1 = i++,
            AFTER_COMMENT_2 = i++,

            //cdata
            BEFORE_CDATA_1 = i++, // [
            BEFORE_CDATA_2 = i++, // C
            BEFORE_CDATA_3 = i++, // D
            BEFORE_CDATA_4 = i++, // A
            BEFORE_CDATA_5 = i++, // T
            BEFORE_CDATA_6 = i++, // A
            IN_CDATA = i++, // [
            AFTER_CDATA_1 = i++, // ]
            AFTER_CDATA_2 = i++, // ]

            //special tags
            BEFORE_SPECIAL = i++, //S
            BEFORE_SPECIAL_END = i++,   //S

            BEFORE_SCRIPT_1 = i++, //C
            BEFORE_SCRIPT_2 = i++, //R
            BEFORE_SCRIPT_3 = i++, //I
            BEFORE_SCRIPT_4 = i++, //P
            BEFORE_SCRIPT_5 = i++, //T
            AFTER_SCRIPT_1 = i++, //C
            AFTER_SCRIPT_2 = i++, //R
            AFTER_SCRIPT_3 = i++, //I
            AFTER_SCRIPT_4 = i++, //P
            AFTER_SCRIPT_5 = i++, //T

            BEFORE_STYLE_1 = i++, //T
            BEFORE_STYLE_2 = i++, //Y
            BEFORE_STYLE_3 = i++, //L
            BEFORE_STYLE_4 = i++, //E
            AFTER_STYLE_1 = i++, //T
            AFTER_STYLE_2 = i++, //Y
            AFTER_STYLE_3 = i++, //L
            AFTER_STYLE_4 = i++, //E

            BEFORE_ENTITY = i++, //&
            BEFORE_NUMERIC_ENTITY = i++, //#
            IN_NAMED_ENTITY = i++,
            IN_NUMERIC_ENTITY = i++,
            IN_HEX_ENTITY = i++, //X

            j = 0,

            SPECIAL_NONE = j++,
            SPECIAL_SCRIPT = j++,
            SPECIAL_STYLE = j++;

        function whitespace(c) {
            return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";
        }

        function characterState(char, SUCCESS) {
            return function (c) {
                if (c === char) this._state = SUCCESS;
            };
        }

        function ifElseState(upper, SUCCESS, FAILURE) {
            var lower = upper.toLowerCase();

            if (upper === lower) {
                return function (c) {
                    if (c === lower) {
                        this._state = SUCCESS;
                    } else {
                        this._state = FAILURE;
                        this._index--;
                    }
                };
            } else {
                return function (c) {
                    if (c === lower || c === upper) {
                        this._state = SUCCESS;
                    } else {
                        this._state = FAILURE;
                        this._index--;
                    }
                };
            }
        }

        function consumeSpecialNameChar(upper, NEXT_STATE) {
            var lower = upper.toLowerCase();

            return function (c) {
                if (c === lower || c === upper) {
                    this._state = NEXT_STATE;
                } else {
                    this._state = IN_TAG_NAME;
                    this._index--; //consume the token again
                }
            };
        }

        function Tokenizer(options, cbs) {
            this._state = TEXT;
            this._buffer = "";
            this._sectionStart = 0;
            this._index = 0;
            this._bufferOffset = 0; //chars removed from _buffer
            this._baseState = TEXT;
            this._special = SPECIAL_NONE;
            this._cbs = cbs;
            this._running = true;
            this._ended = false;
            this._xmlMode = !!(options && options.xmlMode);
            this._decodeEntities = !!(options && options.decodeEntities);
        }

        Tokenizer.prototype._stateText = function (c) {
            if (c === "<") {
                if (this._index > this._sectionStart) {
                    this._cbs.ontext(this._getSection());
                }
                this._state = BEFORE_TAG_NAME;
                this._sectionStart = this._index;
            } else if (this._decodeEntities && this._special === SPECIAL_NONE && c === "&") {
                if (this._index > this._sectionStart) {
                    this._cbs.ontext(this._getSection());
                }
                this._baseState = TEXT;
                this._state = BEFORE_ENTITY;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateBeforeTagName = function (c) {
            if (c === "/") {
                this._state = BEFORE_CLOSING_TAG_NAME;
            } else if (c === ">" || this._special !== SPECIAL_NONE || whitespace(c)) {
                this._state = TEXT;
            } else if (c === "!") {
                this._state = BEFORE_DECLARATION;
                this._sectionStart = this._index + 1;
            } else if (c === "?") {
                this._state = IN_PROCESSING_INSTRUCTION;
                this._sectionStart = this._index + 1;
            } else if (c === "<") {
                this._cbs.ontext(this._getSection());
                this._sectionStart = this._index;
            } else {
                this._state = (!this._xmlMode && (c === "s" || c === "S")) ?
                    BEFORE_SPECIAL : IN_TAG_NAME;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateInTagName = function (c) {
            if (c === "/" || c === ">" || whitespace(c)) {
                this._emitToken("onopentagname");
                this._state = BEFORE_ATTRIBUTE_NAME;
                this._index--;
            }
        };

        Tokenizer.prototype._stateBeforeCloseingTagName = function (c) {
            if (whitespace(c)) ;
            else if (c === ">") {
                this._state = TEXT;
            } else if (this._special !== SPECIAL_NONE) {
                if (c === "s" || c === "S") {
                    this._state = BEFORE_SPECIAL_END;
                } else {
                    this._state = TEXT;
                    this._index--;
                }
            } else {
                this._state = IN_CLOSING_TAG_NAME;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateInCloseingTagName = function (c) {
            if (c === ">" || whitespace(c)) {
                this._emitToken("onclosetag");
                this._state = AFTER_CLOSING_TAG_NAME;
                this._index--;
            }
        };

        Tokenizer.prototype._stateAfterCloseingTagName = function (c) {
            //skip everything until ">"
            if (c === ">") {
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            }
        };

        Tokenizer.prototype._stateBeforeAttributeName = function (c) {
            if (c === ">") {
                this._cbs.onopentagend();
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            } else if (c === "/") {
                this._state = IN_SELF_CLOSING_TAG;
            } else if (!whitespace(c)) {
                this._state = IN_ATTRIBUTE_NAME;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateInSelfClosingTag = function (c) {
            if (c === ">") {
                this._cbs.onselfclosingtag();
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            } else if (!whitespace(c)) {
                this._state = BEFORE_ATTRIBUTE_NAME;
                this._index--;
            }
        };

        Tokenizer.prototype._stateInAttributeName = function (c) {
            if (c === "=" || c === "/" || c === ">" || whitespace(c)) {
                this._cbs.onattribname(this._getSection());
                this._sectionStart = -1;
                this._state = AFTER_ATTRIBUTE_NAME;
                this._index--;
            }
        };

        Tokenizer.prototype._stateAfterAttributeName = function (c) {
            if (c === "=") {
                this._state = BEFORE_ATTRIBUTE_VALUE;
            } else if (c === "/" || c === ">") {
                this._cbs.onattribend();
                this._state = BEFORE_ATTRIBUTE_NAME;
                this._index--;
            } else if (!whitespace(c)) {
                this._cbs.onattribend();
                this._state = IN_ATTRIBUTE_NAME;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateBeforeAttributeValue = function (c) {
            if (c === "\"") {
                this._state = IN_ATTRIBUTE_VALUE_DQ;
                this._sectionStart = this._index + 1;
            } else if (c === "'") {
                this._state = IN_ATTRIBUTE_VALUE_SQ;
                this._sectionStart = this._index + 1;
            } else if (!whitespace(c)) {
                this._state = IN_ATTRIBUTE_VALUE_NQ;
                this._sectionStart = this._index;
                this._index--; //reconsume token
            }
        };

        Tokenizer.prototype._stateInAttributeValueDoubleQuotes = function (c) {
            if (c === "\"") {
                this._emitToken("onattribdata");
                this._cbs.onattribend();
                this._state = BEFORE_ATTRIBUTE_NAME;
            } else if (this._decodeEntities && c === "&") {
                this._emitToken("onattribdata");
                this._baseState = this._state;
                this._state = BEFORE_ENTITY;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateInAttributeValueSingleQuotes = function (c) {
            if (c === "'") {
                this._emitToken("onattribdata");
                this._cbs.onattribend();
                this._state = BEFORE_ATTRIBUTE_NAME;
            } else if (this._decodeEntities && c === "&") {
                this._emitToken("onattribdata");
                this._baseState = this._state;
                this._state = BEFORE_ENTITY;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateInAttributeValueNoQuotes = function (c) {
            if (whitespace(c) || c === ">") {
                this._emitToken("onattribdata");
                this._cbs.onattribend();
                this._state = BEFORE_ATTRIBUTE_NAME;
                this._index--;
            } else if (this._decodeEntities && c === "&") {
                this._emitToken("onattribdata");
                this._baseState = this._state;
                this._state = BEFORE_ENTITY;
                this._sectionStart = this._index;
            }
        };

        Tokenizer.prototype._stateBeforeDeclaration = function (c) {
            this._state = c === "[" ? BEFORE_CDATA_1 :
                c === "-" ? BEFORE_COMMENT :
                    IN_DECLARATION;
        };

        Tokenizer.prototype._stateInDeclaration = function (c) {
            if (c === ">") {
                this._cbs.ondeclaration(this._getSection());
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            }
        };

        Tokenizer.prototype._stateInProcessingInstruction = function (c) {
            if (c === ">") {
                this._cbs.onprocessinginstruction(this._getSection());
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            }
        };

        Tokenizer.prototype._stateBeforeComment = function (c) {
            if (c === "-") {
                this._state = IN_COMMENT;
                this._sectionStart = this._index + 1;
            } else {
                this._state = IN_DECLARATION;
            }
        };

        Tokenizer.prototype._stateInComment = function (c) {
            if (c === "-") this._state = AFTER_COMMENT_1;
        };

        Tokenizer.prototype._stateAfterComment1 = function (c) {
            if (c === "-") {
                this._state = AFTER_COMMENT_2;
            } else {
                this._state = IN_COMMENT;
            }
        };

        Tokenizer.prototype._stateAfterComment2 = function (c) {
            if (c === ">") {
                //remove 2 trailing chars
                this._cbs.oncomment(this._buffer.substring(this._sectionStart, this._index - 2));
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            } else if (c !== "-") {
                this._state = IN_COMMENT;
            }
            // else: stay in AFTER_COMMENT_2 (`--->`)
        };

        Tokenizer.prototype._stateBeforeCdata1 = ifElseState("C", BEFORE_CDATA_2, IN_DECLARATION);
        Tokenizer.prototype._stateBeforeCdata2 = ifElseState("D", BEFORE_CDATA_3, IN_DECLARATION);
        Tokenizer.prototype._stateBeforeCdata3 = ifElseState("A", BEFORE_CDATA_4, IN_DECLARATION);
        Tokenizer.prototype._stateBeforeCdata4 = ifElseState("T", BEFORE_CDATA_5, IN_DECLARATION);
        Tokenizer.prototype._stateBeforeCdata5 = ifElseState("A", BEFORE_CDATA_6, IN_DECLARATION);

        Tokenizer.prototype._stateBeforeCdata6 = function (c) {
            if (c === "[") {
                this._state = IN_CDATA;
                this._sectionStart = this._index + 1;
            } else {
                this._state = IN_DECLARATION;
                this._index--;
            }
        };

        Tokenizer.prototype._stateInCdata = function (c) {
            if (c === "]") this._state = AFTER_CDATA_1;
        };

        Tokenizer.prototype._stateAfterCdata1 = characterState("]", AFTER_CDATA_2);

        Tokenizer.prototype._stateAfterCdata2 = function (c) {
            if (c === ">") {
                //remove 2 trailing chars
                this._cbs.oncdata(this._buffer.substring(this._sectionStart, this._index - 2));
                this._state = TEXT;
                this._sectionStart = this._index + 1;
            } else if (c !== "]") {
                this._state = IN_CDATA;
            }
            //else: stay in AFTER_CDATA_2 (`]]]>`)
        };

        Tokenizer.prototype._stateBeforeSpecial = function (c) {
            if (c === "c" || c === "C") {
                this._state = BEFORE_SCRIPT_1;
            } else if (c === "t" || c === "T") {
                this._state = BEFORE_STYLE_1;
            } else {
                this._state = IN_TAG_NAME;
                this._index--; //consume the token again
            }
        };

        Tokenizer.prototype._stateBeforeSpecialEnd = function (c) {
            if (this._special === SPECIAL_SCRIPT && (c === "c" || c === "C")) {
                this._state = AFTER_SCRIPT_1;
            } else if (this._special === SPECIAL_STYLE && (c === "t" || c === "T")) {
                this._state = AFTER_STYLE_1;
            }
            else this._state = TEXT;
        };

        Tokenizer.prototype._stateBeforeScript1 = consumeSpecialNameChar("R", BEFORE_SCRIPT_2);
        Tokenizer.prototype._stateBeforeScript2 = consumeSpecialNameChar("I", BEFORE_SCRIPT_3);
        Tokenizer.prototype._stateBeforeScript3 = consumeSpecialNameChar("P", BEFORE_SCRIPT_4);
        Tokenizer.prototype._stateBeforeScript4 = consumeSpecialNameChar("T", BEFORE_SCRIPT_5);

        Tokenizer.prototype._stateBeforeScript5 = function (c) {
            if (c === "/" || c === ">" || whitespace(c)) {
                this._special = SPECIAL_SCRIPT;
            }
            this._state = IN_TAG_NAME;
            this._index--; //consume the token again
        };

        Tokenizer.prototype._stateAfterScript1 = ifElseState("R", AFTER_SCRIPT_2, TEXT);
        Tokenizer.prototype._stateAfterScript2 = ifElseState("I", AFTER_SCRIPT_3, TEXT);
        Tokenizer.prototype._stateAfterScript3 = ifElseState("P", AFTER_SCRIPT_4, TEXT);
        Tokenizer.prototype._stateAfterScript4 = ifElseState("T", AFTER_SCRIPT_5, TEXT);

        Tokenizer.prototype._stateAfterScript5 = function (c) {
            if (c === ">" || whitespace(c)) {
                this._special = SPECIAL_NONE;
                this._state = IN_CLOSING_TAG_NAME;
                this._sectionStart = this._index - 6;
                this._index--; //reconsume the token
            }
            else this._state = TEXT;
        };

        Tokenizer.prototype._stateBeforeStyle1 = consumeSpecialNameChar("Y", BEFORE_STYLE_2);
        Tokenizer.prototype._stateBeforeStyle2 = consumeSpecialNameChar("L", BEFORE_STYLE_3);
        Tokenizer.prototype._stateBeforeStyle3 = consumeSpecialNameChar("E", BEFORE_STYLE_4);

        Tokenizer.prototype._stateBeforeStyle4 = function (c) {
            if (c === "/" || c === ">" || whitespace(c)) {
                this._special = SPECIAL_STYLE;
            }
            this._state = IN_TAG_NAME;
            this._index--; //consume the token again
        };

        Tokenizer.prototype._stateAfterStyle1 = ifElseState("Y", AFTER_STYLE_2, TEXT);
        Tokenizer.prototype._stateAfterStyle2 = ifElseState("L", AFTER_STYLE_3, TEXT);
        Tokenizer.prototype._stateAfterStyle3 = ifElseState("E", AFTER_STYLE_4, TEXT);

        Tokenizer.prototype._stateAfterStyle4 = function (c) {
            if (c === ">" || whitespace(c)) {
                this._special = SPECIAL_NONE;
                this._state = IN_CLOSING_TAG_NAME;
                this._sectionStart = this._index - 5;
                this._index--; //reconsume the token
            }
            else this._state = TEXT;
        };

        Tokenizer.prototype._stateBeforeEntity = ifElseState("#", BEFORE_NUMERIC_ENTITY, IN_NAMED_ENTITY);
        Tokenizer.prototype._stateBeforeNumericEntity = ifElseState("X", IN_HEX_ENTITY, IN_NUMERIC_ENTITY);

//for entities terminated with a semicolon
        Tokenizer.prototype._parseNamedEntityStrict = function () {
            //offset = 1
            if (this._sectionStart + 1 < this._index) {
                var entity = this._buffer.substring(this._sectionStart + 1, this._index),
                    map = this._xmlMode ? xmlMap : entityMap;

                if (map.hasOwnProperty(entity)) {
                    this._emitPartial(map[entity]);
                    this._sectionStart = this._index + 1;
                }
            }
        };


//parses legacy entities (without trailing semicolon)
        Tokenizer.prototype._parseLegacyEntity = function () {
            var start = this._sectionStart + 1,
                limit = this._index - start;

            if (limit > 6) limit = 6; //the max length of legacy entities is 6

            while (limit >= 2) { //the min length of legacy entities is 2
                var entity = this._buffer.substr(start, limit);

                if (legacyMap.hasOwnProperty(entity)) {
                    this._emitPartial(legacyMap[entity]);
                    this._sectionStart += limit + 1;
                    return;
                } else {
                    limit--;
                }
            }
        };

        Tokenizer.prototype._stateInNamedEntity = function (c) {
            if (c === ";") {
                this._parseNamedEntityStrict();
                if (this._sectionStart + 1 < this._index && !this._xmlMode) {
                    this._parseLegacyEntity();
                }
                this._state = this._baseState;
            } else if ((c < "a" || c > "z") && (c < "A" || c > "Z") && (c < "0" || c > "9")) {
                if (this._xmlMode) ;
                else if (this._sectionStart + 1 === this._index) ;
                else if (this._baseState !== TEXT) {
                    if (c !== "=") {
                        this._parseNamedEntityStrict();
                    }
                } else {
                    this._parseLegacyEntity();
                }

                this._state = this._baseState;
                this._index--;
            }
        };

        Tokenizer.prototype._decodeNumericEntity = function (offset, base) {
            var sectionStart = this._sectionStart + offset;

            if (sectionStart !== this._index) {
                //parse entity
                var entity = this._buffer.substring(sectionStart, this._index);
                var parsed = parseInt(entity, base);

                this._emitPartial(decodeCodePoint(parsed));
                this._sectionStart = this._index;
            } else {
                this._sectionStart--;
            }

            this._state = this._baseState;
        };

        Tokenizer.prototype._stateInNumericEntity = function (c) {
            if (c === ";") {
                this._decodeNumericEntity(2, 10);
                this._sectionStart++;
            } else if (c < "0" || c > "9") {
                if (!this._xmlMode) {
                    this._decodeNumericEntity(2, 10);
                } else {
                    this._state = this._baseState;
                }
                this._index--;
            }
        };

        Tokenizer.prototype._stateInHexEntity = function (c) {
            if (c === ";") {
                this._decodeNumericEntity(3, 16);
                this._sectionStart++;
            } else if ((c < "a" || c > "f") && (c < "A" || c > "F") && (c < "0" || c > "9")) {
                if (!this._xmlMode) {
                    this._decodeNumericEntity(3, 16);
                } else {
                    this._state = this._baseState;
                }
                this._index--;
            }
        };

        Tokenizer.prototype._cleanup = function () {
            if (this._sectionStart < 0) {
                this._buffer = "";
                this._index = 0;
                this._bufferOffset += this._index;
            } else if (this._running) {
                if (this._state === TEXT) {
                    if (this._sectionStart !== this._index) {
                        this._cbs.ontext(this._buffer.substr(this._sectionStart));
                    }
                    this._buffer = "";
                    this._index = 0;
                    this._bufferOffset += this._index;
                } else if (this._sectionStart === this._index) {
                    //the section just started
                    this._buffer = "";
                    this._index = 0;
                    this._bufferOffset += this._index;
                } else {
                    //remove everything unnecessary
                    this._buffer = this._buffer.substr(this._sectionStart);
                    this._index -= this._sectionStart;
                    this._bufferOffset += this._sectionStart;
                }

                this._sectionStart = 0;
            }
        };

//TODO make events conditional
        Tokenizer.prototype.write = function (chunk) {
            if (this._ended) this._cbs.onerror(Error(".write() after done!"));

            this._buffer += chunk;
            this._parse();
        };

        Tokenizer.prototype._parse = function () {
            while (this._index < this._buffer.length && this._running) {
                var c = this._buffer.charAt(this._index);
                if (this._state === TEXT) {
                    this._stateText(c);
                } else if (this._state === BEFORE_TAG_NAME) {
                    this._stateBeforeTagName(c);
                } else if (this._state === IN_TAG_NAME) {
                    this._stateInTagName(c);
                } else if (this._state === BEFORE_CLOSING_TAG_NAME) {
                    this._stateBeforeCloseingTagName(c);
                } else if (this._state === IN_CLOSING_TAG_NAME) {
                    this._stateInCloseingTagName(c);
                } else if (this._state === AFTER_CLOSING_TAG_NAME) {
                    this._stateAfterCloseingTagName(c);
                } else if (this._state === IN_SELF_CLOSING_TAG) {
                    this._stateInSelfClosingTag(c);
                }

                /*
		*	attributes
		*/
                else if (this._state === BEFORE_ATTRIBUTE_NAME) {
                    this._stateBeforeAttributeName(c);
                } else if (this._state === IN_ATTRIBUTE_NAME) {
                    this._stateInAttributeName(c);
                } else if (this._state === AFTER_ATTRIBUTE_NAME) {
                    this._stateAfterAttributeName(c);
                } else if (this._state === BEFORE_ATTRIBUTE_VALUE) {
                    this._stateBeforeAttributeValue(c);
                } else if (this._state === IN_ATTRIBUTE_VALUE_DQ) {
                    this._stateInAttributeValueDoubleQuotes(c);
                } else if (this._state === IN_ATTRIBUTE_VALUE_SQ) {
                    this._stateInAttributeValueSingleQuotes(c);
                } else if (this._state === IN_ATTRIBUTE_VALUE_NQ) {
                    this._stateInAttributeValueNoQuotes(c);
                }

                /*
		*	declarations
		*/
                else if (this._state === BEFORE_DECLARATION) {
                    this._stateBeforeDeclaration(c);
                } else if (this._state === IN_DECLARATION) {
                    this._stateInDeclaration(c);
                }

                /*
		*	processing instructions
		*/
                else if (this._state === IN_PROCESSING_INSTRUCTION) {
                    this._stateInProcessingInstruction(c);
                }

                /*
		*	comments
		*/
                else if (this._state === BEFORE_COMMENT) {
                    this._stateBeforeComment(c);
                } else if (this._state === IN_COMMENT) {
                    this._stateInComment(c);
                } else if (this._state === AFTER_COMMENT_1) {
                    this._stateAfterComment1(c);
                } else if (this._state === AFTER_COMMENT_2) {
                    this._stateAfterComment2(c);
                }

                /*
		*	cdata
		*/
                else if (this._state === BEFORE_CDATA_1) {
                    this._stateBeforeCdata1(c);
                } else if (this._state === BEFORE_CDATA_2) {
                    this._stateBeforeCdata2(c);
                } else if (this._state === BEFORE_CDATA_3) {
                    this._stateBeforeCdata3(c);
                } else if (this._state === BEFORE_CDATA_4) {
                    this._stateBeforeCdata4(c);
                } else if (this._state === BEFORE_CDATA_5) {
                    this._stateBeforeCdata5(c);
                } else if (this._state === BEFORE_CDATA_6) {
                    this._stateBeforeCdata6(c);
                } else if (this._state === IN_CDATA) {
                    this._stateInCdata(c);
                } else if (this._state === AFTER_CDATA_1) {
                    this._stateAfterCdata1(c);
                } else if (this._state === AFTER_CDATA_2) {
                    this._stateAfterCdata2(c);
                }

                /*
		* special tags
		*/
                else if (this._state === BEFORE_SPECIAL) {
                    this._stateBeforeSpecial(c);
                } else if (this._state === BEFORE_SPECIAL_END) {
                    this._stateBeforeSpecialEnd(c);
                }

                /*
		* script
		*/
                else if (this._state === BEFORE_SCRIPT_1) {
                    this._stateBeforeScript1(c);
                } else if (this._state === BEFORE_SCRIPT_2) {
                    this._stateBeforeScript2(c);
                } else if (this._state === BEFORE_SCRIPT_3) {
                    this._stateBeforeScript3(c);
                } else if (this._state === BEFORE_SCRIPT_4) {
                    this._stateBeforeScript4(c);
                } else if (this._state === BEFORE_SCRIPT_5) {
                    this._stateBeforeScript5(c);
                }

                else if (this._state === AFTER_SCRIPT_1) {
                    this._stateAfterScript1(c);
                } else if (this._state === AFTER_SCRIPT_2) {
                    this._stateAfterScript2(c);
                } else if (this._state === AFTER_SCRIPT_3) {
                    this._stateAfterScript3(c);
                } else if (this._state === AFTER_SCRIPT_4) {
                    this._stateAfterScript4(c);
                } else if (this._state === AFTER_SCRIPT_5) {
                    this._stateAfterScript5(c);
                }

                /*
		* style
		*/
                else if (this._state === BEFORE_STYLE_1) {
                    this._stateBeforeStyle1(c);
                } else if (this._state === BEFORE_STYLE_2) {
                    this._stateBeforeStyle2(c);
                } else if (this._state === BEFORE_STYLE_3) {
                    this._stateBeforeStyle3(c);
                } else if (this._state === BEFORE_STYLE_4) {
                    this._stateBeforeStyle4(c);
                }

                else if (this._state === AFTER_STYLE_1) {
                    this._stateAfterStyle1(c);
                } else if (this._state === AFTER_STYLE_2) {
                    this._stateAfterStyle2(c);
                } else if (this._state === AFTER_STYLE_3) {
                    this._stateAfterStyle3(c);
                } else if (this._state === AFTER_STYLE_4) {
                    this._stateAfterStyle4(c);
                }

                /*
		* entities
		*/
                else if (this._state === BEFORE_ENTITY) {
                    this._stateBeforeEntity(c);
                } else if (this._state === BEFORE_NUMERIC_ENTITY) {
                    this._stateBeforeNumericEntity(c);
                } else if (this._state === IN_NAMED_ENTITY) {
                    this._stateInNamedEntity(c);
                } else if (this._state === IN_NUMERIC_ENTITY) {
                    this._stateInNumericEntity(c);
                } else if (this._state === IN_HEX_ENTITY) {
                    this._stateInHexEntity(c);
                }

                else {
                    this._cbs.onerror(Error("unknown _state"), this._state);
                }

                this._index++;
            }

            this._cleanup();
        };

        Tokenizer.prototype.pause = function () {
            this._running = false;
        };
        Tokenizer.prototype.resume = function () {
            this._running = true;

            if (this._index < this._buffer.length) {
                this._parse();
            }
            if (this._ended) {
                this._finish();
            }
        };

        Tokenizer.prototype.end = function (chunk) {
            if (this._ended) this._cbs.onerror(Error(".end() after done!"));
            if (chunk) this.write(chunk);

            this._ended = true;

            if (this._running) this._finish();
        };

        Tokenizer.prototype._finish = function () {
            //if there is remaining data, emit it in a reasonable way
            if (this._sectionStart < this._index) {
                this._handleTrailingData();
            }

            this._cbs.onend();
        };

        Tokenizer.prototype._handleTrailingData = function () {
            var data = this._buffer.substr(this._sectionStart);

            if (this._state === IN_CDATA || this._state === AFTER_CDATA_1 || this._state === AFTER_CDATA_2) {
                this._cbs.oncdata(data);
            } else if (this._state === IN_COMMENT || this._state === AFTER_COMMENT_1 || this._state === AFTER_COMMENT_2) {
                this._cbs.oncomment(data);
            } else if (this._state === IN_NAMED_ENTITY && !this._xmlMode) {
                this._parseLegacyEntity();
                if (this._sectionStart < this._index) {
                    this._state = this._baseState;
                    this._handleTrailingData();
                }
            } else if (this._state === IN_NUMERIC_ENTITY && !this._xmlMode) {
                this._decodeNumericEntity(2, 10);
                if (this._sectionStart < this._index) {
                    this._state = this._baseState;
                    this._handleTrailingData();
                }
            } else if (this._state === IN_HEX_ENTITY && !this._xmlMode) {
                this._decodeNumericEntity(3, 16);
                if (this._sectionStart < this._index) {
                    this._state = this._baseState;
                    this._handleTrailingData();
                }
            } else if (
                this._state !== IN_TAG_NAME &&
                this._state !== BEFORE_ATTRIBUTE_NAME &&
                this._state !== BEFORE_ATTRIBUTE_VALUE &&
                this._state !== AFTER_ATTRIBUTE_NAME &&
                this._state !== IN_ATTRIBUTE_NAME &&
                this._state !== IN_ATTRIBUTE_VALUE_SQ &&
                this._state !== IN_ATTRIBUTE_VALUE_DQ &&
                this._state !== IN_ATTRIBUTE_VALUE_NQ &&
                this._state !== IN_CLOSING_TAG_NAME
            ) {
                this._cbs.ontext(data);
            }
            //else, ignore remaining data
            //TODO add a way to remove current tag
        };

        Tokenizer.prototype.reset = function () {
            Tokenizer.call(this, {xmlMode: this._xmlMode, decodeEntities: this._decodeEntities}, this._cbs);
        };

        Tokenizer.prototype.getAbsoluteIndex = function () {
            return this._bufferOffset + this._index;
        };

        Tokenizer.prototype._getSection = function () {
            return this._buffer.substring(this._sectionStart, this._index);
        };

        Tokenizer.prototype._emitToken = function (name) {
            this._cbs[name](this._getSection());
            this._sectionStart = -1;
        };

        Tokenizer.prototype._emitPartial = function (value) {
            if (this._baseState !== TEXT) {
                this._cbs.onattribdata(value); //TODO implement the new event
            } else {
                this._cbs.ontext(value);
            }
        };

    }, {
        "entities/lib/decode_codepoint.js": 29,
        "entities/maps/entities.json": 32,
        "entities/maps/legacy.json": 33,
        "entities/maps/xml.json": 34
    }],
    12: [function (require, module, exports) {
        module.exports = Stream;

        var Parser = require("./Parser.js"),
            WritableStream = require("stream").Writable || require("readable-stream").Writable;

        function Stream(cbs, options) {
            var parser = this._parser = new Parser(cbs, options);

            WritableStream.call(this, {decodeStrings: false});

            this.once("finish", function () {
                parser.end();
            });
        }

        require("util").inherits(Stream, WritableStream);

        WritableStream.prototype._write = function (chunk, encoding, cb) {
            this._parser.write(chunk);
            cb();
        };
    }, {"./Parser.js": 8, "readable-stream": 35, "stream": 58, "util": 61}],
    13: [function (require, module, exports) {
        var Parser = require("./Parser.js"),
            DomHandler = require("domhandler");

        function defineProp(name, value) {
            delete module.exports[name];
            module.exports[name] = value;
            return value;
        }

        module.exports = {
            Parser: Parser,
            Tokenizer: require("./Tokenizer.js"),
            ElementType: require("domelementtype"),
            DomHandler: DomHandler,
            get FeedHandler() {
                return defineProp("FeedHandler", require("./FeedHandler.js"));
            },
            get Stream() {
                return defineProp("Stream", require("./Stream.js"));
            },
            get WritableStream() {
                return defineProp("WritableStream", require("./WritableStream.js"));
            },
            get ProxyHandler() {
                return defineProp("ProxyHandler", require("./ProxyHandler.js"));
            },
            get DomUtils() {
                return defineProp("DomUtils", require("domutils"));
            },
            get CollectingHandler() {
                return defineProp("CollectingHandler", require("./CollectingHandler.js"));
            },
            // For legacy support
            DefaultHandler: DomHandler,
            get RssHandler() {
                return defineProp("RssHandler", this.FeedHandler);
            },
            //helper methods
            parseDOM: function (data, options) {
                var handler = new DomHandler(options);
                new Parser(handler, options).end(data);
                return handler.dom;
            },
            parseFeed: function (feed, options) {
                var handler = new module.exports.FeedHandler(options);
                new Parser(handler, options).end(feed);
                return handler.dom;
            },
            createDomStream: function (cb, options, elementCb) {
                var handler = new DomHandler(cb, options, elementCb);
                return new Parser(handler, options);
            },
            // List of all events that the parser emits
            EVENTS: {
                /* Format: eventname: number of arguments */
                attribute: 2,
                cdatastart: 0,
                cdataend: 0,
                text: 1,
                processinginstruction: 2,
                comment: 1,
                commentend: 0,
                closetag: 1,
                opentag: 2,
                opentagname: 1,
                error: 1,
                end: 0
            }
        };

    }, {
        "./CollectingHandler.js": 6,
        "./FeedHandler.js": 7,
        "./Parser.js": 8,
        "./ProxyHandler.js": 9,
        "./Stream.js": 10,
        "./Tokenizer.js": 11,
        "./WritableStream.js": 12,
        "domelementtype": 14,
        "domhandler": 15,
        "domutils": 18
    }],
    14: [function (require, module, exports) {
//Types of elements found in the DOM
        module.exports = {
            Text: "text", //Text
            Directive: "directive", //<? ... ?>
            Comment: "comment", //<!-- ... -->
            Script: "script", //<script> tags
            Style: "style", //<style> tags
            Tag: "tag", //Any tag
            CDATA: "cdata", //<![CDATA[ ... ]]>
            Doctype: "doctype",

            isTag: function (elem) {
                return elem.type === "tag" || elem.type === "script" || elem.type === "style";
            }
        };

    }, {}],
    15: [function (require, module, exports) {
        var ElementType = require("domelementtype");

        var re_whitespace = /\s+/g;
        var NodePrototype = require("./lib/node");
        var ElementPrototype = require("./lib/element");

        function DomHandler(callback, options, elementCB) {
            if (typeof callback === "object") {
                elementCB = options;
                options = callback;
                callback = null;
            } else if (typeof options === "function") {
                elementCB = options;
                options = defaultOpts;
            }
            this._callback = callback;
            this._options = options || defaultOpts;
            this._elementCB = elementCB;
            this.dom = [];
            this._done = false;
            this._tagStack = [];
            this._parser = this._parser || null;
        }

//default options
        var defaultOpts = {
            normalizeWhitespace: false, //Replace all whitespace with single spaces
            withStartIndices: false, //Add startIndex properties to nodes
        };

        DomHandler.prototype.onparserinit = function (parser) {
            this._parser = parser;
        };

//Resets the handler back to starting state
        DomHandler.prototype.onreset = function () {
            DomHandler.call(this, this._callback, this._options, this._elementCB);
        };

//Signals the handler that parsing is done
        DomHandler.prototype.onend = function () {
            if (this._done) return;
            this._done = true;
            this._parser = null;
            this._handleCallback(null);
        };

        DomHandler.prototype._handleCallback =
            DomHandler.prototype.onerror = function (error) {
                if (typeof this._callback === "function") {
                    this._callback(error, this.dom);
                } else {
                    if (error) throw error;
                }
            };

        DomHandler.prototype.onclosetag = function () {
            //if(this._tagStack.pop().name !== name) this._handleCallback(Error("Tagname didn't match!"));
            var elem = this._tagStack.pop();
            if (this._elementCB) this._elementCB(elem);
        };

        DomHandler.prototype._addDomElement = function (element) {
            var parent = this._tagStack[this._tagStack.length - 1];
            var siblings = parent ? parent.children : this.dom;
            var previousSibling = siblings[siblings.length - 1];

            element.next = null;

            if (this._options.withStartIndices) {
                element.startIndex = this._parser.startIndex;
            }

            if (this._options.withDomLvl1) {
                element.__proto__ = element.type === "tag" ? ElementPrototype : NodePrototype;
            }

            if (previousSibling) {
                element.prev = previousSibling;
                previousSibling.next = element;
            } else {
                element.prev = null;
            }

            siblings.push(element);
            element.parent = parent || null;
        };

        DomHandler.prototype.onopentag = function (name, attribs) {
            var element = {
                type: name === "script" ? ElementType.Script : name === "style" ? ElementType.Style : ElementType.Tag,
                name: name,
                attribs: attribs,
                children: []
            };

            this._addDomElement(element);

            this._tagStack.push(element);
        };

        DomHandler.prototype.ontext = function (data) {
            //the ignoreWhitespace is officially dropped, but for now,
            //it's an alias for normalizeWhitespace
            var normalize = this._options.normalizeWhitespace || this._options.ignoreWhitespace;

            var lastTag;

            if (!this._tagStack.length && this.dom.length && (lastTag = this.dom[this.dom.length - 1]).type === ElementType.Text) {
                if (normalize) {
                    lastTag.data = (lastTag.data + data).replace(re_whitespace, " ");
                } else {
                    lastTag.data += data;
                }
            } else {
                if (
                    this._tagStack.length &&
                    (lastTag = this._tagStack[this._tagStack.length - 1]) &&
                    (lastTag = lastTag.children[lastTag.children.length - 1]) &&
                    lastTag.type === ElementType.Text
                ) {
                    if (normalize) {
                        lastTag.data = (lastTag.data + data).replace(re_whitespace, " ");
                    } else {
                        lastTag.data += data;
                    }
                } else {
                    if (normalize) {
                        data = data.replace(re_whitespace, " ");
                    }

                    this._addDomElement({
                        data: data,
                        type: ElementType.Text
                    });
                }
            }
        };

        DomHandler.prototype.oncomment = function (data) {
            var lastTag = this._tagStack[this._tagStack.length - 1];

            if (lastTag && lastTag.type === ElementType.Comment) {
                lastTag.data += data;
                return;
            }

            var element = {
                data: data,
                type: ElementType.Comment
            };

            this._addDomElement(element);
            this._tagStack.push(element);
        };

        DomHandler.prototype.oncdatastart = function () {
            var element = {
                children: [{
                    data: "",
                    type: ElementType.Text
                }],
                type: ElementType.CDATA
            };

            this._addDomElement(element);
            this._tagStack.push(element);
        };

        DomHandler.prototype.oncommentend = DomHandler.prototype.oncdataend = function () {
            this._tagStack.pop();
        };

        DomHandler.prototype.onprocessinginstruction = function (name, data) {
            this._addDomElement({
                name: name,
                data: data,
                type: ElementType.Directive
            });
        };

        module.exports = DomHandler;

    }, {"./lib/element": 16, "./lib/node": 17, "domelementtype": 14}],
    16: [function (require, module, exports) {
// DOM-Level-1-compliant structure
        var NodePrototype = require('./node');
        var ElementPrototype = module.exports = Object.create(NodePrototype);

        var domLvl1 = {
            tagName: "name"
        };

        Object.keys(domLvl1).forEach(function (key) {
            var shorthand = domLvl1[key];
            Object.defineProperty(ElementPrototype, key, {
                get: function () {
                    return this[shorthand] || null;
                },
                set: function (val) {
                    this[shorthand] = val;
                    return val;
                }
            });
        });

    }, {"./node": 17}],
    17: [function (require, module, exports) {
// This object will be used as the prototype for Nodes when creating a
// DOM-Level-1-compliant structure.
        var NodePrototype = module.exports = {
            get firstChild() {
                var children = this.children;
                return children && children[0] || null;
            },
            get lastChild() {
                var children = this.children;
                return children && children[children.length - 1] || null;
            },
            get nodeType() {
                return nodeTypes[this.type] || nodeTypes.element;
            }
        };

        var domLvl1 = {
            tagName: "name",
            childNodes: "children",
            parentNode: "parent",
            previousSibling: "prev",
            nextSibling: "next",
            nodeValue: "data"
        };

        var nodeTypes = {
            element: 1,
            text: 3,
            cdata: 4,
            comment: 8
        };

        Object.keys(domLvl1).forEach(function (key) {
            var shorthand = domLvl1[key];
            Object.defineProperty(NodePrototype, key, {
                get: function () {
                    return this[shorthand] || null;
                },
                set: function (val) {
                    this[shorthand] = val;
                    return val;
                }
            });
        });

    }, {}],
    18: [function (require, module, exports) {
        var DomUtils = module.exports;

        [
            require("./lib/stringify"),
            require("./lib/traversal"),
            require("./lib/manipulation"),
            require("./lib/querying"),
            require("./lib/legacy"),
            require("./lib/helpers")
        ].forEach(function (ext) {
            Object.keys(ext).forEach(function (key) {
                DomUtils[key] = ext[key].bind(DomUtils);
            });
        });

    }, {
        "./lib/helpers": 19,
        "./lib/legacy": 20,
        "./lib/manipulation": 21,
        "./lib/querying": 22,
        "./lib/stringify": 23,
        "./lib/traversal": 24
    }],
    19: [function (require, module, exports) {
// removeSubsets
// Given an array of nodes, remove any member that is contained by another.
        exports.removeSubsets = function (nodes) {
            var idx = nodes.length, node, ancestor, replace;

            // Check if each node (or one of its ancestors) is already contained in the
            // array.
            while (--idx > -1) {
                node = ancestor = nodes[idx];

                // Temporarily remove the node under consideration
                nodes[idx] = null;
                replace = true;

                while (ancestor) {
                    if (nodes.indexOf(ancestor) > -1) {
                        replace = false;
                        nodes.splice(idx, 1);
                        break;
                    }
                    ancestor = ancestor.parent;
                }

                // If the node has been found to be unique, re-insert it.
                if (replace) {
                    nodes[idx] = node;
                }
            }

            return nodes;
        };

// Source: http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
        var POSITION = {
            DISCONNECTED: 1,
            PRECEDING: 2,
            FOLLOWING: 4,
            CONTAINS: 8,
            CONTAINED_BY: 16
        };

// Compare the position of one node against another node in any other document.
// The return value is a bitmask with the following values:
//
// document order:
// > There is an ordering, document order, defined on all the nodes in the
// > document corresponding to the order in which the first character of the
// > XML representation of each node occurs in the XML representation of the
// > document after expansion of general entities. Thus, the document element
// > node will be the first node. Element nodes occur before their children.
// > Thus, document order orders element nodes in order of the occurrence of
// > their start-tag in the XML (after expansion of entities). The attribute
// > nodes of an element occur after the element and before its children. The
// > relative order of attribute nodes is implementation-dependent./
// Source:
// http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
//
// @argument {Node} nodaA The first node to use in the comparison
// @argument {Node} nodeB The second node to use in the comparison
//
// @return {Number} A bitmask describing the input nodes' relative position.
//         See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
//         a description of these values.
        var comparePos = exports.compareDocumentPosition = function (nodeA, nodeB) {
            var aParents = [];
            var bParents = [];
            var current, sharedParent, siblings, aSibling, bSibling, idx;

            if (nodeA === nodeB) {
                return 0;
            }

            current = nodeA;
            while (current) {
                aParents.unshift(current);
                current = current.parent;
            }
            current = nodeB;
            while (current) {
                bParents.unshift(current);
                current = current.parent;
            }

            idx = 0;
            while (aParents[idx] === bParents[idx]) {
                idx++;
            }

            if (idx === 0) {
                return POSITION.DISCONNECTED;
            }

            sharedParent = aParents[idx - 1];
            siblings = sharedParent.children;
            aSibling = aParents[idx];
            bSibling = bParents[idx];

            if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
                if (sharedParent === nodeB) {
                    return POSITION.FOLLOWING | POSITION.CONTAINED_BY;
                }
                return POSITION.FOLLOWING;
            } else {
                if (sharedParent === nodeA) {
                    return POSITION.PRECEDING | POSITION.CONTAINS;
                }
                return POSITION.PRECEDING;
            }
        };

// Sort an array of nodes based on their relative position in the document and
// remove any duplicate nodes. If the array contains nodes that do not belong
// to the same document, sort order is unspecified.
//
// @argument {Array} nodes Array of DOM nodes
//
// @returns {Array} collection of unique nodes, sorted in document order
        exports.uniqueSort = function (nodes) {
            var idx = nodes.length, node, position;

            nodes = nodes.slice();

            while (--idx > -1) {
                node = nodes[idx];
                position = nodes.indexOf(node);
                if (position > -1 && position < idx) {
                    nodes.splice(idx, 1);
                }
            }
            nodes.sort(function (a, b) {
                var relative = comparePos(a, b);
                if (relative & POSITION.PRECEDING) {
                    return -1;
                } else if (relative & POSITION.FOLLOWING) {
                    return 1;
                }
                return 0;
            });

            return nodes;
        };

    }, {}],
    20: [function (require, module, exports) {
        var ElementType = require("domelementtype");
        var isTag = exports.isTag = ElementType.isTag;

        exports.testElement = function (options, element) {
            for (var key in options) {
                if (!options.hasOwnProperty(key)) ;
                else if (key === "tag_name") {
                    if (!isTag(element) || !options.tag_name(element.name)) {
                        return false;
                    }
                } else if (key === "tag_type") {
                    if (!options.tag_type(element.type)) return false;
                } else if (key === "tag_contains") {
                    if (isTag(element) || !options.tag_contains(element.data)) {
                        return false;
                    }
                } else if (!element.attribs || !options[key](element.attribs[key])) {
                    return false;
                }
            }
            return true;
        };

        var Checks = {
            tag_name: function (name) {
                if (typeof name === "function") {
                    return function (elem) {
                        return isTag(elem) && name(elem.name);
                    };
                } else if (name === "*") {
                    return isTag;
                } else {
                    return function (elem) {
                        return isTag(elem) && elem.name === name;
                    };
                }
            },
            tag_type: function (type) {
                if (typeof type === "function") {
                    return function (elem) {
                        return type(elem.type);
                    };
                } else {
                    return function (elem) {
                        return elem.type === type;
                    };
                }
            },
            tag_contains: function (data) {
                if (typeof data === "function") {
                    return function (elem) {
                        return !isTag(elem) && data(elem.data);
                    };
                } else {
                    return function (elem) {
                        return !isTag(elem) && elem.data === data;
                    };
                }
            }
        };

        function getAttribCheck(attrib, value) {
            if (typeof value === "function") {
                return function (elem) {
                    return elem.attribs && value(elem.attribs[attrib]);
                };
            } else {
                return function (elem) {
                    return elem.attribs && elem.attribs[attrib] === value;
                };
            }
        }

        function combineFuncs(a, b) {
            return function (elem) {
                return a(elem) || b(elem);
            };
        }

        exports.getElements = function (options, element, recurse, limit) {
            var funcs = Object.keys(options).map(function (key) {
                var value = options[key];
                return key in Checks ? Checks[key](value) : getAttribCheck(key, value);
            });

            return funcs.length === 0 ? [] : this.filter(
                funcs.reduce(combineFuncs),
                element, recurse, limit
            );
        };

        exports.getElementById = function (id, element, recurse) {
            if (!Array.isArray(element)) element = [element];
            return this.findOne(getAttribCheck("id", id), element, recurse !== false);
        };

        exports.getElementsByTagName = function (name, element, recurse, limit) {
            return this.filter(Checks.tag_name(name), element, recurse, limit);
        };

        exports.getElementsByTagType = function (type, element, recurse, limit) {
            return this.filter(Checks.tag_type(type), element, recurse, limit);
        };

    }, {"domelementtype": 14}],
    21: [function (require, module, exports) {
        exports.removeElement = function (elem) {
            if (elem.prev) elem.prev.next = elem.next;
            if (elem.next) elem.next.prev = elem.prev;

            if (elem.parent) {
                var childs = elem.parent.children;
                childs.splice(childs.lastIndexOf(elem), 1);
            }
        };

        exports.replaceElement = function (elem, replacement) {
            var prev = replacement.prev = elem.prev;
            if (prev) {
                prev.next = replacement;
            }

            var next = replacement.next = elem.next;
            if (next) {
                next.prev = replacement;
            }

            var parent = replacement.parent = elem.parent;
            if (parent) {
                var childs = parent.children;
                childs[childs.lastIndexOf(elem)] = replacement;
            }
        };

        exports.appendChild = function (elem, child) {
            child.parent = elem;

            if (elem.children.push(child) !== 1) {
                var sibling = elem.children[elem.children.length - 2];
                sibling.next = child;
                child.prev = sibling;
                child.next = null;
            }
        };

        exports.append = function (elem, next) {
            var parent = elem.parent,
                currNext = elem.next;

            next.next = currNext;
            next.prev = elem;
            elem.next = next;
            next.parent = parent;

            if (currNext) {
                currNext.prev = next;
                if (parent) {
                    var childs = parent.children;
                    childs.splice(childs.lastIndexOf(currNext), 0, next);
                }
            } else if (parent) {
                parent.children.push(next);
            }
        };

        exports.prepend = function (elem, prev) {
            var parent = elem.parent;
            if (parent) {
                var childs = parent.children;
                childs.splice(childs.lastIndexOf(elem), 0, prev);
            }

            if (elem.prev) {
                elem.prev.next = prev;
            }

            prev.parent = parent;
            prev.prev = elem.prev;
            prev.next = elem;
            elem.prev = prev;
        };


    }, {}],
    22: [function (require, module, exports) {
        var isTag = require("domelementtype").isTag;

        module.exports = {
            filter: filter,
            find: find,
            findOneChild: findOneChild,
            findOne: findOne,
            existsOne: existsOne,
            findAll: findAll
        };

        function filter(test, element, recurse, limit) {
            if (!Array.isArray(element)) element = [element];

            if (typeof limit !== "number" || !isFinite(limit)) {
                limit = Infinity;
            }
            return find(test, element, recurse !== false, limit);
        }

        function find(test, elems, recurse, limit) {
            var result = [], childs;

            for (var i = 0, j = elems.length; i < j; i++) {
                if (test(elems[i])) {
                    result.push(elems[i]);
                    if (--limit <= 0) break;
                }

                childs = elems[i].children;
                if (recurse && childs && childs.length > 0) {
                    childs = find(test, childs, recurse, limit);
                    result = result.concat(childs);
                    limit -= childs.length;
                    if (limit <= 0) break;
                }
            }

            return result;
        }

        function findOneChild(test, elems) {
            for (var i = 0, l = elems.length; i < l; i++) {
                if (test(elems[i])) return elems[i];
            }

            return null;
        }

        function findOne(test, elems) {
            var elem = null;

            for (var i = 0, l = elems.length; i < l && !elem; i++) {
                if (!isTag(elems[i])) {
                    continue;
                } else if (test(elems[i])) {
                    elem = elems[i];
                } else if (elems[i].children.length > 0) {
                    elem = findOne(test, elems[i].children);
                }
            }

            return elem;
        }

        function existsOne(test, elems) {
            for (var i = 0, l = elems.length; i < l; i++) {
                if (
                    isTag(elems[i]) && (
                        test(elems[i]) || (
                            elems[i].children.length > 0 &&
                            existsOne(test, elems[i].children)
                        )
                    )
                ) {
                    return true;
                }
            }

            return false;
        }

        function findAll(test, elems) {
            var result = [];
            for (var i = 0, j = elems.length; i < j; i++) {
                if (!isTag(elems[i])) continue;
                if (test(elems[i])) result.push(elems[i]);

                if (elems[i].children.length > 0) {
                    result = result.concat(findAll(test, elems[i].children));
                }
            }
            return result;
        }

    }, {"domelementtype": 14}],
    23: [function (require, module, exports) {
        var ElementType = require("domelementtype"),
            getOuterHTML = require("dom-serializer"),
            isTag = ElementType.isTag;

        module.exports = {
            getInnerHTML: getInnerHTML,
            getOuterHTML: getOuterHTML,
            getText: getText
        };

        function getInnerHTML(elem, opts) {
            return elem.children ? elem.children.map(function (elem) {
                return getOuterHTML(elem, opts);
            }).join("") : "";
        }

        function getText(elem) {
            if (Array.isArray(elem)) return elem.map(getText).join("");
            if (isTag(elem) || elem.type === ElementType.CDATA) return getText(elem.children);
            if (elem.type === ElementType.Text) return elem.data;
            return "";
        }

    }, {"dom-serializer": 25, "domelementtype": 14}],
    24: [function (require, module, exports) {
        var getChildren = exports.getChildren = function (elem) {
            return elem.children;
        };

        var getParent = exports.getParent = function (elem) {
            return elem.parent;
        };

        exports.getSiblings = function (elem) {
            var parent = getParent(elem);
            return parent ? getChildren(parent) : [elem];
        };

        exports.getAttributeValue = function (elem, name) {
            return elem.attribs && elem.attribs[name];
        };

        exports.hasAttrib = function (elem, name) {
            return !!elem.attribs && hasOwnProperty.call(elem.attribs, name);
        };

        exports.getName = function (elem) {
            return elem.name;
        };

    }, {}],
    25: [function (require, module, exports) {
        /*
  Module dependencies
*/
        var ElementType = require('domelementtype');
        var entities = require('entities');

        /*
  Boolean Attributes
*/
        var booleanAttributes = {
            __proto__: null,
            allowfullscreen: true,
            async: true,
            autofocus: true,
            autoplay: true,
            checked: true,
            controls: true,
            default: true,
            defer: true,
            disabled: true,
            hidden: true,
            ismap: true,
            loop: true,
            multiple: true,
            muted: true,
            open: true,
            readonly: true,
            required: true,
            reversed: true,
            scoped: true,
            seamless: true,
            selected: true,
            typemustmatch: true
        };

        var unencodedElements = {
            __proto__: null,
            style: true,
            script: true,
            xmp: true,
            iframe: true,
            noembed: true,
            noframes: true,
            plaintext: true,
            noscript: true
        };

        /*
  Format attributes
*/
        function formatAttrs(attributes, opts) {
            if (!attributes) return;

            var output = '',
                value;

            // Loop through the attributes
            for (var key in attributes) {
                value = attributes[key];
                if (output) {
                    output += ' ';
                }

                if (!value && booleanAttributes[key]) {
                    output += key;
                } else {
                    output += key + '="' + (opts.decodeEntities ? entities.encodeXML(value) : value) + '"';
                }
            }

            return output;
        }

        /*
  Self-enclosing tags (stolen from node-htmlparser)
*/
        var singleTag = {
            __proto__: null,
            area: true,
            base: true,
            basefont: true,
            br: true,
            col: true,
            command: true,
            embed: true,
            frame: true,
            hr: true,
            img: true,
            input: true,
            isindex: true,
            keygen: true,
            link: true,
            meta: true,
            param: true,
            source: true,
            track: true,
            wbr: true,
        };


        var render = module.exports = function (dom, opts) {
            if (!Array.isArray(dom) && !dom.cheerio) dom = [dom];
            opts = opts || {};

            var output = '';

            for (var i = 0; i < dom.length; i++) {
                var elem = dom[i];

                if (elem.type === 'root')
                    output += render(elem.children, opts);
                else if (ElementType.isTag(elem))
                    output += renderTag(elem, opts);
                else if (elem.type === ElementType.Directive)
                    output += renderDirective(elem);
                else if (elem.type === ElementType.Comment)
                    output += renderComment(elem);
                else if (elem.type === ElementType.CDATA)
                    output += renderCdata(elem);
                else
                    output += renderText(elem, opts);
            }

            return output;
        };

        function renderTag(elem, opts) {
            // Handle SVG
            if (elem.name === "svg") opts = {decodeEntities: opts.decodeEntities, xmlMode: true};

            var tag = '<' + elem.name,
                attribs = formatAttrs(elem.attribs, opts);

            if (attribs) {
                tag += ' ' + attribs;
            }

            if (
                opts.xmlMode
                && (!elem.children || elem.children.length === 0)
            ) {
                tag += '/>';
            } else {
                tag += '>';
                if (elem.children) {
                    tag += render(elem.children, opts);
                }

                if (!singleTag[elem.name] || opts.xmlMode) {
                    tag += '</' + elem.name + '>';
                }
            }

            return tag;
        }

        function renderDirective(elem) {
            return '<' + elem.data + '>';
        }

        function renderText(elem, opts) {
            var data = elem.data || '';

            // if entities weren't decoded, no need to encode them back
            if (opts.decodeEntities && !(elem.parent && elem.parent.name in unencodedElements)) {
                data = entities.encodeXML(data);
            }

            return data;
        }

        function renderCdata(elem) {
            return '<![CDATA[' + elem.children[0].data + ']]>';
        }

        function renderComment(elem) {
            return '<!--' + elem.data + '-->';
        }

    }, {"domelementtype": 26, "entities": 27}],
    26: [function (require, module, exports) {
//Types of elements found in the DOM
        module.exports = {
            Text: "text", //Text
            Directive: "directive", //<? ... ?>
            Comment: "comment", //<!-- ... -->
            Script: "script", //<script> tags
            Style: "style", //<style> tags
            Tag: "tag", //Any tag
            CDATA: "cdata", //<![CDATA[ ... ]]>

            isTag: function (elem) {
                return elem.type === "tag" || elem.type === "script" || elem.type === "style";
            }
        };
    }, {}],
    27: [function (require, module, exports) {
        var encode = require("./lib/encode.js"),
            decode = require("./lib/decode.js");

        exports.decode = function (data, level) {
            return (!level || level <= 0 ? decode.XML : decode.HTML)(data);
        };

        exports.decodeStrict = function (data, level) {
            return (!level || level <= 0 ? decode.XML : decode.HTMLStrict)(data);
        };

        exports.encode = function (data, level) {
            return (!level || level <= 0 ? encode.XML : encode.HTML)(data);
        };

        exports.encodeXML = encode.XML;

        exports.encodeHTML4 =
            exports.encodeHTML5 =
                exports.encodeHTML = encode.HTML;

        exports.decodeXML =
            exports.decodeXMLStrict = decode.XML;

        exports.decodeHTML4 =
            exports.decodeHTML5 =
                exports.decodeHTML = decode.HTML;

        exports.decodeHTML4Strict =
            exports.decodeHTML5Strict =
                exports.decodeHTMLStrict = decode.HTMLStrict;

        exports.escape = encode.escape;

    }, {"./lib/decode.js": 28, "./lib/encode.js": 30}],
    28: [function (require, module, exports) {
        var entityMap = require("../maps/entities.json"),
            legacyMap = require("../maps/legacy.json"),
            xmlMap = require("../maps/xml.json"),
            decodeCodePoint = require("./decode_codepoint.js");

        var decodeXMLStrict = getStrictDecoder(xmlMap),
            decodeHTMLStrict = getStrictDecoder(entityMap);

        function getStrictDecoder(map) {
            var keys = Object.keys(map).join("|"),
                replace = getReplacer(map);

            keys += "|#[xX][\\da-fA-F]+|#\\d+";

            var re = new RegExp("&(?:" + keys + ");", "g");

            return function (str) {
                return String(str).replace(re, replace);
            };
        }

        var decodeHTML = (function () {
            var legacy = Object.keys(legacyMap)
                .sort(sorter);

            var keys = Object.keys(entityMap)
                .sort(sorter);

            for (var i = 0, j = 0; i < keys.length; i++) {
                if (legacy[j] === keys[i]) {
                    keys[i] += ";?";
                    j++;
                } else {
                    keys[i] += ";";
                }
            }

            var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g"),
                replace = getReplacer(entityMap);

            function replacer(str) {
                if (str.substr(-1) !== ";") str += ";";
                return replace(str);
            }

            //TODO consider creating a merged map
            return function (str) {
                return String(str).replace(re, replacer);
            };
        }());

        function sorter(a, b) {
            return a < b ? 1 : -1;
        }

        function getReplacer(map) {
            return function replace(str) {
                if (str.charAt(1) === "#") {
                    if (str.charAt(2) === "X" || str.charAt(2) === "x") {
                        return decodeCodePoint(parseInt(str.substr(3), 16));
                    }
                    return decodeCodePoint(parseInt(str.substr(2), 10));
                }
                return map[str.slice(1, -1)];
            };
        }

        module.exports = {
            XML: decodeXMLStrict,
            HTML: decodeHTML,
            HTMLStrict: decodeHTMLStrict
        };
    }, {"../maps/entities.json": 32, "../maps/legacy.json": 33, "../maps/xml.json": 34, "./decode_codepoint.js": 29}],
    29: [function (require, module, exports) {
        var decodeMap = require("../maps/decode.json");

        module.exports = decodeCodePoint;

// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
        function decodeCodePoint(codePoint) {

            if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
                return "\uFFFD";
            }

            if (codePoint in decodeMap) {
                codePoint = decodeMap[codePoint];
            }

            var output = "";

            if (codePoint > 0xFFFF) {
                codePoint -= 0x10000;
                output += String.fromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
                codePoint = 0xDC00 | codePoint & 0x3FF;
            }

            output += String.fromCharCode(codePoint);
            return output;
        }

    }, {"../maps/decode.json": 31}],
    30: [function (require, module, exports) {
        var inverseXML = getInverseObj(require("../maps/xml.json")),
            xmlReplacer = getInverseReplacer(inverseXML);

        exports.XML = getInverse(inverseXML, xmlReplacer);

        var inverseHTML = getInverseObj(require("../maps/entities.json")),
            htmlReplacer = getInverseReplacer(inverseHTML);

        exports.HTML = getInverse(inverseHTML, htmlReplacer);

        function getInverseObj(obj) {
            return Object.keys(obj).sort().reduce(function (inverse, name) {
                inverse[obj[name]] = "&" + name + ";";
                return inverse;
            }, {});
        }

        function getInverseReplacer(inverse) {
            var single = [],
                multiple = [];

            Object.keys(inverse).forEach(function (k) {
                if (k.length === 1) {
                    single.push("\\" + k);
                } else {
                    multiple.push(k);
                }
            });

            //TODO add ranges
            multiple.unshift("[" + single.join("") + "]");

            return new RegExp(multiple.join("|"), "g");
        }

        var re_nonASCII = /[^\0-\x7F]/g,
            re_astralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;

        function singleCharReplacer(c) {
            return "&#x" + c.charCodeAt(0).toString(16).toUpperCase() + ";";
        }

        function astralReplacer(c) {
            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
            var high = c.charCodeAt(0);
            var low = c.charCodeAt(1);
            var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
            return "&#x" + codePoint.toString(16).toUpperCase() + ";";
        }

        function getInverse(inverse, re) {
            function func(name) {
                return inverse[name];
            }

            return function (data) {
                return data
                    .replace(re, func)
                    .replace(re_astralSymbols, astralReplacer)
                    .replace(re_nonASCII, singleCharReplacer);
            };
        }

        var re_xmlChars = getInverseReplacer(inverseXML);

        function escapeXML(data) {
            return data
                .replace(re_xmlChars, singleCharReplacer)
                .replace(re_astralSymbols, astralReplacer)
                .replace(re_nonASCII, singleCharReplacer);
        }

        exports.escape = escapeXML;

    }, {"../maps/entities.json": 32, "../maps/xml.json": 34}],
    31: [function (require, module, exports) {
        module.exports = {
            "0": 65533,
            "128": 8364,
            "130": 8218,
            "131": 402,
            "132": 8222,
            "133": 8230,
            "134": 8224,
            "135": 8225,
            "136": 710,
            "137": 8240,
            "138": 352,
            "139": 8249,
            "140": 338,
            "142": 381,
            "145": 8216,
            "146": 8217,
            "147": 8220,
            "148": 8221,
            "149": 8226,
            "150": 8211,
            "151": 8212,
            "152": 732,
            "153": 8482,
            "154": 353,
            "155": 8250,
            "156": 339,
            "158": 382,
            "159": 376
        }
    }, {}],
    32: [function (require, module, exports) {
        module.exports = {
            "Aacute": "\u00C1",
            "aacute": "\u00E1",
            "Abreve": "\u0102",
            "abreve": "\u0103",
            "ac": "\u223E",
            "acd": "\u223F",
            "acE": "\u223E\u0333",
            "Acirc": "\u00C2",
            "acirc": "\u00E2",
            "acute": "\u00B4",
            "Acy": "\u0410",
            "acy": "\u0430",
            "AElig": "\u00C6",
            "aelig": "\u00E6",
            "af": "\u2061",
            "Afr": "\uD835\uDD04",
            "afr": "\uD835\uDD1E",
            "Agrave": "\u00C0",
            "agrave": "\u00E0",
            "alefsym": "\u2135",
            "aleph": "\u2135",
            "Alpha": "\u0391",
            "alpha": "\u03B1",
            "Amacr": "\u0100",
            "amacr": "\u0101",
            "amalg": "\u2A3F",
            "amp": "&",
            "AMP": "&",
            "andand": "\u2A55",
            "And": "\u2A53",
            "and": "\u2227",
            "andd": "\u2A5C",
            "andslope": "\u2A58",
            "andv": "\u2A5A",
            "ang": "\u2220",
            "ange": "\u29A4",
            "angle": "\u2220",
            "angmsdaa": "\u29A8",
            "angmsdab": "\u29A9",
            "angmsdac": "\u29AA",
            "angmsdad": "\u29AB",
            "angmsdae": "\u29AC",
            "angmsdaf": "\u29AD",
            "angmsdag": "\u29AE",
            "angmsdah": "\u29AF",
            "angmsd": "\u2221",
            "angrt": "\u221F",
            "angrtvb": "\u22BE",
            "angrtvbd": "\u299D",
            "angsph": "\u2222",
            "angst": "\u00C5",
            "angzarr": "\u237C",
            "Aogon": "\u0104",
            "aogon": "\u0105",
            "Aopf": "\uD835\uDD38",
            "aopf": "\uD835\uDD52",
            "apacir": "\u2A6F",
            "ap": "\u2248",
            "apE": "\u2A70",
            "ape": "\u224A",
            "apid": "\u224B",
            "apos": "'",
            "ApplyFunction": "\u2061",
            "approx": "\u2248",
            "approxeq": "\u224A",
            "Aring": "\u00C5",
            "aring": "\u00E5",
            "Ascr": "\uD835\uDC9C",
            "ascr": "\uD835\uDCB6",
            "Assign": "\u2254",
            "ast": "*",
            "asymp": "\u2248",
            "asympeq": "\u224D",
            "Atilde": "\u00C3",
            "atilde": "\u00E3",
            "Auml": "\u00C4",
            "auml": "\u00E4",
            "awconint": "\u2233",
            "awint": "\u2A11",
            "backcong": "\u224C",
            "backepsilon": "\u03F6",
            "backprime": "\u2035",
            "backsim": "\u223D",
            "backsimeq": "\u22CD",
            "Backslash": "\u2216",
            "Barv": "\u2AE7",
            "barvee": "\u22BD",
            "barwed": "\u2305",
            "Barwed": "\u2306",
            "barwedge": "\u2305",
            "bbrk": "\u23B5",
            "bbrktbrk": "\u23B6",
            "bcong": "\u224C",
            "Bcy": "\u0411",
            "bcy": "\u0431",
            "bdquo": "\u201E",
            "becaus": "\u2235",
            "because": "\u2235",
            "Because": "\u2235",
            "bemptyv": "\u29B0",
            "bepsi": "\u03F6",
            "bernou": "\u212C",
            "Bernoullis": "\u212C",
            "Beta": "\u0392",
            "beta": "\u03B2",
            "beth": "\u2136",
            "between": "\u226C",
            "Bfr": "\uD835\uDD05",
            "bfr": "\uD835\uDD1F",
            "bigcap": "\u22C2",
            "bigcirc": "\u25EF",
            "bigcup": "\u22C3",
            "bigodot": "\u2A00",
            "bigoplus": "\u2A01",
            "bigotimes": "\u2A02",
            "bigsqcup": "\u2A06",
            "bigstar": "\u2605",
            "bigtriangledown": "\u25BD",
            "bigtriangleup": "\u25B3",
            "biguplus": "\u2A04",
            "bigvee": "\u22C1",
            "bigwedge": "\u22C0",
            "bkarow": "\u290D",
            "blacklozenge": "\u29EB",
            "blacksquare": "\u25AA",
            "blacktriangle": "\u25B4",
            "blacktriangledown": "\u25BE",
            "blacktriangleleft": "\u25C2",
            "blacktriangleright": "\u25B8",
            "blank": "\u2423",
            "blk12": "\u2592",
            "blk14": "\u2591",
            "blk34": "\u2593",
            "block": "\u2588",
            "bne": "=\u20E5",
            "bnequiv": "\u2261\u20E5",
            "bNot": "\u2AED",
            "bnot": "\u2310",
            "Bopf": "\uD835\uDD39",
            "bopf": "\uD835\uDD53",
            "bot": "\u22A5",
            "bottom": "\u22A5",
            "bowtie": "\u22C8",
            "boxbox": "\u29C9",
            "boxdl": "\u2510",
            "boxdL": "\u2555",
            "boxDl": "\u2556",
            "boxDL": "\u2557",
            "boxdr": "\u250C",
            "boxdR": "\u2552",
            "boxDr": "\u2553",
            "boxDR": "\u2554",
            "boxh": "\u2500",
            "boxH": "\u2550",
            "boxhd": "\u252C",
            "boxHd": "\u2564",
            "boxhD": "\u2565",
            "boxHD": "\u2566",
            "boxhu": "\u2534",
            "boxHu": "\u2567",
            "boxhU": "\u2568",
            "boxHU": "\u2569",
            "boxminus": "\u229F",
            "boxplus": "\u229E",
            "boxtimes": "\u22A0",
            "boxul": "\u2518",
            "boxuL": "\u255B",
            "boxUl": "\u255C",
            "boxUL": "\u255D",
            "boxur": "\u2514",
            "boxuR": "\u2558",
            "boxUr": "\u2559",
            "boxUR": "\u255A",
            "boxv": "\u2502",
            "boxV": "\u2551",
            "boxvh": "\u253C",
            "boxvH": "\u256A",
            "boxVh": "\u256B",
            "boxVH": "\u256C",
            "boxvl": "\u2524",
            "boxvL": "\u2561",
            "boxVl": "\u2562",
            "boxVL": "\u2563",
            "boxvr": "\u251C",
            "boxvR": "\u255E",
            "boxVr": "\u255F",
            "boxVR": "\u2560",
            "bprime": "\u2035",
            "breve": "\u02D8",
            "Breve": "\u02D8",
            "brvbar": "\u00A6",
            "bscr": "\uD835\uDCB7",
            "Bscr": "\u212C",
            "bsemi": "\u204F",
            "bsim": "\u223D",
            "bsime": "\u22CD",
            "bsolb": "\u29C5",
            "bsol": "\\",
            "bsolhsub": "\u27C8",
            "bull": "\u2022",
            "bullet": "\u2022",
            "bump": "\u224E",
            "bumpE": "\u2AAE",
            "bumpe": "\u224F",
            "Bumpeq": "\u224E",
            "bumpeq": "\u224F",
            "Cacute": "\u0106",
            "cacute": "\u0107",
            "capand": "\u2A44",
            "capbrcup": "\u2A49",
            "capcap": "\u2A4B",
            "cap": "\u2229",
            "Cap": "\u22D2",
            "capcup": "\u2A47",
            "capdot": "\u2A40",
            "CapitalDifferentialD": "\u2145",
            "caps": "\u2229\uFE00",
            "caret": "\u2041",
            "caron": "\u02C7",
            "Cayleys": "\u212D",
            "ccaps": "\u2A4D",
            "Ccaron": "\u010C",
            "ccaron": "\u010D",
            "Ccedil": "\u00C7",
            "ccedil": "\u00E7",
            "Ccirc": "\u0108",
            "ccirc": "\u0109",
            "Cconint": "\u2230",
            "ccups": "\u2A4C",
            "ccupssm": "\u2A50",
            "Cdot": "\u010A",
            "cdot": "\u010B",
            "cedil": "\u00B8",
            "Cedilla": "\u00B8",
            "cemptyv": "\u29B2",
            "cent": "\u00A2",
            "centerdot": "\u00B7",
            "CenterDot": "\u00B7",
            "cfr": "\uD835\uDD20",
            "Cfr": "\u212D",
            "CHcy": "\u0427",
            "chcy": "\u0447",
            "check": "\u2713",
            "checkmark": "\u2713",
            "Chi": "\u03A7",
            "chi": "\u03C7",
            "circ": "\u02C6",
            "circeq": "\u2257",
            "circlearrowleft": "\u21BA",
            "circlearrowright": "\u21BB",
            "circledast": "\u229B",
            "circledcirc": "\u229A",
            "circleddash": "\u229D",
            "CircleDot": "\u2299",
            "circledR": "\u00AE",
            "circledS": "\u24C8",
            "CircleMinus": "\u2296",
            "CirclePlus": "\u2295",
            "CircleTimes": "\u2297",
            "cir": "\u25CB",
            "cirE": "\u29C3",
            "cire": "\u2257",
            "cirfnint": "\u2A10",
            "cirmid": "\u2AEF",
            "cirscir": "\u29C2",
            "ClockwiseContourIntegral": "\u2232",
            "CloseCurlyDoubleQuote": "\u201D",
            "CloseCurlyQuote": "\u2019",
            "clubs": "\u2663",
            "clubsuit": "\u2663",
            "colon": ":",
            "Colon": "\u2237",
            "Colone": "\u2A74",
            "colone": "\u2254",
            "coloneq": "\u2254",
            "comma": ",",
            "commat": "@",
            "comp": "\u2201",
            "compfn": "\u2218",
            "complement": "\u2201",
            "complexes": "\u2102",
            "cong": "\u2245",
            "congdot": "\u2A6D",
            "Congruent": "\u2261",
            "conint": "\u222E",
            "Conint": "\u222F",
            "ContourIntegral": "\u222E",
            "copf": "\uD835\uDD54",
            "Copf": "\u2102",
            "coprod": "\u2210",
            "Coproduct": "\u2210",
            "copy": "\u00A9",
            "COPY": "\u00A9",
            "copysr": "\u2117",
            "CounterClockwiseContourIntegral": "\u2233",
            "crarr": "\u21B5",
            "cross": "\u2717",
            "Cross": "\u2A2F",
            "Cscr": "\uD835\uDC9E",
            "cscr": "\uD835\uDCB8",
            "csub": "\u2ACF",
            "csube": "\u2AD1",
            "csup": "\u2AD0",
            "csupe": "\u2AD2",
            "ctdot": "\u22EF",
            "cudarrl": "\u2938",
            "cudarrr": "\u2935",
            "cuepr": "\u22DE",
            "cuesc": "\u22DF",
            "cularr": "\u21B6",
            "cularrp": "\u293D",
            "cupbrcap": "\u2A48",
            "cupcap": "\u2A46",
            "CupCap": "\u224D",
            "cup": "\u222A",
            "Cup": "\u22D3",
            "cupcup": "\u2A4A",
            "cupdot": "\u228D",
            "cupor": "\u2A45",
            "cups": "\u222A\uFE00",
            "curarr": "\u21B7",
            "curarrm": "\u293C",
            "curlyeqprec": "\u22DE",
            "curlyeqsucc": "\u22DF",
            "curlyvee": "\u22CE",
            "curlywedge": "\u22CF",
            "curren": "\u00A4",
            "curvearrowleft": "\u21B6",
            "curvearrowright": "\u21B7",
            "cuvee": "\u22CE",
            "cuwed": "\u22CF",
            "cwconint": "\u2232",
            "cwint": "\u2231",
            "cylcty": "\u232D",
            "dagger": "\u2020",
            "Dagger": "\u2021",
            "daleth": "\u2138",
            "darr": "\u2193",
            "Darr": "\u21A1",
            "dArr": "\u21D3",
            "dash": "\u2010",
            "Dashv": "\u2AE4",
            "dashv": "\u22A3",
            "dbkarow": "\u290F",
            "dblac": "\u02DD",
            "Dcaron": "\u010E",
            "dcaron": "\u010F",
            "Dcy": "\u0414",
            "dcy": "\u0434",
            "ddagger": "\u2021",
            "ddarr": "\u21CA",
            "DD": "\u2145",
            "dd": "\u2146",
            "DDotrahd": "\u2911",
            "ddotseq": "\u2A77",
            "deg": "\u00B0",
            "Del": "\u2207",
            "Delta": "\u0394",
            "delta": "\u03B4",
            "demptyv": "\u29B1",
            "dfisht": "\u297F",
            "Dfr": "\uD835\uDD07",
            "dfr": "\uD835\uDD21",
            "dHar": "\u2965",
            "dharl": "\u21C3",
            "dharr": "\u21C2",
            "DiacriticalAcute": "\u00B4",
            "DiacriticalDot": "\u02D9",
            "DiacriticalDoubleAcute": "\u02DD",
            "DiacriticalGrave": "`",
            "DiacriticalTilde": "\u02DC",
            "diam": "\u22C4",
            "diamond": "\u22C4",
            "Diamond": "\u22C4",
            "diamondsuit": "\u2666",
            "diams": "\u2666",
            "die": "\u00A8",
            "DifferentialD": "\u2146",
            "digamma": "\u03DD",
            "disin": "\u22F2",
            "div": "\u00F7",
            "divide": "\u00F7",
            "divideontimes": "\u22C7",
            "divonx": "\u22C7",
            "DJcy": "\u0402",
            "djcy": "\u0452",
            "dlcorn": "\u231E",
            "dlcrop": "\u230D",
            "dollar": "$",
            "Dopf": "\uD835\uDD3B",
            "dopf": "\uD835\uDD55",
            "Dot": "\u00A8",
            "dot": "\u02D9",
            "DotDot": "\u20DC",
            "doteq": "\u2250",
            "doteqdot": "\u2251",
            "DotEqual": "\u2250",
            "dotminus": "\u2238",
            "dotplus": "\u2214",
            "dotsquare": "\u22A1",
            "doublebarwedge": "\u2306",
            "DoubleContourIntegral": "\u222F",
            "DoubleDot": "\u00A8",
            "DoubleDownArrow": "\u21D3",
            "DoubleLeftArrow": "\u21D0",
            "DoubleLeftRightArrow": "\u21D4",
            "DoubleLeftTee": "\u2AE4",
            "DoubleLongLeftArrow": "\u27F8",
            "DoubleLongLeftRightArrow": "\u27FA",
            "DoubleLongRightArrow": "\u27F9",
            "DoubleRightArrow": "\u21D2",
            "DoubleRightTee": "\u22A8",
            "DoubleUpArrow": "\u21D1",
            "DoubleUpDownArrow": "\u21D5",
            "DoubleVerticalBar": "\u2225",
            "DownArrowBar": "\u2913",
            "downarrow": "\u2193",
            "DownArrow": "\u2193",
            "Downarrow": "\u21D3",
            "DownArrowUpArrow": "\u21F5",
            "DownBreve": "\u0311",
            "downdownarrows": "\u21CA",
            "downharpoonleft": "\u21C3",
            "downharpoonright": "\u21C2",
            "DownLeftRightVector": "\u2950",
            "DownLeftTeeVector": "\u295E",
            "DownLeftVectorBar": "\u2956",
            "DownLeftVector": "\u21BD",
            "DownRightTeeVector": "\u295F",
            "DownRightVectorBar": "\u2957",
            "DownRightVector": "\u21C1",
            "DownTeeArrow": "\u21A7",
            "DownTee": "\u22A4",
            "drbkarow": "\u2910",
            "drcorn": "\u231F",
            "drcrop": "\u230C",
            "Dscr": "\uD835\uDC9F",
            "dscr": "\uD835\uDCB9",
            "DScy": "\u0405",
            "dscy": "\u0455",
            "dsol": "\u29F6",
            "Dstrok": "\u0110",
            "dstrok": "\u0111",
            "dtdot": "\u22F1",
            "dtri": "\u25BF",
            "dtrif": "\u25BE",
            "duarr": "\u21F5",
            "duhar": "\u296F",
            "dwangle": "\u29A6",
            "DZcy": "\u040F",
            "dzcy": "\u045F",
            "dzigrarr": "\u27FF",
            "Eacute": "\u00C9",
            "eacute": "\u00E9",
            "easter": "\u2A6E",
            "Ecaron": "\u011A",
            "ecaron": "\u011B",
            "Ecirc": "\u00CA",
            "ecirc": "\u00EA",
            "ecir": "\u2256",
            "ecolon": "\u2255",
            "Ecy": "\u042D",
            "ecy": "\u044D",
            "eDDot": "\u2A77",
            "Edot": "\u0116",
            "edot": "\u0117",
            "eDot": "\u2251",
            "ee": "\u2147",
            "efDot": "\u2252",
            "Efr": "\uD835\uDD08",
            "efr": "\uD835\uDD22",
            "eg": "\u2A9A",
            "Egrave": "\u00C8",
            "egrave": "\u00E8",
            "egs": "\u2A96",
            "egsdot": "\u2A98",
            "el": "\u2A99",
            "Element": "\u2208",
            "elinters": "\u23E7",
            "ell": "\u2113",
            "els": "\u2A95",
            "elsdot": "\u2A97",
            "Emacr": "\u0112",
            "emacr": "\u0113",
            "empty": "\u2205",
            "emptyset": "\u2205",
            "EmptySmallSquare": "\u25FB",
            "emptyv": "\u2205",
            "EmptyVerySmallSquare": "\u25AB",
            "emsp13": "\u2004",
            "emsp14": "\u2005",
            "emsp": "\u2003",
            "ENG": "\u014A",
            "eng": "\u014B",
            "ensp": "\u2002",
            "Eogon": "\u0118",
            "eogon": "\u0119",
            "Eopf": "\uD835\uDD3C",
            "eopf": "\uD835\uDD56",
            "epar": "\u22D5",
            "eparsl": "\u29E3",
            "eplus": "\u2A71",
            "epsi": "\u03B5",
            "Epsilon": "\u0395",
            "epsilon": "\u03B5",
            "epsiv": "\u03F5",
            "eqcirc": "\u2256",
            "eqcolon": "\u2255",
            "eqsim": "\u2242",
            "eqslantgtr": "\u2A96",
            "eqslantless": "\u2A95",
            "Equal": "\u2A75",
            "equals": "=",
            "EqualTilde": "\u2242",
            "equest": "\u225F",
            "Equilibrium": "\u21CC",
            "equiv": "\u2261",
            "equivDD": "\u2A78",
            "eqvparsl": "\u29E5",
            "erarr": "\u2971",
            "erDot": "\u2253",
            "escr": "\u212F",
            "Escr": "\u2130",
            "esdot": "\u2250",
            "Esim": "\u2A73",
            "esim": "\u2242",
            "Eta": "\u0397",
            "eta": "\u03B7",
            "ETH": "\u00D0",
            "eth": "\u00F0",
            "Euml": "\u00CB",
            "euml": "\u00EB",
            "euro": "\u20AC",
            "excl": "!",
            "exist": "\u2203",
            "Exists": "\u2203",
            "expectation": "\u2130",
            "exponentiale": "\u2147",
            "ExponentialE": "\u2147",
            "fallingdotseq": "\u2252",
            "Fcy": "\u0424",
            "fcy": "\u0444",
            "female": "\u2640",
            "ffilig": "\uFB03",
            "fflig": "\uFB00",
            "ffllig": "\uFB04",
            "Ffr": "\uD835\uDD09",
            "ffr": "\uD835\uDD23",
            "filig": "\uFB01",
            "FilledSmallSquare": "\u25FC",
            "FilledVerySmallSquare": "\u25AA",
            "fjlig": "fj",
            "flat": "\u266D",
            "fllig": "\uFB02",
            "fltns": "\u25B1",
            "fnof": "\u0192",
            "Fopf": "\uD835\uDD3D",
            "fopf": "\uD835\uDD57",
            "forall": "\u2200",
            "ForAll": "\u2200",
            "fork": "\u22D4",
            "forkv": "\u2AD9",
            "Fouriertrf": "\u2131",
            "fpartint": "\u2A0D",
            "frac12": "\u00BD",
            "frac13": "\u2153",
            "frac14": "\u00BC",
            "frac15": "\u2155",
            "frac16": "\u2159",
            "frac18": "\u215B",
            "frac23": "\u2154",
            "frac25": "\u2156",
            "frac34": "\u00BE",
            "frac35": "\u2157",
            "frac38": "\u215C",
            "frac45": "\u2158",
            "frac56": "\u215A",
            "frac58": "\u215D",
            "frac78": "\u215E",
            "frasl": "\u2044",
            "frown": "\u2322",
            "fscr": "\uD835\uDCBB",
            "Fscr": "\u2131",
            "gacute": "\u01F5",
            "Gamma": "\u0393",
            "gamma": "\u03B3",
            "Gammad": "\u03DC",
            "gammad": "\u03DD",
            "gap": "\u2A86",
            "Gbreve": "\u011E",
            "gbreve": "\u011F",
            "Gcedil": "\u0122",
            "Gcirc": "\u011C",
            "gcirc": "\u011D",
            "Gcy": "\u0413",
            "gcy": "\u0433",
            "Gdot": "\u0120",
            "gdot": "\u0121",
            "ge": "\u2265",
            "gE": "\u2267",
            "gEl": "\u2A8C",
            "gel": "\u22DB",
            "geq": "\u2265",
            "geqq": "\u2267",
            "geqslant": "\u2A7E",
            "gescc": "\u2AA9",
            "ges": "\u2A7E",
            "gesdot": "\u2A80",
            "gesdoto": "\u2A82",
            "gesdotol": "\u2A84",
            "gesl": "\u22DB\uFE00",
            "gesles": "\u2A94",
            "Gfr": "\uD835\uDD0A",
            "gfr": "\uD835\uDD24",
            "gg": "\u226B",
            "Gg": "\u22D9",
            "ggg": "\u22D9",
            "gimel": "\u2137",
            "GJcy": "\u0403",
            "gjcy": "\u0453",
            "gla": "\u2AA5",
            "gl": "\u2277",
            "glE": "\u2A92",
            "glj": "\u2AA4",
            "gnap": "\u2A8A",
            "gnapprox": "\u2A8A",
            "gne": "\u2A88",
            "gnE": "\u2269",
            "gneq": "\u2A88",
            "gneqq": "\u2269",
            "gnsim": "\u22E7",
            "Gopf": "\uD835\uDD3E",
            "gopf": "\uD835\uDD58",
            "grave": "`",
            "GreaterEqual": "\u2265",
            "GreaterEqualLess": "\u22DB",
            "GreaterFullEqual": "\u2267",
            "GreaterGreater": "\u2AA2",
            "GreaterLess": "\u2277",
            "GreaterSlantEqual": "\u2A7E",
            "GreaterTilde": "\u2273",
            "Gscr": "\uD835\uDCA2",
            "gscr": "\u210A",
            "gsim": "\u2273",
            "gsime": "\u2A8E",
            "gsiml": "\u2A90",
            "gtcc": "\u2AA7",
            "gtcir": "\u2A7A",
            "gt": ">",
            "GT": ">",
            "Gt": "\u226B",
            "gtdot": "\u22D7",
            "gtlPar": "\u2995",
            "gtquest": "\u2A7C",
            "gtrapprox": "\u2A86",
            "gtrarr": "\u2978",
            "gtrdot": "\u22D7",
            "gtreqless": "\u22DB",
            "gtreqqless": "\u2A8C",
            "gtrless": "\u2277",
            "gtrsim": "\u2273",
            "gvertneqq": "\u2269\uFE00",
            "gvnE": "\u2269\uFE00",
            "Hacek": "\u02C7",
            "hairsp": "\u200A",
            "half": "\u00BD",
            "hamilt": "\u210B",
            "HARDcy": "\u042A",
            "hardcy": "\u044A",
            "harrcir": "\u2948",
            "harr": "\u2194",
            "hArr": "\u21D4",
            "harrw": "\u21AD",
            "Hat": "^",
            "hbar": "\u210F",
            "Hcirc": "\u0124",
            "hcirc": "\u0125",
            "hearts": "\u2665",
            "heartsuit": "\u2665",
            "hellip": "\u2026",
            "hercon": "\u22B9",
            "hfr": "\uD835\uDD25",
            "Hfr": "\u210C",
            "HilbertSpace": "\u210B",
            "hksearow": "\u2925",
            "hkswarow": "\u2926",
            "hoarr": "\u21FF",
            "homtht": "\u223B",
            "hookleftarrow": "\u21A9",
            "hookrightarrow": "\u21AA",
            "hopf": "\uD835\uDD59",
            "Hopf": "\u210D",
            "horbar": "\u2015",
            "HorizontalLine": "\u2500",
            "hscr": "\uD835\uDCBD",
            "Hscr": "\u210B",
            "hslash": "\u210F",
            "Hstrok": "\u0126",
            "hstrok": "\u0127",
            "HumpDownHump": "\u224E",
            "HumpEqual": "\u224F",
            "hybull": "\u2043",
            "hyphen": "\u2010",
            "Iacute": "\u00CD",
            "iacute": "\u00ED",
            "ic": "\u2063",
            "Icirc": "\u00CE",
            "icirc": "\u00EE",
            "Icy": "\u0418",
            "icy": "\u0438",
            "Idot": "\u0130",
            "IEcy": "\u0415",
            "iecy": "\u0435",
            "iexcl": "\u00A1",
            "iff": "\u21D4",
            "ifr": "\uD835\uDD26",
            "Ifr": "\u2111",
            "Igrave": "\u00CC",
            "igrave": "\u00EC",
            "ii": "\u2148",
            "iiiint": "\u2A0C",
            "iiint": "\u222D",
            "iinfin": "\u29DC",
            "iiota": "\u2129",
            "IJlig": "\u0132",
            "ijlig": "\u0133",
            "Imacr": "\u012A",
            "imacr": "\u012B",
            "image": "\u2111",
            "ImaginaryI": "\u2148",
            "imagline": "\u2110",
            "imagpart": "\u2111",
            "imath": "\u0131",
            "Im": "\u2111",
            "imof": "\u22B7",
            "imped": "\u01B5",
            "Implies": "\u21D2",
            "incare": "\u2105",
            "in": "\u2208",
            "infin": "\u221E",
            "infintie": "\u29DD",
            "inodot": "\u0131",
            "intcal": "\u22BA",
            "int": "\u222B",
            "Int": "\u222C",
            "integers": "\u2124",
            "Integral": "\u222B",
            "intercal": "\u22BA",
            "Intersection": "\u22C2",
            "intlarhk": "\u2A17",
            "intprod": "\u2A3C",
            "InvisibleComma": "\u2063",
            "InvisibleTimes": "\u2062",
            "IOcy": "\u0401",
            "iocy": "\u0451",
            "Iogon": "\u012E",
            "iogon": "\u012F",
            "Iopf": "\uD835\uDD40",
            "iopf": "\uD835\uDD5A",
            "Iota": "\u0399",
            "iota": "\u03B9",
            "iprod": "\u2A3C",
            "iquest": "\u00BF",
            "iscr": "\uD835\uDCBE",
            "Iscr": "\u2110",
            "isin": "\u2208",
            "isindot": "\u22F5",
            "isinE": "\u22F9",
            "isins": "\u22F4",
            "isinsv": "\u22F3",
            "isinv": "\u2208",
            "it": "\u2062",
            "Itilde": "\u0128",
            "itilde": "\u0129",
            "Iukcy": "\u0406",
            "iukcy": "\u0456",
            "Iuml": "\u00CF",
            "iuml": "\u00EF",
            "Jcirc": "\u0134",
            "jcirc": "\u0135",
            "Jcy": "\u0419",
            "jcy": "\u0439",
            "Jfr": "\uD835\uDD0D",
            "jfr": "\uD835\uDD27",
            "jmath": "\u0237",
            "Jopf": "\uD835\uDD41",
            "jopf": "\uD835\uDD5B",
            "Jscr": "\uD835\uDCA5",
            "jscr": "\uD835\uDCBF",
            "Jsercy": "\u0408",
            "jsercy": "\u0458",
            "Jukcy": "\u0404",
            "jukcy": "\u0454",
            "Kappa": "\u039A",
            "kappa": "\u03BA",
            "kappav": "\u03F0",
            "Kcedil": "\u0136",
            "kcedil": "\u0137",
            "Kcy": "\u041A",
            "kcy": "\u043A",
            "Kfr": "\uD835\uDD0E",
            "kfr": "\uD835\uDD28",
            "kgreen": "\u0138",
            "KHcy": "\u0425",
            "khcy": "\u0445",
            "KJcy": "\u040C",
            "kjcy": "\u045C",
            "Kopf": "\uD835\uDD42",
            "kopf": "\uD835\uDD5C",
            "Kscr": "\uD835\uDCA6",
            "kscr": "\uD835\uDCC0",
            "lAarr": "\u21DA",
            "Lacute": "\u0139",
            "lacute": "\u013A",
            "laemptyv": "\u29B4",
            "lagran": "\u2112",
            "Lambda": "\u039B",
            "lambda": "\u03BB",
            "lang": "\u27E8",
            "Lang": "\u27EA",
            "langd": "\u2991",
            "langle": "\u27E8",
            "lap": "\u2A85",
            "Laplacetrf": "\u2112",
            "laquo": "\u00AB",
            "larrb": "\u21E4",
            "larrbfs": "\u291F",
            "larr": "\u2190",
            "Larr": "\u219E",
            "lArr": "\u21D0",
            "larrfs": "\u291D",
            "larrhk": "\u21A9",
            "larrlp": "\u21AB",
            "larrpl": "\u2939",
            "larrsim": "\u2973",
            "larrtl": "\u21A2",
            "latail": "\u2919",
            "lAtail": "\u291B",
            "lat": "\u2AAB",
            "late": "\u2AAD",
            "lates": "\u2AAD\uFE00",
            "lbarr": "\u290C",
            "lBarr": "\u290E",
            "lbbrk": "\u2772",
            "lbrace": "{",
            "lbrack": "[",
            "lbrke": "\u298B",
            "lbrksld": "\u298F",
            "lbrkslu": "\u298D",
            "Lcaron": "\u013D",
            "lcaron": "\u013E",
            "Lcedil": "\u013B",
            "lcedil": "\u013C",
            "lceil": "\u2308",
            "lcub": "{",
            "Lcy": "\u041B",
            "lcy": "\u043B",
            "ldca": "\u2936",
            "ldquo": "\u201C",
            "ldquor": "\u201E",
            "ldrdhar": "\u2967",
            "ldrushar": "\u294B",
            "ldsh": "\u21B2",
            "le": "\u2264",
            "lE": "\u2266",
            "LeftAngleBracket": "\u27E8",
            "LeftArrowBar": "\u21E4",
            "leftarrow": "\u2190",
            "LeftArrow": "\u2190",
            "Leftarrow": "\u21D0",
            "LeftArrowRightArrow": "\u21C6",
            "leftarrowtail": "\u21A2",
            "LeftCeiling": "\u2308",
            "LeftDoubleBracket": "\u27E6",
            "LeftDownTeeVector": "\u2961",
            "LeftDownVectorBar": "\u2959",
            "LeftDownVector": "\u21C3",
            "LeftFloor": "\u230A",
            "leftharpoondown": "\u21BD",
            "leftharpoonup": "\u21BC",
            "leftleftarrows": "\u21C7",
            "leftrightarrow": "\u2194",
            "LeftRightArrow": "\u2194",
            "Leftrightarrow": "\u21D4",
            "leftrightarrows": "\u21C6",
            "leftrightharpoons": "\u21CB",
            "leftrightsquigarrow": "\u21AD",
            "LeftRightVector": "\u294E",
            "LeftTeeArrow": "\u21A4",
            "LeftTee": "\u22A3",
            "LeftTeeVector": "\u295A",
            "leftthreetimes": "\u22CB",
            "LeftTriangleBar": "\u29CF",
            "LeftTriangle": "\u22B2",
            "LeftTriangleEqual": "\u22B4",
            "LeftUpDownVector": "\u2951",
            "LeftUpTeeVector": "\u2960",
            "LeftUpVectorBar": "\u2958",
            "LeftUpVector": "\u21BF",
            "LeftVectorBar": "\u2952",
            "LeftVector": "\u21BC",
            "lEg": "\u2A8B",
            "leg": "\u22DA",
            "leq": "\u2264",
            "leqq": "\u2266",
            "leqslant": "\u2A7D",
            "lescc": "\u2AA8",
            "les": "\u2A7D",
            "lesdot": "\u2A7F",
            "lesdoto": "\u2A81",
            "lesdotor": "\u2A83",
            "lesg": "\u22DA\uFE00",
            "lesges": "\u2A93",
            "lessapprox": "\u2A85",
            "lessdot": "\u22D6",
            "lesseqgtr": "\u22DA",
            "lesseqqgtr": "\u2A8B",
            "LessEqualGreater": "\u22DA",
            "LessFullEqual": "\u2266",
            "LessGreater": "\u2276",
            "lessgtr": "\u2276",
            "LessLess": "\u2AA1",
            "lesssim": "\u2272",
            "LessSlantEqual": "\u2A7D",
            "LessTilde": "\u2272",
            "lfisht": "\u297C",
            "lfloor": "\u230A",
            "Lfr": "\uD835\uDD0F",
            "lfr": "\uD835\uDD29",
            "lg": "\u2276",
            "lgE": "\u2A91",
            "lHar": "\u2962",
            "lhard": "\u21BD",
            "lharu": "\u21BC",
            "lharul": "\u296A",
            "lhblk": "\u2584",
            "LJcy": "\u0409",
            "ljcy": "\u0459",
            "llarr": "\u21C7",
            "ll": "\u226A",
            "Ll": "\u22D8",
            "llcorner": "\u231E",
            "Lleftarrow": "\u21DA",
            "llhard": "\u296B",
            "lltri": "\u25FA",
            "Lmidot": "\u013F",
            "lmidot": "\u0140",
            "lmoustache": "\u23B0",
            "lmoust": "\u23B0",
            "lnap": "\u2A89",
            "lnapprox": "\u2A89",
            "lne": "\u2A87",
            "lnE": "\u2268",
            "lneq": "\u2A87",
            "lneqq": "\u2268",
            "lnsim": "\u22E6",
            "loang": "\u27EC",
            "loarr": "\u21FD",
            "lobrk": "\u27E6",
            "longleftarrow": "\u27F5",
            "LongLeftArrow": "\u27F5",
            "Longleftarrow": "\u27F8",
            "longleftrightarrow": "\u27F7",
            "LongLeftRightArrow": "\u27F7",
            "Longleftrightarrow": "\u27FA",
            "longmapsto": "\u27FC",
            "longrightarrow": "\u27F6",
            "LongRightArrow": "\u27F6",
            "Longrightarrow": "\u27F9",
            "looparrowleft": "\u21AB",
            "looparrowright": "\u21AC",
            "lopar": "\u2985",
            "Lopf": "\uD835\uDD43",
            "lopf": "\uD835\uDD5D",
            "loplus": "\u2A2D",
            "lotimes": "\u2A34",
            "lowast": "\u2217",
            "lowbar": "_",
            "LowerLeftArrow": "\u2199",
            "LowerRightArrow": "\u2198",
            "loz": "\u25CA",
            "lozenge": "\u25CA",
            "lozf": "\u29EB",
            "lpar": "(",
            "lparlt": "\u2993",
            "lrarr": "\u21C6",
            "lrcorner": "\u231F",
            "lrhar": "\u21CB",
            "lrhard": "\u296D",
            "lrm": "\u200E",
            "lrtri": "\u22BF",
            "lsaquo": "\u2039",
            "lscr": "\uD835\uDCC1",
            "Lscr": "\u2112",
            "lsh": "\u21B0",
            "Lsh": "\u21B0",
            "lsim": "\u2272",
            "lsime": "\u2A8D",
            "lsimg": "\u2A8F",
            "lsqb": "[",
            "lsquo": "\u2018",
            "lsquor": "\u201A",
            "Lstrok": "\u0141",
            "lstrok": "\u0142",
            "ltcc": "\u2AA6",
            "ltcir": "\u2A79",
            "lt": "<",
            "LT": "<",
            "Lt": "\u226A",
            "ltdot": "\u22D6",
            "lthree": "\u22CB",
            "ltimes": "\u22C9",
            "ltlarr": "\u2976",
            "ltquest": "\u2A7B",
            "ltri": "\u25C3",
            "ltrie": "\u22B4",
            "ltrif": "\u25C2",
            "ltrPar": "\u2996",
            "lurdshar": "\u294A",
            "luruhar": "\u2966",
            "lvertneqq": "\u2268\uFE00",
            "lvnE": "\u2268\uFE00",
            "macr": "\u00AF",
            "male": "\u2642",
            "malt": "\u2720",
            "maltese": "\u2720",
            "Map": "\u2905",
            "map": "\u21A6",
            "mapsto": "\u21A6",
            "mapstodown": "\u21A7",
            "mapstoleft": "\u21A4",
            "mapstoup": "\u21A5",
            "marker": "\u25AE",
            "mcomma": "\u2A29",
            "Mcy": "\u041C",
            "mcy": "\u043C",
            "mdash": "\u2014",
            "mDDot": "\u223A",
            "measuredangle": "\u2221",
            "MediumSpace": "\u205F",
            "Mellintrf": "\u2133",
            "Mfr": "\uD835\uDD10",
            "mfr": "\uD835\uDD2A",
            "mho": "\u2127",
            "micro": "\u00B5",
            "midast": "*",
            "midcir": "\u2AF0",
            "mid": "\u2223",
            "middot": "\u00B7",
            "minusb": "\u229F",
            "minus": "\u2212",
            "minusd": "\u2238",
            "minusdu": "\u2A2A",
            "MinusPlus": "\u2213",
            "mlcp": "\u2ADB",
            "mldr": "\u2026",
            "mnplus": "\u2213",
            "models": "\u22A7",
            "Mopf": "\uD835\uDD44",
            "mopf": "\uD835\uDD5E",
            "mp": "\u2213",
            "mscr": "\uD835\uDCC2",
            "Mscr": "\u2133",
            "mstpos": "\u223E",
            "Mu": "\u039C",
            "mu": "\u03BC",
            "multimap": "\u22B8",
            "mumap": "\u22B8",
            "nabla": "\u2207",
            "Nacute": "\u0143",
            "nacute": "\u0144",
            "nang": "\u2220\u20D2",
            "nap": "\u2249",
            "napE": "\u2A70\u0338",
            "napid": "\u224B\u0338",
            "napos": "\u0149",
            "napprox": "\u2249",
            "natural": "\u266E",
            "naturals": "\u2115",
            "natur": "\u266E",
            "nbsp": "\u00A0",
            "nbump": "\u224E\u0338",
            "nbumpe": "\u224F\u0338",
            "ncap": "\u2A43",
            "Ncaron": "\u0147",
            "ncaron": "\u0148",
            "Ncedil": "\u0145",
            "ncedil": "\u0146",
            "ncong": "\u2247",
            "ncongdot": "\u2A6D\u0338",
            "ncup": "\u2A42",
            "Ncy": "\u041D",
            "ncy": "\u043D",
            "ndash": "\u2013",
            "nearhk": "\u2924",
            "nearr": "\u2197",
            "neArr": "\u21D7",
            "nearrow": "\u2197",
            "ne": "\u2260",
            "nedot": "\u2250\u0338",
            "NegativeMediumSpace": "\u200B",
            "NegativeThickSpace": "\u200B",
            "NegativeThinSpace": "\u200B",
            "NegativeVeryThinSpace": "\u200B",
            "nequiv": "\u2262",
            "nesear": "\u2928",
            "nesim": "\u2242\u0338",
            "NestedGreaterGreater": "\u226B",
            "NestedLessLess": "\u226A",
            "NewLine": "\n",
            "nexist": "\u2204",
            "nexists": "\u2204",
            "Nfr": "\uD835\uDD11",
            "nfr": "\uD835\uDD2B",
            "ngE": "\u2267\u0338",
            "nge": "\u2271",
            "ngeq": "\u2271",
            "ngeqq": "\u2267\u0338",
            "ngeqslant": "\u2A7E\u0338",
            "nges": "\u2A7E\u0338",
            "nGg": "\u22D9\u0338",
            "ngsim": "\u2275",
            "nGt": "\u226B\u20D2",
            "ngt": "\u226F",
            "ngtr": "\u226F",
            "nGtv": "\u226B\u0338",
            "nharr": "\u21AE",
            "nhArr": "\u21CE",
            "nhpar": "\u2AF2",
            "ni": "\u220B",
            "nis": "\u22FC",
            "nisd": "\u22FA",
            "niv": "\u220B",
            "NJcy": "\u040A",
            "njcy": "\u045A",
            "nlarr": "\u219A",
            "nlArr": "\u21CD",
            "nldr": "\u2025",
            "nlE": "\u2266\u0338",
            "nle": "\u2270",
            "nleftarrow": "\u219A",
            "nLeftarrow": "\u21CD",
            "nleftrightarrow": "\u21AE",
            "nLeftrightarrow": "\u21CE",
            "nleq": "\u2270",
            "nleqq": "\u2266\u0338",
            "nleqslant": "\u2A7D\u0338",
            "nles": "\u2A7D\u0338",
            "nless": "\u226E",
            "nLl": "\u22D8\u0338",
            "nlsim": "\u2274",
            "nLt": "\u226A\u20D2",
            "nlt": "\u226E",
            "nltri": "\u22EA",
            "nltrie": "\u22EC",
            "nLtv": "\u226A\u0338",
            "nmid": "\u2224",
            "NoBreak": "\u2060",
            "NonBreakingSpace": "\u00A0",
            "nopf": "\uD835\uDD5F",
            "Nopf": "\u2115",
            "Not": "\u2AEC",
            "not": "\u00AC",
            "NotCongruent": "\u2262",
            "NotCupCap": "\u226D",
            "NotDoubleVerticalBar": "\u2226",
            "NotElement": "\u2209",
            "NotEqual": "\u2260",
            "NotEqualTilde": "\u2242\u0338",
            "NotExists": "\u2204",
            "NotGreater": "\u226F",
            "NotGreaterEqual": "\u2271",
            "NotGreaterFullEqual": "\u2267\u0338",
            "NotGreaterGreater": "\u226B\u0338",
            "NotGreaterLess": "\u2279",
            "NotGreaterSlantEqual": "\u2A7E\u0338",
            "NotGreaterTilde": "\u2275",
            "NotHumpDownHump": "\u224E\u0338",
            "NotHumpEqual": "\u224F\u0338",
            "notin": "\u2209",
            "notindot": "\u22F5\u0338",
            "notinE": "\u22F9\u0338",
            "notinva": "\u2209",
            "notinvb": "\u22F7",
            "notinvc": "\u22F6",
            "NotLeftTriangleBar": "\u29CF\u0338",
            "NotLeftTriangle": "\u22EA",
            "NotLeftTriangleEqual": "\u22EC",
            "NotLess": "\u226E",
            "NotLessEqual": "\u2270",
            "NotLessGreater": "\u2278",
            "NotLessLess": "\u226A\u0338",
            "NotLessSlantEqual": "\u2A7D\u0338",
            "NotLessTilde": "\u2274",
            "NotNestedGreaterGreater": "\u2AA2\u0338",
            "NotNestedLessLess": "\u2AA1\u0338",
            "notni": "\u220C",
            "notniva": "\u220C",
            "notnivb": "\u22FE",
            "notnivc": "\u22FD",
            "NotPrecedes": "\u2280",
            "NotPrecedesEqual": "\u2AAF\u0338",
            "NotPrecedesSlantEqual": "\u22E0",
            "NotReverseElement": "\u220C",
            "NotRightTriangleBar": "\u29D0\u0338",
            "NotRightTriangle": "\u22EB",
            "NotRightTriangleEqual": "\u22ED",
            "NotSquareSubset": "\u228F\u0338",
            "NotSquareSubsetEqual": "\u22E2",
            "NotSquareSuperset": "\u2290\u0338",
            "NotSquareSupersetEqual": "\u22E3",
            "NotSubset": "\u2282\u20D2",
            "NotSubsetEqual": "\u2288",
            "NotSucceeds": "\u2281",
            "NotSucceedsEqual": "\u2AB0\u0338",
            "NotSucceedsSlantEqual": "\u22E1",
            "NotSucceedsTilde": "\u227F\u0338",
            "NotSuperset": "\u2283\u20D2",
            "NotSupersetEqual": "\u2289",
            "NotTilde": "\u2241",
            "NotTildeEqual": "\u2244",
            "NotTildeFullEqual": "\u2247",
            "NotTildeTilde": "\u2249",
            "NotVerticalBar": "\u2224",
            "nparallel": "\u2226",
            "npar": "\u2226",
            "nparsl": "\u2AFD\u20E5",
            "npart": "\u2202\u0338",
            "npolint": "\u2A14",
            "npr": "\u2280",
            "nprcue": "\u22E0",
            "nprec": "\u2280",
            "npreceq": "\u2AAF\u0338",
            "npre": "\u2AAF\u0338",
            "nrarrc": "\u2933\u0338",
            "nrarr": "\u219B",
            "nrArr": "\u21CF",
            "nrarrw": "\u219D\u0338",
            "nrightarrow": "\u219B",
            "nRightarrow": "\u21CF",
            "nrtri": "\u22EB",
            "nrtrie": "\u22ED",
            "nsc": "\u2281",
            "nsccue": "\u22E1",
            "nsce": "\u2AB0\u0338",
            "Nscr": "\uD835\uDCA9",
            "nscr": "\uD835\uDCC3",
            "nshortmid": "\u2224",
            "nshortparallel": "\u2226",
            "nsim": "\u2241",
            "nsime": "\u2244",
            "nsimeq": "\u2244",
            "nsmid": "\u2224",
            "nspar": "\u2226",
            "nsqsube": "\u22E2",
            "nsqsupe": "\u22E3",
            "nsub": "\u2284",
            "nsubE": "\u2AC5\u0338",
            "nsube": "\u2288",
            "nsubset": "\u2282\u20D2",
            "nsubseteq": "\u2288",
            "nsubseteqq": "\u2AC5\u0338",
            "nsucc": "\u2281",
            "nsucceq": "\u2AB0\u0338",
            "nsup": "\u2285",
            "nsupE": "\u2AC6\u0338",
            "nsupe": "\u2289",
            "nsupset": "\u2283\u20D2",
            "nsupseteq": "\u2289",
            "nsupseteqq": "\u2AC6\u0338",
            "ntgl": "\u2279",
            "Ntilde": "\u00D1",
            "ntilde": "\u00F1",
            "ntlg": "\u2278",
            "ntriangleleft": "\u22EA",
            "ntrianglelefteq": "\u22EC",
            "ntriangleright": "\u22EB",
            "ntrianglerighteq": "\u22ED",
            "Nu": "\u039D",
            "nu": "\u03BD",
            "num": "#",
            "numero": "\u2116",
            "numsp": "\u2007",
            "nvap": "\u224D\u20D2",
            "nvdash": "\u22AC",
            "nvDash": "\u22AD",
            "nVdash": "\u22AE",
            "nVDash": "\u22AF",
            "nvge": "\u2265\u20D2",
            "nvgt": ">\u20D2",
            "nvHarr": "\u2904",
            "nvinfin": "\u29DE",
            "nvlArr": "\u2902",
            "nvle": "\u2264\u20D2",
            "nvlt": "<\u20D2",
            "nvltrie": "\u22B4\u20D2",
            "nvrArr": "\u2903",
            "nvrtrie": "\u22B5\u20D2",
            "nvsim": "\u223C\u20D2",
            "nwarhk": "\u2923",
            "nwarr": "\u2196",
            "nwArr": "\u21D6",
            "nwarrow": "\u2196",
            "nwnear": "\u2927",
            "Oacute": "\u00D3",
            "oacute": "\u00F3",
            "oast": "\u229B",
            "Ocirc": "\u00D4",
            "ocirc": "\u00F4",
            "ocir": "\u229A",
            "Ocy": "\u041E",
            "ocy": "\u043E",
            "odash": "\u229D",
            "Odblac": "\u0150",
            "odblac": "\u0151",
            "odiv": "\u2A38",
            "odot": "\u2299",
            "odsold": "\u29BC",
            "OElig": "\u0152",
            "oelig": "\u0153",
            "ofcir": "\u29BF",
            "Ofr": "\uD835\uDD12",
            "ofr": "\uD835\uDD2C",
            "ogon": "\u02DB",
            "Ograve": "\u00D2",
            "ograve": "\u00F2",
            "ogt": "\u29C1",
            "ohbar": "\u29B5",
            "ohm": "\u03A9",
            "oint": "\u222E",
            "olarr": "\u21BA",
            "olcir": "\u29BE",
            "olcross": "\u29BB",
            "oline": "\u203E",
            "olt": "\u29C0",
            "Omacr": "\u014C",
            "omacr": "\u014D",
            "Omega": "\u03A9",
            "omega": "\u03C9",
            "Omicron": "\u039F",
            "omicron": "\u03BF",
            "omid": "\u29B6",
            "ominus": "\u2296",
            "Oopf": "\uD835\uDD46",
            "oopf": "\uD835\uDD60",
            "opar": "\u29B7",
            "OpenCurlyDoubleQuote": "\u201C",
            "OpenCurlyQuote": "\u2018",
            "operp": "\u29B9",
            "oplus": "\u2295",
            "orarr": "\u21BB",
            "Or": "\u2A54",
            "or": "\u2228",
            "ord": "\u2A5D",
            "order": "\u2134",
            "orderof": "\u2134",
            "ordf": "\u00AA",
            "ordm": "\u00BA",
            "origof": "\u22B6",
            "oror": "\u2A56",
            "orslope": "\u2A57",
            "orv": "\u2A5B",
            "oS": "\u24C8",
            "Oscr": "\uD835\uDCAA",
            "oscr": "\u2134",
            "Oslash": "\u00D8",
            "oslash": "\u00F8",
            "osol": "\u2298",
            "Otilde": "\u00D5",
            "otilde": "\u00F5",
            "otimesas": "\u2A36",
            "Otimes": "\u2A37",
            "otimes": "\u2297",
            "Ouml": "\u00D6",
            "ouml": "\u00F6",
            "ovbar": "\u233D",
            "OverBar": "\u203E",
            "OverBrace": "\u23DE",
            "OverBracket": "\u23B4",
            "OverParenthesis": "\u23DC",
            "para": "\u00B6",
            "parallel": "\u2225",
            "par": "\u2225",
            "parsim": "\u2AF3",
            "parsl": "\u2AFD",
            "part": "\u2202",
            "PartialD": "\u2202",
            "Pcy": "\u041F",
            "pcy": "\u043F",
            "percnt": "%",
            "period": ".",
            "permil": "\u2030",
            "perp": "\u22A5",
            "pertenk": "\u2031",
            "Pfr": "\uD835\uDD13",
            "pfr": "\uD835\uDD2D",
            "Phi": "\u03A6",
            "phi": "\u03C6",
            "phiv": "\u03D5",
            "phmmat": "\u2133",
            "phone": "\u260E",
            "Pi": "\u03A0",
            "pi": "\u03C0",
            "pitchfork": "\u22D4",
            "piv": "\u03D6",
            "planck": "\u210F",
            "planckh": "\u210E",
            "plankv": "\u210F",
            "plusacir": "\u2A23",
            "plusb": "\u229E",
            "pluscir": "\u2A22",
            "plus": "+",
            "plusdo": "\u2214",
            "plusdu": "\u2A25",
            "pluse": "\u2A72",
            "PlusMinus": "\u00B1",
            "plusmn": "\u00B1",
            "plussim": "\u2A26",
            "plustwo": "\u2A27",
            "pm": "\u00B1",
            "Poincareplane": "\u210C",
            "pointint": "\u2A15",
            "popf": "\uD835\uDD61",
            "Popf": "\u2119",
            "pound": "\u00A3",
            "prap": "\u2AB7",
            "Pr": "\u2ABB",
            "pr": "\u227A",
            "prcue": "\u227C",
            "precapprox": "\u2AB7",
            "prec": "\u227A",
            "preccurlyeq": "\u227C",
            "Precedes": "\u227A",
            "PrecedesEqual": "\u2AAF",
            "PrecedesSlantEqual": "\u227C",
            "PrecedesTilde": "\u227E",
            "preceq": "\u2AAF",
            "precnapprox": "\u2AB9",
            "precneqq": "\u2AB5",
            "precnsim": "\u22E8",
            "pre": "\u2AAF",
            "prE": "\u2AB3",
            "precsim": "\u227E",
            "prime": "\u2032",
            "Prime": "\u2033",
            "primes": "\u2119",
            "prnap": "\u2AB9",
            "prnE": "\u2AB5",
            "prnsim": "\u22E8",
            "prod": "\u220F",
            "Product": "\u220F",
            "profalar": "\u232E",
            "profline": "\u2312",
            "profsurf": "\u2313",
            "prop": "\u221D",
            "Proportional": "\u221D",
            "Proportion": "\u2237",
            "propto": "\u221D",
            "prsim": "\u227E",
            "prurel": "\u22B0",
            "Pscr": "\uD835\uDCAB",
            "pscr": "\uD835\uDCC5",
            "Psi": "\u03A8",
            "psi": "\u03C8",
            "puncsp": "\u2008",
            "Qfr": "\uD835\uDD14",
            "qfr": "\uD835\uDD2E",
            "qint": "\u2A0C",
            "qopf": "\uD835\uDD62",
            "Qopf": "\u211A",
            "qprime": "\u2057",
            "Qscr": "\uD835\uDCAC",
            "qscr": "\uD835\uDCC6",
            "quaternions": "\u210D",
            "quatint": "\u2A16",
            "quest": "?",
            "questeq": "\u225F",
            "quot": "\"",
            "QUOT": "\"",
            "rAarr": "\u21DB",
            "race": "\u223D\u0331",
            "Racute": "\u0154",
            "racute": "\u0155",
            "radic": "\u221A",
            "raemptyv": "\u29B3",
            "rang": "\u27E9",
            "Rang": "\u27EB",
            "rangd": "\u2992",
            "range": "\u29A5",
            "rangle": "\u27E9",
            "raquo": "\u00BB",
            "rarrap": "\u2975",
            "rarrb": "\u21E5",
            "rarrbfs": "\u2920",
            "rarrc": "\u2933",
            "rarr": "\u2192",
            "Rarr": "\u21A0",
            "rArr": "\u21D2",
            "rarrfs": "\u291E",
            "rarrhk": "\u21AA",
            "rarrlp": "\u21AC",
            "rarrpl": "\u2945",
            "rarrsim": "\u2974",
            "Rarrtl": "\u2916",
            "rarrtl": "\u21A3",
            "rarrw": "\u219D",
            "ratail": "\u291A",
            "rAtail": "\u291C",
            "ratio": "\u2236",
            "rationals": "\u211A",
            "rbarr": "\u290D",
            "rBarr": "\u290F",
            "RBarr": "\u2910",
            "rbbrk": "\u2773",
            "rbrace": "}",
            "rbrack": "]",
            "rbrke": "\u298C",
            "rbrksld": "\u298E",
            "rbrkslu": "\u2990",
            "Rcaron": "\u0158",
            "rcaron": "\u0159",
            "Rcedil": "\u0156",
            "rcedil": "\u0157",
            "rceil": "\u2309",
            "rcub": "}",
            "Rcy": "\u0420",
            "rcy": "\u0440",
            "rdca": "\u2937",
            "rdldhar": "\u2969",
            "rdquo": "\u201D",
            "rdquor": "\u201D",
            "rdsh": "\u21B3",
            "real": "\u211C",
            "realine": "\u211B",
            "realpart": "\u211C",
            "reals": "\u211D",
            "Re": "\u211C",
            "rect": "\u25AD",
            "reg": "\u00AE",
            "REG": "\u00AE",
            "ReverseElement": "\u220B",
            "ReverseEquilibrium": "\u21CB",
            "ReverseUpEquilibrium": "\u296F",
            "rfisht": "\u297D",
            "rfloor": "\u230B",
            "rfr": "\uD835\uDD2F",
            "Rfr": "\u211C",
            "rHar": "\u2964",
            "rhard": "\u21C1",
            "rharu": "\u21C0",
            "rharul": "\u296C",
            "Rho": "\u03A1",
            "rho": "\u03C1",
            "rhov": "\u03F1",
            "RightAngleBracket": "\u27E9",
            "RightArrowBar": "\u21E5",
            "rightarrow": "\u2192",
            "RightArrow": "\u2192",
            "Rightarrow": "\u21D2",
            "RightArrowLeftArrow": "\u21C4",
            "rightarrowtail": "\u21A3",
            "RightCeiling": "\u2309",
            "RightDoubleBracket": "\u27E7",
            "RightDownTeeVector": "\u295D",
            "RightDownVectorBar": "\u2955",
            "RightDownVector": "\u21C2",
            "RightFloor": "\u230B",
            "rightharpoondown": "\u21C1",
            "rightharpoonup": "\u21C0",
            "rightleftarrows": "\u21C4",
            "rightleftharpoons": "\u21CC",
            "rightrightarrows": "\u21C9",
            "rightsquigarrow": "\u219D",
            "RightTeeArrow": "\u21A6",
            "RightTee": "\u22A2",
            "RightTeeVector": "\u295B",
            "rightthreetimes": "\u22CC",
            "RightTriangleBar": "\u29D0",
            "RightTriangle": "\u22B3",
            "RightTriangleEqual": "\u22B5",
            "RightUpDownVector": "\u294F",
            "RightUpTeeVector": "\u295C",
            "RightUpVectorBar": "\u2954",
            "RightUpVector": "\u21BE",
            "RightVectorBar": "\u2953",
            "RightVector": "\u21C0",
            "ring": "\u02DA",
            "risingdotseq": "\u2253",
            "rlarr": "\u21C4",
            "rlhar": "\u21CC",
            "rlm": "\u200F",
            "rmoustache": "\u23B1",
            "rmoust": "\u23B1",
            "rnmid": "\u2AEE",
            "roang": "\u27ED",
            "roarr": "\u21FE",
            "robrk": "\u27E7",
            "ropar": "\u2986",
            "ropf": "\uD835\uDD63",
            "Ropf": "\u211D",
            "roplus": "\u2A2E",
            "rotimes": "\u2A35",
            "RoundImplies": "\u2970",
            "rpar": ")",
            "rpargt": "\u2994",
            "rppolint": "\u2A12",
            "rrarr": "\u21C9",
            "Rrightarrow": "\u21DB",
            "rsaquo": "\u203A",
            "rscr": "\uD835\uDCC7",
            "Rscr": "\u211B",
            "rsh": "\u21B1",
            "Rsh": "\u21B1",
            "rsqb": "]",
            "rsquo": "\u2019",
            "rsquor": "\u2019",
            "rthree": "\u22CC",
            "rtimes": "\u22CA",
            "rtri": "\u25B9",
            "rtrie": "\u22B5",
            "rtrif": "\u25B8",
            "rtriltri": "\u29CE",
            "RuleDelayed": "\u29F4",
            "ruluhar": "\u2968",
            "rx": "\u211E",
            "Sacute": "\u015A",
            "sacute": "\u015B",
            "sbquo": "\u201A",
            "scap": "\u2AB8",
            "Scaron": "\u0160",
            "scaron": "\u0161",
            "Sc": "\u2ABC",
            "sc": "\u227B",
            "sccue": "\u227D",
            "sce": "\u2AB0",
            "scE": "\u2AB4",
            "Scedil": "\u015E",
            "scedil": "\u015F",
            "Scirc": "\u015C",
            "scirc": "\u015D",
            "scnap": "\u2ABA",
            "scnE": "\u2AB6",
            "scnsim": "\u22E9",
            "scpolint": "\u2A13",
            "scsim": "\u227F",
            "Scy": "\u0421",
            "scy": "\u0441",
            "sdotb": "\u22A1",
            "sdot": "\u22C5",
            "sdote": "\u2A66",
            "searhk": "\u2925",
            "searr": "\u2198",
            "seArr": "\u21D8",
            "searrow": "\u2198",
            "sect": "\u00A7",
            "semi": ";",
            "seswar": "\u2929",
            "setminus": "\u2216",
            "setmn": "\u2216",
            "sext": "\u2736",
            "Sfr": "\uD835\uDD16",
            "sfr": "\uD835\uDD30",
            "sfrown": "\u2322",
            "sharp": "\u266F",
            "SHCHcy": "\u0429",
            "shchcy": "\u0449",
            "SHcy": "\u0428",
            "shcy": "\u0448",
            "ShortDownArrow": "\u2193",
            "ShortLeftArrow": "\u2190",
            "shortmid": "\u2223",
            "shortparallel": "\u2225",
            "ShortRightArrow": "\u2192",
            "ShortUpArrow": "\u2191",
            "shy": "\u00AD",
            "Sigma": "\u03A3",
            "sigma": "\u03C3",
            "sigmaf": "\u03C2",
            "sigmav": "\u03C2",
            "sim": "\u223C",
            "simdot": "\u2A6A",
            "sime": "\u2243",
            "simeq": "\u2243",
            "simg": "\u2A9E",
            "simgE": "\u2AA0",
            "siml": "\u2A9D",
            "simlE": "\u2A9F",
            "simne": "\u2246",
            "simplus": "\u2A24",
            "simrarr": "\u2972",
            "slarr": "\u2190",
            "SmallCircle": "\u2218",
            "smallsetminus": "\u2216",
            "smashp": "\u2A33",
            "smeparsl": "\u29E4",
            "smid": "\u2223",
            "smile": "\u2323",
            "smt": "\u2AAA",
            "smte": "\u2AAC",
            "smtes": "\u2AAC\uFE00",
            "SOFTcy": "\u042C",
            "softcy": "\u044C",
            "solbar": "\u233F",
            "solb": "\u29C4",
            "sol": "/",
            "Sopf": "\uD835\uDD4A",
            "sopf": "\uD835\uDD64",
            "spades": "\u2660",
            "spadesuit": "\u2660",
            "spar": "\u2225",
            "sqcap": "\u2293",
            "sqcaps": "\u2293\uFE00",
            "sqcup": "\u2294",
            "sqcups": "\u2294\uFE00",
            "Sqrt": "\u221A",
            "sqsub": "\u228F",
            "sqsube": "\u2291",
            "sqsubset": "\u228F",
            "sqsubseteq": "\u2291",
            "sqsup": "\u2290",
            "sqsupe": "\u2292",
            "sqsupset": "\u2290",
            "sqsupseteq": "\u2292",
            "square": "\u25A1",
            "Square": "\u25A1",
            "SquareIntersection": "\u2293",
            "SquareSubset": "\u228F",
            "SquareSubsetEqual": "\u2291",
            "SquareSuperset": "\u2290",
            "SquareSupersetEqual": "\u2292",
            "SquareUnion": "\u2294",
            "squarf": "\u25AA",
            "squ": "\u25A1",
            "squf": "\u25AA",
            "srarr": "\u2192",
            "Sscr": "\uD835\uDCAE",
            "sscr": "\uD835\uDCC8",
            "ssetmn": "\u2216",
            "ssmile": "\u2323",
            "sstarf": "\u22C6",
            "Star": "\u22C6",
            "star": "\u2606",
            "starf": "\u2605",
            "straightepsilon": "\u03F5",
            "straightphi": "\u03D5",
            "strns": "\u00AF",
            "sub": "\u2282",
            "Sub": "\u22D0",
            "subdot": "\u2ABD",
            "subE": "\u2AC5",
            "sube": "\u2286",
            "subedot": "\u2AC3",
            "submult": "\u2AC1",
            "subnE": "\u2ACB",
            "subne": "\u228A",
            "subplus": "\u2ABF",
            "subrarr": "\u2979",
            "subset": "\u2282",
            "Subset": "\u22D0",
            "subseteq": "\u2286",
            "subseteqq": "\u2AC5",
            "SubsetEqual": "\u2286",
            "subsetneq": "\u228A",
            "subsetneqq": "\u2ACB",
            "subsim": "\u2AC7",
            "subsub": "\u2AD5",
            "subsup": "\u2AD3",
            "succapprox": "\u2AB8",
            "succ": "\u227B",
            "succcurlyeq": "\u227D",
            "Succeeds": "\u227B",
            "SucceedsEqual": "\u2AB0",
            "SucceedsSlantEqual": "\u227D",
            "SucceedsTilde": "\u227F",
            "succeq": "\u2AB0",
            "succnapprox": "\u2ABA",
            "succneqq": "\u2AB6",
            "succnsim": "\u22E9",
            "succsim": "\u227F",
            "SuchThat": "\u220B",
            "sum": "\u2211",
            "Sum": "\u2211",
            "sung": "\u266A",
            "sup1": "\u00B9",
            "sup2": "\u00B2",
            "sup3": "\u00B3",
            "sup": "\u2283",
            "Sup": "\u22D1",
            "supdot": "\u2ABE",
            "supdsub": "\u2AD8",
            "supE": "\u2AC6",
            "supe": "\u2287",
            "supedot": "\u2AC4",
            "Superset": "\u2283",
            "SupersetEqual": "\u2287",
            "suphsol": "\u27C9",
            "suphsub": "\u2AD7",
            "suplarr": "\u297B",
            "supmult": "\u2AC2",
            "supnE": "\u2ACC",
            "supne": "\u228B",
            "supplus": "\u2AC0",
            "supset": "\u2283",
            "Supset": "\u22D1",
            "supseteq": "\u2287",
            "supseteqq": "\u2AC6",
            "supsetneq": "\u228B",
            "supsetneqq": "\u2ACC",
            "supsim": "\u2AC8",
            "supsub": "\u2AD4",
            "supsup": "\u2AD6",
            "swarhk": "\u2926",
            "swarr": "\u2199",
            "swArr": "\u21D9",
            "swarrow": "\u2199",
            "swnwar": "\u292A",
            "szlig": "\u00DF",
            "Tab": "\t",
            "target": "\u2316",
            "Tau": "\u03A4",
            "tau": "\u03C4",
            "tbrk": "\u23B4",
            "Tcaron": "\u0164",
            "tcaron": "\u0165",
            "Tcedil": "\u0162",
            "tcedil": "\u0163",
            "Tcy": "\u0422",
            "tcy": "\u0442",
            "tdot": "\u20DB",
            "telrec": "\u2315",
            "Tfr": "\uD835\uDD17",
            "tfr": "\uD835\uDD31",
            "there4": "\u2234",
            "therefore": "\u2234",
            "Therefore": "\u2234",
            "Theta": "\u0398",
            "theta": "\u03B8",
            "thetasym": "\u03D1",
            "thetav": "\u03D1",
            "thickapprox": "\u2248",
            "thicksim": "\u223C",
            "ThickSpace": "\u205F\u200A",
            "ThinSpace": "\u2009",
            "thinsp": "\u2009",
            "thkap": "\u2248",
            "thksim": "\u223C",
            "THORN": "\u00DE",
            "thorn": "\u00FE",
            "tilde": "\u02DC",
            "Tilde": "\u223C",
            "TildeEqual": "\u2243",
            "TildeFullEqual": "\u2245",
            "TildeTilde": "\u2248",
            "timesbar": "\u2A31",
            "timesb": "\u22A0",
            "times": "\u00D7",
            "timesd": "\u2A30",
            "tint": "\u222D",
            "toea": "\u2928",
            "topbot": "\u2336",
            "topcir": "\u2AF1",
            "top": "\u22A4",
            "Topf": "\uD835\uDD4B",
            "topf": "\uD835\uDD65",
            "topfork": "\u2ADA",
            "tosa": "\u2929",
            "tprime": "\u2034",
            "trade": "\u2122",
            "TRADE": "\u2122",
            "triangle": "\u25B5",
            "triangledown": "\u25BF",
            "triangleleft": "\u25C3",
            "trianglelefteq": "\u22B4",
            "triangleq": "\u225C",
            "triangleright": "\u25B9",
            "trianglerighteq": "\u22B5",
            "tridot": "\u25EC",
            "trie": "\u225C",
            "triminus": "\u2A3A",
            "TripleDot": "\u20DB",
            "triplus": "\u2A39",
            "trisb": "\u29CD",
            "tritime": "\u2A3B",
            "trpezium": "\u23E2",
            "Tscr": "\uD835\uDCAF",
            "tscr": "\uD835\uDCC9",
            "TScy": "\u0426",
            "tscy": "\u0446",
            "TSHcy": "\u040B",
            "tshcy": "\u045B",
            "Tstrok": "\u0166",
            "tstrok": "\u0167",
            "twixt": "\u226C",
            "twoheadleftarrow": "\u219E",
            "twoheadrightarrow": "\u21A0",
            "Uacute": "\u00DA",
            "uacute": "\u00FA",
            "uarr": "\u2191",
            "Uarr": "\u219F",
            "uArr": "\u21D1",
            "Uarrocir": "\u2949",
            "Ubrcy": "\u040E",
            "ubrcy": "\u045E",
            "Ubreve": "\u016C",
            "ubreve": "\u016D",
            "Ucirc": "\u00DB",
            "ucirc": "\u00FB",
            "Ucy": "\u0423",
            "ucy": "\u0443",
            "udarr": "\u21C5",
            "Udblac": "\u0170",
            "udblac": "\u0171",
            "udhar": "\u296E",
            "ufisht": "\u297E",
            "Ufr": "\uD835\uDD18",
            "ufr": "\uD835\uDD32",
            "Ugrave": "\u00D9",
            "ugrave": "\u00F9",
            "uHar": "\u2963",
            "uharl": "\u21BF",
            "uharr": "\u21BE",
            "uhblk": "\u2580",
            "ulcorn": "\u231C",
            "ulcorner": "\u231C",
            "ulcrop": "\u230F",
            "ultri": "\u25F8",
            "Umacr": "\u016A",
            "umacr": "\u016B",
            "uml": "\u00A8",
            "UnderBar": "_",
            "UnderBrace": "\u23DF",
            "UnderBracket": "\u23B5",
            "UnderParenthesis": "\u23DD",
            "Union": "\u22C3",
            "UnionPlus": "\u228E",
            "Uogon": "\u0172",
            "uogon": "\u0173",
            "Uopf": "\uD835\uDD4C",
            "uopf": "\uD835\uDD66",
            "UpArrowBar": "\u2912",
            "uparrow": "\u2191",
            "UpArrow": "\u2191",
            "Uparrow": "\u21D1",
            "UpArrowDownArrow": "\u21C5",
            "updownarrow": "\u2195",
            "UpDownArrow": "\u2195",
            "Updownarrow": "\u21D5",
            "UpEquilibrium": "\u296E",
            "upharpoonleft": "\u21BF",
            "upharpoonright": "\u21BE",
            "uplus": "\u228E",
            "UpperLeftArrow": "\u2196",
            "UpperRightArrow": "\u2197",
            "upsi": "\u03C5",
            "Upsi": "\u03D2",
            "upsih": "\u03D2",
            "Upsilon": "\u03A5",
            "upsilon": "\u03C5",
            "UpTeeArrow": "\u21A5",
            "UpTee": "\u22A5",
            "upuparrows": "\u21C8",
            "urcorn": "\u231D",
            "urcorner": "\u231D",
            "urcrop": "\u230E",
            "Uring": "\u016E",
            "uring": "\u016F",
            "urtri": "\u25F9",
            "Uscr": "\uD835\uDCB0",
            "uscr": "\uD835\uDCCA",
            "utdot": "\u22F0",
            "Utilde": "\u0168",
            "utilde": "\u0169",
            "utri": "\u25B5",
            "utrif": "\u25B4",
            "uuarr": "\u21C8",
            "Uuml": "\u00DC",
            "uuml": "\u00FC",
            "uwangle": "\u29A7",
            "vangrt": "\u299C",
            "varepsilon": "\u03F5",
            "varkappa": "\u03F0",
            "varnothing": "\u2205",
            "varphi": "\u03D5",
            "varpi": "\u03D6",
            "varpropto": "\u221D",
            "varr": "\u2195",
            "vArr": "\u21D5",
            "varrho": "\u03F1",
            "varsigma": "\u03C2",
            "varsubsetneq": "\u228A\uFE00",
            "varsubsetneqq": "\u2ACB\uFE00",
            "varsupsetneq": "\u228B\uFE00",
            "varsupsetneqq": "\u2ACC\uFE00",
            "vartheta": "\u03D1",
            "vartriangleleft": "\u22B2",
            "vartriangleright": "\u22B3",
            "vBar": "\u2AE8",
            "Vbar": "\u2AEB",
            "vBarv": "\u2AE9",
            "Vcy": "\u0412",
            "vcy": "\u0432",
            "vdash": "\u22A2",
            "vDash": "\u22A8",
            "Vdash": "\u22A9",
            "VDash": "\u22AB",
            "Vdashl": "\u2AE6",
            "veebar": "\u22BB",
            "vee": "\u2228",
            "Vee": "\u22C1",
            "veeeq": "\u225A",
            "vellip": "\u22EE",
            "verbar": "|",
            "Verbar": "\u2016",
            "vert": "|",
            "Vert": "\u2016",
            "VerticalBar": "\u2223",
            "VerticalLine": "|",
            "VerticalSeparator": "\u2758",
            "VerticalTilde": "\u2240",
            "VeryThinSpace": "\u200A",
            "Vfr": "\uD835\uDD19",
            "vfr": "\uD835\uDD33",
            "vltri": "\u22B2",
            "vnsub": "\u2282\u20D2",
            "vnsup": "\u2283\u20D2",
            "Vopf": "\uD835\uDD4D",
            "vopf": "\uD835\uDD67",
            "vprop": "\u221D",
            "vrtri": "\u22B3",
            "Vscr": "\uD835\uDCB1",
            "vscr": "\uD835\uDCCB",
            "vsubnE": "\u2ACB\uFE00",
            "vsubne": "\u228A\uFE00",
            "vsupnE": "\u2ACC\uFE00",
            "vsupne": "\u228B\uFE00",
            "Vvdash": "\u22AA",
            "vzigzag": "\u299A",
            "Wcirc": "\u0174",
            "wcirc": "\u0175",
            "wedbar": "\u2A5F",
            "wedge": "\u2227",
            "Wedge": "\u22C0",
            "wedgeq": "\u2259",
            "weierp": "\u2118",
            "Wfr": "\uD835\uDD1A",
            "wfr": "\uD835\uDD34",
            "Wopf": "\uD835\uDD4E",
            "wopf": "\uD835\uDD68",
            "wp": "\u2118",
            "wr": "\u2240",
            "wreath": "\u2240",
            "Wscr": "\uD835\uDCB2",
            "wscr": "\uD835\uDCCC",
            "xcap": "\u22C2",
            "xcirc": "\u25EF",
            "xcup": "\u22C3",
            "xdtri": "\u25BD",
            "Xfr": "\uD835\uDD1B",
            "xfr": "\uD835\uDD35",
            "xharr": "\u27F7",
            "xhArr": "\u27FA",
            "Xi": "\u039E",
            "xi": "\u03BE",
            "xlarr": "\u27F5",
            "xlArr": "\u27F8",
            "xmap": "\u27FC",
            "xnis": "\u22FB",
            "xodot": "\u2A00",
            "Xopf": "\uD835\uDD4F",
            "xopf": "\uD835\uDD69",
            "xoplus": "\u2A01",
            "xotime": "\u2A02",
            "xrarr": "\u27F6",
            "xrArr": "\u27F9",
            "Xscr": "\uD835\uDCB3",
            "xscr": "\uD835\uDCCD",
            "xsqcup": "\u2A06",
            "xuplus": "\u2A04",
            "xutri": "\u25B3",
            "xvee": "\u22C1",
            "xwedge": "\u22C0",
            "Yacute": "\u00DD",
            "yacute": "\u00FD",
            "YAcy": "\u042F",
            "yacy": "\u044F",
            "Ycirc": "\u0176",
            "ycirc": "\u0177",
            "Ycy": "\u042B",
            "ycy": "\u044B",
            "yen": "\u00A5",
            "Yfr": "\uD835\uDD1C",
            "yfr": "\uD835\uDD36",
            "YIcy": "\u0407",
            "yicy": "\u0457",
            "Yopf": "\uD835\uDD50",
            "yopf": "\uD835\uDD6A",
            "Yscr": "\uD835\uDCB4",
            "yscr": "\uD835\uDCCE",
            "YUcy": "\u042E",
            "yucy": "\u044E",
            "yuml": "\u00FF",
            "Yuml": "\u0178",
            "Zacute": "\u0179",
            "zacute": "\u017A",
            "Zcaron": "\u017D",
            "zcaron": "\u017E",
            "Zcy": "\u0417",
            "zcy": "\u0437",
            "Zdot": "\u017B",
            "zdot": "\u017C",
            "zeetrf": "\u2128",
            "ZeroWidthSpace": "\u200B",
            "Zeta": "\u0396",
            "zeta": "\u03B6",
            "zfr": "\uD835\uDD37",
            "Zfr": "\u2128",
            "ZHcy": "\u0416",
            "zhcy": "\u0436",
            "zigrarr": "\u21DD",
            "zopf": "\uD835\uDD6B",
            "Zopf": "\u2124",
            "Zscr": "\uD835\uDCB5",
            "zscr": "\uD835\uDCCF",
            "zwj": "\u200D",
            "zwnj": "\u200C"
        }
    }, {}],
    33: [function (require, module, exports) {
        module.exports = {
            "Aacute": "\u00C1",
            "aacute": "\u00E1",
            "Acirc": "\u00C2",
            "acirc": "\u00E2",
            "acute": "\u00B4",
            "AElig": "\u00C6",
            "aelig": "\u00E6",
            "Agrave": "\u00C0",
            "agrave": "\u00E0",
            "amp": "&",
            "AMP": "&",
            "Aring": "\u00C5",
            "aring": "\u00E5",
            "Atilde": "\u00C3",
            "atilde": "\u00E3",
            "Auml": "\u00C4",
            "auml": "\u00E4",
            "brvbar": "\u00A6",
            "Ccedil": "\u00C7",
            "ccedil": "\u00E7",
            "cedil": "\u00B8",
            "cent": "\u00A2",
            "copy": "\u00A9",
            "COPY": "\u00A9",
            "curren": "\u00A4",
            "deg": "\u00B0",
            "divide": "\u00F7",
            "Eacute": "\u00C9",
            "eacute": "\u00E9",
            "Ecirc": "\u00CA",
            "ecirc": "\u00EA",
            "Egrave": "\u00C8",
            "egrave": "\u00E8",
            "ETH": "\u00D0",
            "eth": "\u00F0",
            "Euml": "\u00CB",
            "euml": "\u00EB",
            "frac12": "\u00BD",
            "frac14": "\u00BC",
            "frac34": "\u00BE",
            "gt": ">",
            "GT": ">",
            "Iacute": "\u00CD",
            "iacute": "\u00ED",
            "Icirc": "\u00CE",
            "icirc": "\u00EE",
            "iexcl": "\u00A1",
            "Igrave": "\u00CC",
            "igrave": "\u00EC",
            "iquest": "\u00BF",
            "Iuml": "\u00CF",
            "iuml": "\u00EF",
            "laquo": "\u00AB",
            "lt": "<",
            "LT": "<",
            "macr": "\u00AF",
            "micro": "\u00B5",
            "middot": "\u00B7",
            "nbsp": "\u00A0",
            "not": "\u00AC",
            "Ntilde": "\u00D1",
            "ntilde": "\u00F1",
            "Oacute": "\u00D3",
            "oacute": "\u00F3",
            "Ocirc": "\u00D4",
            "ocirc": "\u00F4",
            "Ograve": "\u00D2",
            "ograve": "\u00F2",
            "ordf": "\u00AA",
            "ordm": "\u00BA",
            "Oslash": "\u00D8",
            "oslash": "\u00F8",
            "Otilde": "\u00D5",
            "otilde": "\u00F5",
            "Ouml": "\u00D6",
            "ouml": "\u00F6",
            "para": "\u00B6",
            "plusmn": "\u00B1",
            "pound": "\u00A3",
            "quot": "\"",
            "QUOT": "\"",
            "raquo": "\u00BB",
            "reg": "\u00AE",
            "REG": "\u00AE",
            "sect": "\u00A7",
            "shy": "\u00AD",
            "sup1": "\u00B9",
            "sup2": "\u00B2",
            "sup3": "\u00B3",
            "szlig": "\u00DF",
            "THORN": "\u00DE",
            "thorn": "\u00FE",
            "times": "\u00D7",
            "Uacute": "\u00DA",
            "uacute": "\u00FA",
            "Ucirc": "\u00DB",
            "ucirc": "\u00FB",
            "Ugrave": "\u00D9",
            "ugrave": "\u00F9",
            "uml": "\u00A8",
            "Uuml": "\u00DC",
            "uuml": "\u00FC",
            "Yacute": "\u00DD",
            "yacute": "\u00FD",
            "yen": "\u00A5",
            "yuml": "\u00FF"
        }
    }, {}],
    34: [function (require, module, exports) {
        module.exports = {"amp": "&", "apos": "'", "gt": ">", "lt": "<", "quot": "\""}

    }, {}],
    35: [function (require, module, exports) {

    }, {}],
    36: [function (require, module, exports) {
        (function (global) {
            /*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */
            /* eslint-disable no-proto */

            'use strict'

            var base64 = require('base64-js')
            var ieee754 = require('ieee754')
            var isArray = require('isarray')

            exports.Buffer = Buffer
            exports.SlowBuffer = SlowBuffer
            exports.INSPECT_MAX_BYTES = 50
            Buffer.poolSize = 8192 // not used by this implementation

            var rootParent = {}

            /**
             * If `Buffer.TYPED_ARRAY_SUPPORT`:
             *   === true    Use Uint8Array implementation (fastest)
             *   === false   Use Object implementation (most compatible, even IE6)
             *
             * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
             * Opera 11.6+, iOS 4.2+.
             *
             * Due to various browser bugs, sometimes the Object implementation will be used even
             * when the browser supports typed arrays.
             *
             * Note:
             *
             *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
             *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
             *
             *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
             *
             *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
             *     incorrect length in some situations.

             * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
             * get the Object implementation, which is slower but behaves correctly.
             */
            Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
                ? global.TYPED_ARRAY_SUPPORT
                : typedArraySupport()

            function typedArraySupport() {
                try {
                    var arr = new Uint8Array(1)
                    arr.foo = function () {
                        return 42
                    }
                    return arr.foo() === 42 && // typed array instances can be augmented
                        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
                        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
                } catch (e) {
                    return false
                }
            }

            function kMaxLength() {
                return Buffer.TYPED_ARRAY_SUPPORT
                    ? 0x7fffffff
                    : 0x3fffffff
            }

            /**
             * The Buffer constructor returns instances of `Uint8Array` that have their
             * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
             * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
             * and the `Uint8Array` methods. Square bracket notation works as expected -- it
             * returns a single octet.
             *
             * The `Uint8Array` prototype remains unmodified.
             */
            function Buffer(arg) {
                if (!(this instanceof Buffer)) {
                    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.
                    if (arguments.length > 1) return new Buffer(arg, arguments[1])
                    return new Buffer(arg)
                }

                if (!Buffer.TYPED_ARRAY_SUPPORT) {
                    this.length = 0
                    this.parent = undefined
                }

                // Common case.
                if (typeof arg === 'number') {
                    return fromNumber(this, arg)
                }

                // Slightly less common case.
                if (typeof arg === 'string') {
                    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8')
                }

                // Unusual.
                return fromObject(this, arg)
            }

// TODO: Legacy, not needed anymore. Remove in next major version.
            Buffer._augment = function (arr) {
                arr.__proto__ = Buffer.prototype
                return arr
            }

            function fromNumber(that, length) {
                that = allocate(that, length < 0 ? 0 : checked(length) | 0)
                if (!Buffer.TYPED_ARRAY_SUPPORT) {
                    for (var i = 0; i < length; i++) {
                        that[i] = 0
                    }
                }
                return that
            }

            function fromString(that, string, encoding) {
                if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8'

                // Assumption: byteLength() return value is always < kMaxLength.
                var length = byteLength(string, encoding) | 0
                that = allocate(that, length)

                that.write(string, encoding)
                return that
            }

            function fromObject(that, object) {
                if (Buffer.isBuffer(object)) return fromBuffer(that, object)

                if (isArray(object)) return fromArray(that, object)

                if (object == null) {
                    throw new TypeError('must start with number, buffer, array or string')
                }

                if (typeof ArrayBuffer !== 'undefined') {
                    if (object.buffer instanceof ArrayBuffer) {
                        return fromTypedArray(that, object)
                    }
                    if (object instanceof ArrayBuffer) {
                        return fromArrayBuffer(that, object)
                    }
                }

                if (object.length) return fromArrayLike(that, object)

                return fromJsonObject(that, object)
            }

            function fromBuffer(that, buffer) {
                var length = checked(buffer.length) | 0
                that = allocate(that, length)
                buffer.copy(that, 0, 0, length)
                return that
            }

            function fromArray(that, array) {
                var length = checked(array.length) | 0
                that = allocate(that, length)
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

// Duplicate of fromArray() to keep fromArray() monomorphic.
            function fromTypedArray(that, array) {
                var length = checked(array.length) | 0
                that = allocate(that, length)
                // Truncating the elements is probably not what people expect from typed
                // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
                // of the old Buffer constructor.
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

            function fromArrayBuffer(that, array) {
                array.byteLength // this throws if `array` is not a valid ArrayBuffer

                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    // Return an augmented `Uint8Array` instance, for best performance
                    that = new Uint8Array(array)
                    that.__proto__ = Buffer.prototype
                } else {
                    // Fallback: Return an object instance of the Buffer class
                    that = fromTypedArray(that, new Uint8Array(array))
                }
                return that
            }

            function fromArrayLike(that, array) {
                var length = checked(array.length) | 0
                that = allocate(that, length)
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
// Returns a zero-length buffer for inputs that don't conform to the spec.
            function fromJsonObject(that, object) {
                var array
                var length = 0

                if (object.type === 'Buffer' && isArray(object.data)) {
                    array = object.data
                    length = checked(array.length) | 0
                }
                that = allocate(that, length)

                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

            if (Buffer.TYPED_ARRAY_SUPPORT) {
                Buffer.prototype.__proto__ = Uint8Array.prototype
                Buffer.__proto__ = Uint8Array
                if (typeof Symbol !== 'undefined' && Symbol.species &&
                    Buffer[Symbol.species] === Buffer) {
                    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
                    Object.defineProperty(Buffer, Symbol.species, {
                        value: null,
                        configurable: true
                    })
                }
            } else {
                // pre-set for values that may exist in the future
                Buffer.prototype.length = undefined
                Buffer.prototype.parent = undefined
            }

            function allocate(that, length) {
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    // Return an augmented `Uint8Array` instance, for best performance
                    that = new Uint8Array(length)
                    that.__proto__ = Buffer.prototype
                } else {
                    // Fallback: Return an object instance of the Buffer class
                    that.length = length
                }

                var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1
                if (fromPool) that.parent = rootParent

                return that
            }

            function checked(length) {
                // Note: cannot use `length < kMaxLength` here because that fails when
                // length is NaN (which is otherwise coerced to zero.)
                if (length >= kMaxLength()) {
                    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                        'size: 0x' + kMaxLength().toString(16) + ' bytes')
                }
                return length | 0
            }

            function SlowBuffer(subject, encoding) {
                if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding)

                var buf = new Buffer(subject, encoding)
                delete buf.parent
                return buf
            }

            Buffer.isBuffer = function isBuffer(b) {
                return !!(b != null && b._isBuffer)
            }

            Buffer.compare = function compare(a, b) {
                if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
                    throw new TypeError('Arguments must be Buffers')
                }

                if (a === b) return 0

                var x = a.length
                var y = b.length

                for (var i = 0, len = Math.min(x, y); i < len; ++i) {
                    if (a[i] !== b[i]) {
                        x = a[i]
                        y = b[i]
                        break
                    }
                }

                if (x < y) return -1
                if (y < x) return 1
                return 0
            }

            Buffer.isEncoding = function isEncoding(encoding) {
                switch (String(encoding).toLowerCase()) {
                    case 'hex':
                    case 'utf8':
                    case 'utf-8':
                    case 'ascii':
                    case 'binary':
                    case 'base64':
                    case 'raw':
                    case 'ucs2':
                    case 'ucs-2':
                    case 'utf16le':
                    case 'utf-16le':
                        return true
                    default:
                        return false
                }
            }

            Buffer.concat = function concat(list, length) {
                if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.')

                if (list.length === 0) {
                    return new Buffer(0)
                }

                var i
                if (length === undefined) {
                    length = 0
                    for (i = 0; i < list.length; i++) {
                        length += list[i].length
                    }
                }

                var buf = new Buffer(length)
                var pos = 0
                for (i = 0; i < list.length; i++) {
                    var item = list[i]
                    item.copy(buf, pos)
                    pos += item.length
                }
                return buf
            }

            function byteLength(string, encoding) {
                if (typeof string !== 'string') string = '' + string

                var len = string.length
                if (len === 0) return 0

                // Use a for loop to avoid recursion
                var loweredCase = false
                for (; ;) {
                    switch (encoding) {
                        case 'ascii':
                        case 'binary':
                        // Deprecated
                        case 'raw':
                        case 'raws':
                            return len
                        case 'utf8':
                        case 'utf-8':
                            return utf8ToBytes(string).length
                        case 'ucs2':
                        case 'ucs-2':
                        case 'utf16le':
                        case 'utf-16le':
                            return len * 2
                        case 'hex':
                            return len >>> 1
                        case 'base64':
                            return base64ToBytes(string).length
                        default:
                            if (loweredCase) return utf8ToBytes(string).length // assume utf8
                            encoding = ('' + encoding).toLowerCase()
                            loweredCase = true
                    }
                }
            }

            Buffer.byteLength = byteLength

            function slowToString(encoding, start, end) {
                var loweredCase = false

                start = start | 0
                end = end === undefined || end === Infinity ? this.length : end | 0

                if (!encoding) encoding = 'utf8'
                if (start < 0) start = 0
                if (end > this.length) end = this.length
                if (end <= start) return ''

                while (true) {
                    switch (encoding) {
                        case 'hex':
                            return hexSlice(this, start, end)

                        case 'utf8':
                        case 'utf-8':
                            return utf8Slice(this, start, end)

                        case 'ascii':
                            return asciiSlice(this, start, end)

                        case 'binary':
                            return binarySlice(this, start, end)

                        case 'base64':
                            return base64Slice(this, start, end)

                        case 'ucs2':
                        case 'ucs-2':
                        case 'utf16le':
                        case 'utf-16le':
                            return utf16leSlice(this, start, end)

                        default:
                            if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                            encoding = (encoding + '').toLowerCase()
                            loweredCase = true
                    }
                }
            }

// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
            Buffer.prototype._isBuffer = true

            Buffer.prototype.toString = function toString() {
                var length = this.length | 0
                if (length === 0) return ''
                if (arguments.length === 0) return utf8Slice(this, 0, length)
                return slowToString.apply(this, arguments)
            }

            Buffer.prototype.equals = function equals(b) {
                if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
                if (this === b) return true
                return Buffer.compare(this, b) === 0
            }

            Buffer.prototype.inspect = function inspect() {
                var str = ''
                var max = exports.INSPECT_MAX_BYTES
                if (this.length > 0) {
                    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
                    if (this.length > max) str += ' ... '
                }
                return '<Buffer ' + str + '>'
            }

            Buffer.prototype.compare = function compare(b) {
                if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
                return Buffer.compare(this, b)
            }

            Buffer.prototype.indexOf = function indexOf(val, byteOffset) {
                if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff
                else if (byteOffset < -0x80000000) byteOffset = -0x80000000
                byteOffset >>= 0

                if (this.length === 0) return -1
                if (byteOffset >= this.length) return -1

                // Negative offsets start from the end of the buffer
                if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0)

                if (typeof val === 'string') {
                    if (val.length === 0) return -1 // special case: looking for empty string always fails
                    return String.prototype.indexOf.call(this, val, byteOffset)
                }
                if (Buffer.isBuffer(val)) {
                    return arrayIndexOf(this, val, byteOffset)
                }
                if (typeof val === 'number') {
                    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
                        return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
                    }
                    return arrayIndexOf(this, [val], byteOffset)
                }

                function arrayIndexOf(arr, val, byteOffset) {
                    var foundIndex = -1
                    for (var i = 0; byteOffset + i < arr.length; i++) {
                        if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
                            if (foundIndex === -1) foundIndex = i
                            if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
                        } else {
                            foundIndex = -1
                        }
                    }
                    return -1
                }

                throw new TypeError('val must be string, number or Buffer')
            }

            function hexWrite(buf, string, offset, length) {
                offset = Number(offset) || 0
                var remaining = buf.length - offset
                if (!length) {
                    length = remaining
                } else {
                    length = Number(length)
                    if (length > remaining) {
                        length = remaining
                    }
                }

                // must be an even number of digits
                var strLen = string.length
                if (strLen % 2 !== 0) throw new Error('Invalid hex string')

                if (length > strLen / 2) {
                    length = strLen / 2
                }
                for (var i = 0; i < length; i++) {
                    var parsed = parseInt(string.substr(i * 2, 2), 16)
                    if (isNaN(parsed)) throw new Error('Invalid hex string')
                    buf[offset + i] = parsed
                }
                return i
            }

            function utf8Write(buf, string, offset, length) {
                return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
            }

            function asciiWrite(buf, string, offset, length) {
                return blitBuffer(asciiToBytes(string), buf, offset, length)
            }

            function binaryWrite(buf, string, offset, length) {
                return asciiWrite(buf, string, offset, length)
            }

            function base64Write(buf, string, offset, length) {
                return blitBuffer(base64ToBytes(string), buf, offset, length)
            }

            function ucs2Write(buf, string, offset, length) {
                return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
            }

            Buffer.prototype.write = function write(string, offset, length, encoding) {
                // Buffer#write(string)
                if (offset === undefined) {
                    encoding = 'utf8'
                    length = this.length
                    offset = 0
                    // Buffer#write(string, encoding)
                } else if (length === undefined && typeof offset === 'string') {
                    encoding = offset
                    length = this.length
                    offset = 0
                    // Buffer#write(string, offset[, length][, encoding])
                } else if (isFinite(offset)) {
                    offset = offset | 0
                    if (isFinite(length)) {
                        length = length | 0
                        if (encoding === undefined) encoding = 'utf8'
                    } else {
                        encoding = length
                        length = undefined
                    }
                    // legacy write(string, encoding, offset, length) - remove in v0.13
                } else {
                    var swap = encoding
                    encoding = offset
                    offset = length | 0
                    length = swap
                }

                var remaining = this.length - offset
                if (length === undefined || length > remaining) length = remaining

                if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
                    throw new RangeError('attempt to write outside buffer bounds')
                }

                if (!encoding) encoding = 'utf8'

                var loweredCase = false
                for (; ;) {
                    switch (encoding) {
                        case 'hex':
                            return hexWrite(this, string, offset, length)

                        case 'utf8':
                        case 'utf-8':
                            return utf8Write(this, string, offset, length)

                        case 'ascii':
                            return asciiWrite(this, string, offset, length)

                        case 'binary':
                            return binaryWrite(this, string, offset, length)

                        case 'base64':
                            // Warning: maxLength not taken into account in base64Write
                            return base64Write(this, string, offset, length)

                        case 'ucs2':
                        case 'ucs-2':
                        case 'utf16le':
                        case 'utf-16le':
                            return ucs2Write(this, string, offset, length)

                        default:
                            if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                            encoding = ('' + encoding).toLowerCase()
                            loweredCase = true
                    }
                }
            }

            Buffer.prototype.toJSON = function toJSON() {
                return {
                    type: 'Buffer',
                    data: Array.prototype.slice.call(this._arr || this, 0)
                }
            }

            function base64Slice(buf, start, end) {
                if (start === 0 && end === buf.length) {
                    return base64.fromByteArray(buf)
                } else {
                    return base64.fromByteArray(buf.slice(start, end))
                }
            }

            function utf8Slice(buf, start, end) {
                end = Math.min(buf.length, end)
                var res = []

                var i = start
                while (i < end) {
                    var firstByte = buf[i]
                    var codePoint = null
                    var bytesPerSequence = (firstByte > 0xEF) ? 4
                        : (firstByte > 0xDF) ? 3
                            : (firstByte > 0xBF) ? 2
                                : 1

                    if (i + bytesPerSequence <= end) {
                        var secondByte, thirdByte, fourthByte, tempCodePoint

                        switch (bytesPerSequence) {
                            case 1:
                                if (firstByte < 0x80) {
                                    codePoint = firstByte
                                }
                                break
                            case 2:
                                secondByte = buf[i + 1]
                                if ((secondByte & 0xC0) === 0x80) {
                                    tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
                                    if (tempCodePoint > 0x7F) {
                                        codePoint = tempCodePoint
                                    }
                                }
                                break
                            case 3:
                                secondByte = buf[i + 1]
                                thirdByte = buf[i + 2]
                                if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
                                    tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
                                    if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                                        codePoint = tempCodePoint
                                    }
                                }
                                break
                            case 4:
                                secondByte = buf[i + 1]
                                thirdByte = buf[i + 2]
                                fourthByte = buf[i + 3]
                                if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
                                    tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
                                    if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                                        codePoint = tempCodePoint
                                    }
                                }
                        }
                    }

                    if (codePoint === null) {
                        // we did not generate a valid codePoint so insert a
                        // replacement char (U+FFFD) and advance only 1 byte
                        codePoint = 0xFFFD
                        bytesPerSequence = 1
                    } else if (codePoint > 0xFFFF) {
                        // encode to utf16 (surrogate pair dance)
                        codePoint -= 0x10000
                        res.push(codePoint >>> 10 & 0x3FF | 0xD800)
                        codePoint = 0xDC00 | codePoint & 0x3FF
                    }

                    res.push(codePoint)
                    i += bytesPerSequence
                }

                return decodeCodePointsArray(res)
            }

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
            var MAX_ARGUMENTS_LENGTH = 0x1000

            function decodeCodePointsArray(codePoints) {
                var len = codePoints.length
                if (len <= MAX_ARGUMENTS_LENGTH) {
                    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
                }

                // Decode in chunks to avoid "call stack size exceeded".
                var res = ''
                var i = 0
                while (i < len) {
                    res += String.fromCharCode.apply(
                        String,
                        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
                    )
                }
                return res
            }

            function asciiSlice(buf, start, end) {
                var ret = ''
                end = Math.min(buf.length, end)

                for (var i = start; i < end; i++) {
                    ret += String.fromCharCode(buf[i] & 0x7F)
                }
                return ret
            }

            function binarySlice(buf, start, end) {
                var ret = ''
                end = Math.min(buf.length, end)

                for (var i = start; i < end; i++) {
                    ret += String.fromCharCode(buf[i])
                }
                return ret
            }

            function hexSlice(buf, start, end) {
                var len = buf.length

                if (!start || start < 0) start = 0
                if (!end || end < 0 || end > len) end = len

                var out = ''
                for (var i = start; i < end; i++) {
                    out += toHex(buf[i])
                }
                return out
            }

            function utf16leSlice(buf, start, end) {
                var bytes = buf.slice(start, end)
                var res = ''
                for (var i = 0; i < bytes.length; i += 2) {
                    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
                }
                return res
            }

            Buffer.prototype.slice = function slice(start, end) {
                var len = this.length
                start = ~~start
                end = end === undefined ? len : ~~end

                if (start < 0) {
                    start += len
                    if (start < 0) start = 0
                } else if (start > len) {
                    start = len
                }

                if (end < 0) {
                    end += len
                    if (end < 0) end = 0
                } else if (end > len) {
                    end = len
                }

                if (end < start) end = start

                var newBuf
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    newBuf = this.subarray(start, end)
                    newBuf.__proto__ = Buffer.prototype
                } else {
                    var sliceLen = end - start
                    newBuf = new Buffer(sliceLen, undefined)
                    for (var i = 0; i < sliceLen; i++) {
                        newBuf[i] = this[i + start]
                    }
                }

                if (newBuf.length) newBuf.parent = this.parent || this

                return newBuf
            }

            /*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */
            function checkOffset(offset, ext, length) {
                if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
                if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
            }

            Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
                offset = offset | 0
                byteLength = byteLength | 0
                if (!noAssert) checkOffset(offset, byteLength, this.length)

                var val = this[offset]
                var mul = 1
                var i = 0
                while (++i < byteLength && (mul *= 0x100)) {
                    val += this[offset + i] * mul
                }

                return val
            }

            Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
                offset = offset | 0
                byteLength = byteLength | 0
                if (!noAssert) {
                    checkOffset(offset, byteLength, this.length)
                }

                var val = this[offset + --byteLength]
                var mul = 1
                while (byteLength > 0 && (mul *= 0x100)) {
                    val += this[offset + --byteLength] * mul
                }

                return val
            }

            Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 1, this.length)
                return this[offset]
            }

            Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length)
                return this[offset] | (this[offset + 1] << 8)
            }

            Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length)
                return (this[offset] << 8) | this[offset + 1]
            }

            Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length)

                return ((this[offset]) |
                    (this[offset + 1] << 8) |
                    (this[offset + 2] << 16)) +
                    (this[offset + 3] * 0x1000000)
            }

            Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length)

                return (this[offset] * 0x1000000) +
                    ((this[offset + 1] << 16) |
                        (this[offset + 2] << 8) |
                        this[offset + 3])
            }

            Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
                offset = offset | 0
                byteLength = byteLength | 0
                if (!noAssert) checkOffset(offset, byteLength, this.length)

                var val = this[offset]
                var mul = 1
                var i = 0
                while (++i < byteLength && (mul *= 0x100)) {
                    val += this[offset + i] * mul
                }
                mul *= 0x80

                if (val >= mul) val -= Math.pow(2, 8 * byteLength)

                return val
            }

            Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
                offset = offset | 0
                byteLength = byteLength | 0
                if (!noAssert) checkOffset(offset, byteLength, this.length)

                var i = byteLength
                var mul = 1
                var val = this[offset + --i]
                while (i > 0 && (mul *= 0x100)) {
                    val += this[offset + --i] * mul
                }
                mul *= 0x80

                if (val >= mul) val -= Math.pow(2, 8 * byteLength)

                return val
            }

            Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 1, this.length)
                if (!(this[offset] & 0x80)) return (this[offset])
                return ((0xff - this[offset] + 1) * -1)
            }

            Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length)
                var val = this[offset] | (this[offset + 1] << 8)
                return (val & 0x8000) ? val | 0xFFFF0000 : val
            }

            Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length)
                var val = this[offset + 1] | (this[offset] << 8)
                return (val & 0x8000) ? val | 0xFFFF0000 : val
            }

            Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length)

                return (this[offset]) |
                    (this[offset + 1] << 8) |
                    (this[offset + 2] << 16) |
                    (this[offset + 3] << 24)
            }

            Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length)

                return (this[offset] << 24) |
                    (this[offset + 1] << 16) |
                    (this[offset + 2] << 8) |
                    (this[offset + 3])
            }

            Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length)
                return ieee754.read(this, offset, true, 23, 4)
            }

            Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length)
                return ieee754.read(this, offset, false, 23, 4)
            }

            Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 8, this.length)
                return ieee754.read(this, offset, true, 52, 8)
            }

            Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 8, this.length)
                return ieee754.read(this, offset, false, 52, 8)
            }

            function checkInt(buf, value, offset, ext, max, min) {
                if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
                if (value > max || value < min) throw new RangeError('value is out of bounds')
                if (offset + ext > buf.length) throw new RangeError('index out of range')
            }

            Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
                value = +value
                offset = offset | 0
                byteLength = byteLength | 0
                if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)

                var mul = 1
                var i = 0
                this[offset] = value & 0xFF
                while (++i < byteLength && (mul *= 0x100)) {
                    this[offset + i] = (value / mul) & 0xFF
                }

                return offset + byteLength
            }

            Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
                value = +value
                offset = offset | 0
                byteLength = byteLength | 0
                if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)

                var i = byteLength - 1
                var mul = 1
                this[offset + i] = value & 0xFF
                while (--i >= 0 && (mul *= 0x100)) {
                    this[offset + i] = (value / mul) & 0xFF
                }

                return offset + byteLength
            }

            Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
                if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
                this[offset] = (value & 0xff)
                return offset + 1
            }

            function objectWriteUInt16(buf, value, offset, littleEndian) {
                if (value < 0) value = 0xffff + value + 1
                for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
                    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
                        (littleEndian ? i : 1 - i) * 8
                }
            }

            Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value & 0xff)
                    this[offset + 1] = (value >>> 8)
                } else {
                    objectWriteUInt16(this, value, offset, true)
                }
                return offset + 2
            }

            Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value >>> 8)
                    this[offset + 1] = (value & 0xff)
                } else {
                    objectWriteUInt16(this, value, offset, false)
                }
                return offset + 2
            }

            function objectWriteUInt32(buf, value, offset, littleEndian) {
                if (value < 0) value = 0xffffffff + value + 1
                for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
                    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
                }
            }

            Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset + 3] = (value >>> 24)
                    this[offset + 2] = (value >>> 16)
                    this[offset + 1] = (value >>> 8)
                    this[offset] = (value & 0xff)
                } else {
                    objectWriteUInt32(this, value, offset, true)
                }
                return offset + 4
            }

            Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value >>> 24)
                    this[offset + 1] = (value >>> 16)
                    this[offset + 2] = (value >>> 8)
                    this[offset + 3] = (value & 0xff)
                } else {
                    objectWriteUInt32(this, value, offset, false)
                }
                return offset + 4
            }

            Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) {
                    var limit = Math.pow(2, 8 * byteLength - 1)

                    checkInt(this, value, offset, byteLength, limit - 1, -limit)
                }

                var i = 0
                var mul = 1
                var sub = value < 0 ? 1 : 0
                this[offset] = value & 0xFF
                while (++i < byteLength && (mul *= 0x100)) {
                    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
                }

                return offset + byteLength
            }

            Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) {
                    var limit = Math.pow(2, 8 * byteLength - 1)

                    checkInt(this, value, offset, byteLength, limit - 1, -limit)
                }

                var i = byteLength - 1
                var mul = 1
                var sub = value < 0 ? 1 : 0
                this[offset + i] = value & 0xFF
                while (--i >= 0 && (mul *= 0x100)) {
                    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
                }

                return offset + byteLength
            }

            Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
                if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
                if (value < 0) value = 0xff + value + 1
                this[offset] = (value & 0xff)
                return offset + 1
            }

            Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value & 0xff)
                    this[offset + 1] = (value >>> 8)
                } else {
                    objectWriteUInt16(this, value, offset, true)
                }
                return offset + 2
            }

            Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value >>> 8)
                    this[offset + 1] = (value & 0xff)
                } else {
                    objectWriteUInt16(this, value, offset, false)
                }
                return offset + 2
            }

            Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value & 0xff)
                    this[offset + 1] = (value >>> 8)
                    this[offset + 2] = (value >>> 16)
                    this[offset + 3] = (value >>> 24)
                } else {
                    objectWriteUInt32(this, value, offset, true)
                }
                return offset + 4
            }

            Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
                value = +value
                offset = offset | 0
                if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
                if (value < 0) value = 0xffffffff + value + 1
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = (value >>> 24)
                    this[offset + 1] = (value >>> 16)
                    this[offset + 2] = (value >>> 8)
                    this[offset + 3] = (value & 0xff)
                } else {
                    objectWriteUInt32(this, value, offset, false)
                }
                return offset + 4
            }

            function checkIEEE754(buf, value, offset, ext, max, min) {
                if (offset + ext > buf.length) throw new RangeError('index out of range')
                if (offset < 0) throw new RangeError('index out of range')
            }

            function writeFloat(buf, value, offset, littleEndian, noAssert) {
                if (!noAssert) {
                    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
                }
                ieee754.write(buf, value, offset, littleEndian, 23, 4)
                return offset + 4
            }

            Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
                return writeFloat(this, value, offset, true, noAssert)
            }

            Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
                return writeFloat(this, value, offset, false, noAssert)
            }

            function writeDouble(buf, value, offset, littleEndian, noAssert) {
                if (!noAssert) {
                    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
                }
                ieee754.write(buf, value, offset, littleEndian, 52, 8)
                return offset + 8
            }

            Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
                return writeDouble(this, value, offset, true, noAssert)
            }

            Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
                return writeDouble(this, value, offset, false, noAssert)
            }

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
            Buffer.prototype.copy = function copy(target, targetStart, start, end) {
                if (!start) start = 0
                if (!end && end !== 0) end = this.length
                if (targetStart >= target.length) targetStart = target.length
                if (!targetStart) targetStart = 0
                if (end > 0 && end < start) end = start

                // Copy 0 bytes; we're done
                if (end === start) return 0
                if (target.length === 0 || this.length === 0) return 0

                // Fatal error conditions
                if (targetStart < 0) {
                    throw new RangeError('targetStart out of bounds')
                }
                if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
                if (end < 0) throw new RangeError('sourceEnd out of bounds')

                // Are we oob?
                if (end > this.length) end = this.length
                if (target.length - targetStart < end - start) {
                    end = target.length - targetStart + start
                }

                var len = end - start
                var i

                if (this === target && start < targetStart && targetStart < end) {
                    // descending copy from end
                    for (i = len - 1; i >= 0; i--) {
                        target[i + targetStart] = this[i + start]
                    }
                } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
                    // ascending copy from start
                    for (i = 0; i < len; i++) {
                        target[i + targetStart] = this[i + start]
                    }
                } else {
                    Uint8Array.prototype.set.call(
                        target,
                        this.subarray(start, start + len),
                        targetStart
                    )
                }

                return len
            }

// fill(value, start=0, end=buffer.length)
            Buffer.prototype.fill = function fill(value, start, end) {
                if (!value) value = 0
                if (!start) start = 0
                if (!end) end = this.length

                if (end < start) throw new RangeError('end < start')

                // Fill 0 bytes; we're done
                if (end === start) return
                if (this.length === 0) return

                if (start < 0 || start >= this.length) throw new RangeError('start out of bounds')
                if (end < 0 || end > this.length) throw new RangeError('end out of bounds')

                var i
                if (typeof value === 'number') {
                    for (i = start; i < end; i++) {
                        this[i] = value
                    }
                } else {
                    var bytes = utf8ToBytes(value.toString())
                    var len = bytes.length
                    for (i = start; i < end; i++) {
                        this[i] = bytes[i % len]
                    }
                }

                return this
            }

// HELPER FUNCTIONS
// ================

            var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g

            function base64clean(str) {
                // Node strips out invalid characters like \n and \t from the string, base64-js does not
                str = stringtrim(str).replace(INVALID_BASE64_RE, '')
                // Node converts strings with length < 2 to ''
                if (str.length < 2) return ''
                // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
                while (str.length % 4 !== 0) {
                    str = str + '='
                }
                return str
            }

            function stringtrim(str) {
                if (str.trim) return str.trim()
                return str.replace(/^\s+|\s+$/g, '')
            }

            function toHex(n) {
                if (n < 16) return '0' + n.toString(16)
                return n.toString(16)
            }

            function utf8ToBytes(string, units) {
                units = units || Infinity
                var codePoint
                var length = string.length
                var leadSurrogate = null
                var bytes = []

                for (var i = 0; i < length; i++) {
                    codePoint = string.charCodeAt(i)

                    // is surrogate component
                    if (codePoint > 0xD7FF && codePoint < 0xE000) {
                        // last char was a lead
                        if (!leadSurrogate) {
                            // no lead yet
                            if (codePoint > 0xDBFF) {
                                // unexpected trail
                                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                                continue
                            } else if (i + 1 === length) {
                                // unpaired lead
                                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                                continue
                            }

                            // valid lead
                            leadSurrogate = codePoint

                            continue
                        }

                        // 2 leads in a row
                        if (codePoint < 0xDC00) {
                            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                            leadSurrogate = codePoint
                            continue
                        }

                        // valid surrogate pair
                        codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
                    } else if (leadSurrogate) {
                        // valid bmp char, but last char was a lead
                        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                    }

                    leadSurrogate = null

                    // encode utf8
                    if (codePoint < 0x80) {
                        if ((units -= 1) < 0) break
                        bytes.push(codePoint)
                    } else if (codePoint < 0x800) {
                        if ((units -= 2) < 0) break
                        bytes.push(
                            codePoint >> 0x6 | 0xC0,
                            codePoint & 0x3F | 0x80
                        )
                    } else if (codePoint < 0x10000) {
                        if ((units -= 3) < 0) break
                        bytes.push(
                            codePoint >> 0xC | 0xE0,
                            codePoint >> 0x6 & 0x3F | 0x80,
                            codePoint & 0x3F | 0x80
                        )
                    } else if (codePoint < 0x110000) {
                        if ((units -= 4) < 0) break
                        bytes.push(
                            codePoint >> 0x12 | 0xF0,
                            codePoint >> 0xC & 0x3F | 0x80,
                            codePoint >> 0x6 & 0x3F | 0x80,
                            codePoint & 0x3F | 0x80
                        )
                    } else {
                        throw new Error('Invalid code point')
                    }
                }

                return bytes
            }

            function asciiToBytes(str) {
                var byteArray = []
                for (var i = 0; i < str.length; i++) {
                    // Node's code seems to be doing this and not & 0x7F..
                    byteArray.push(str.charCodeAt(i) & 0xFF)
                }
                return byteArray
            }

            function utf16leToBytes(str, units) {
                var c, hi, lo
                var byteArray = []
                for (var i = 0; i < str.length; i++) {
                    if ((units -= 2) < 0) break

                    c = str.charCodeAt(i)
                    hi = c >> 8
                    lo = c % 256
                    byteArray.push(lo)
                    byteArray.push(hi)
                }

                return byteArray
            }

            function base64ToBytes(str) {
                return base64.toByteArray(base64clean(str))
            }

            function blitBuffer(src, dst, offset, length) {
                for (var i = 0; i < length; i++) {
                    if ((i + offset >= dst.length) || (i >= src.length)) break
                    dst[i + offset] = src[i]
                }
                return i
            }

        }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"base64-js": 37, "ieee754": 38, "isarray": 39}],
    37: [function (require, module, exports) {
        'use strict'

        exports.toByteArray = toByteArray
        exports.fromByteArray = fromByteArray

        var lookup = []
        var revLookup = []
        var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

        function init() {
            var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
            for (var i = 0, len = code.length; i < len; ++i) {
                lookup[i] = code[i]
                revLookup[code.charCodeAt(i)] = i
            }

            revLookup['-'.charCodeAt(0)] = 62
            revLookup['_'.charCodeAt(0)] = 63
        }

        init()

        function toByteArray(b64) {
            var i, j, l, tmp, placeHolders, arr
            var len = b64.length

            if (len % 4 > 0) {
                throw new Error('Invalid string. Length must be a multiple of 4')
            }

            // the number of equal signs (place holders)
            // if there are two placeholders, than the two characters before it
            // represent one byte
            // if there is only one, then the three characters before it represent 2 bytes
            // this is just a cheap hack to not do indexOf twice
            placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0

            // base64 is 4/3 + up to two characters of the original data
            arr = new Arr(len * 3 / 4 - placeHolders)

            // if there are placeholders, only get up to the last complete 4 chars
            l = placeHolders > 0 ? len - 4 : len

            var L = 0

            for (i = 0, j = 0; i < l; i += 4, j += 3) {
                tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]
                arr[L++] = (tmp >> 16) & 0xFF
                arr[L++] = (tmp >> 8) & 0xFF
                arr[L++] = tmp & 0xFF
            }

            if (placeHolders === 2) {
                tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4)
                arr[L++] = tmp & 0xFF
            } else if (placeHolders === 1) {
                tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2)
                arr[L++] = (tmp >> 8) & 0xFF
                arr[L++] = tmp & 0xFF
            }

            return arr
        }

        function tripletToBase64(num) {
            return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
        }

        function encodeChunk(uint8, start, end) {
            var tmp
            var output = []
            for (var i = start; i < end; i += 3) {
                tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
                output.push(tripletToBase64(tmp))
            }
            return output.join('')
        }

        function fromByteArray(uint8) {
            var tmp
            var len = uint8.length
            var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
            var output = ''
            var parts = []
            var maxChunkLength = 16383 // must be multiple of 3

            // go through the array every three bytes, we'll deal with trailing stuff later
            for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
                parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
            }

            // pad the end with zeros, but make sure to not forget the extra bytes
            if (extraBytes === 1) {
                tmp = uint8[len - 1]
                output += lookup[tmp >> 2]
                output += lookup[(tmp << 4) & 0x3F]
                output += '=='
            } else if (extraBytes === 2) {
                tmp = (uint8[len - 2] << 8) + (uint8[len - 1])
                output += lookup[tmp >> 10]
                output += lookup[(tmp >> 4) & 0x3F]
                output += lookup[(tmp << 2) & 0x3F]
                output += '='
            }

            parts.push(output)

            return parts.join('')
        }

    }, {}],
    38: [function (require, module, exports) {
        exports.read = function (buffer, offset, isLE, mLen, nBytes) {
            var e, m
            var eLen = nBytes * 8 - mLen - 1
            var eMax = (1 << eLen) - 1
            var eBias = eMax >> 1
            var nBits = -7
            var i = isLE ? (nBytes - 1) : 0
            var d = isLE ? -1 : 1
            var s = buffer[offset + i]

            i += d

            e = s & ((1 << (-nBits)) - 1)
            s >>= (-nBits)
            nBits += eLen
            for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
            }

            m = e & ((1 << (-nBits)) - 1)
            e >>= (-nBits)
            nBits += mLen
            for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
            }

            if (e === 0) {
                e = 1 - eBias
            } else if (e === eMax) {
                return m ? NaN : ((s ? -1 : 1) * Infinity)
            } else {
                m = m + Math.pow(2, mLen)
                e = e - eBias
            }
            return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
        }

        exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
            var e, m, c
            var eLen = nBytes * 8 - mLen - 1
            var eMax = (1 << eLen) - 1
            var eBias = eMax >> 1
            var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
            var i = isLE ? 0 : (nBytes - 1)
            var d = isLE ? 1 : -1
            var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

            value = Math.abs(value)

            if (isNaN(value) || value === Infinity) {
                m = isNaN(value) ? 1 : 0
                e = eMax
            } else {
                e = Math.floor(Math.log(value) / Math.LN2)
                if (value * (c = Math.pow(2, -e)) < 1) {
                    e--
                    c *= 2
                }
                if (e + eBias >= 1) {
                    value += rt / c
                } else {
                    value += rt * Math.pow(2, 1 - eBias)
                }
                if (value * c >= 2) {
                    e++
                    c /= 2
                }

                if (e + eBias >= eMax) {
                    m = 0
                    e = eMax
                } else if (e + eBias >= 1) {
                    m = (value * c - 1) * Math.pow(2, mLen)
                    e = e + eBias
                } else {
                    m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
                    e = 0
                }
            }

            for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {
            }

            e = (e << mLen) | m
            eLen += mLen
            for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {
            }

            buffer[offset + i - d] |= s * 128
        }

    }, {}],
    39: [function (require, module, exports) {
        var toString = {}.toString;

        module.exports = Array.isArray || function (arr) {
            return toString.call(arr) == '[object Array]';
        };

    }, {}],
    40: [function (require, module, exports) {
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

        function EventEmitter() {
            this._events = this._events || {};
            this._maxListeners = this._maxListeners || undefined;
        }

        module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
        EventEmitter.EventEmitter = EventEmitter;

        EventEmitter.prototype._events = undefined;
        EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
        EventEmitter.defaultMaxListeners = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
        EventEmitter.prototype.setMaxListeners = function (n) {
            if (!isNumber(n) || n < 0 || isNaN(n))
                throw TypeError('n must be a positive number');
            this._maxListeners = n;
            return this;
        };

        EventEmitter.prototype.emit = function (type) {
            var er, handler, len, args, i, listeners;

            if (!this._events)
                this._events = {};

            // If there is no 'error' event listener then throw.
            if (type === 'error') {
                if (!this._events.error ||
                    (isObject(this._events.error) && !this._events.error.length)) {
                    er = arguments[1];
                    if (er instanceof Error) {
                        throw er; // Unhandled 'error' event
                    }
                    throw TypeError('Uncaught, unspecified "error" event.');
                }
            }

            handler = this._events[type];

            if (isUndefined(handler))
                return false;

            if (isFunction(handler)) {
                switch (arguments.length) {
                    // fast cases
                    case 1:
                        handler.call(this);
                        break;
                    case 2:
                        handler.call(this, arguments[1]);
                        break;
                    case 3:
                        handler.call(this, arguments[1], arguments[2]);
                        break;
                    // slower
                    default:
                        args = Array.prototype.slice.call(arguments, 1);
                        handler.apply(this, args);
                }
            } else if (isObject(handler)) {
                args = Array.prototype.slice.call(arguments, 1);
                listeners = handler.slice();
                len = listeners.length;
                for (i = 0; i < len; i++)
                    listeners[i].apply(this, args);
            }

            return true;
        };

        EventEmitter.prototype.addListener = function (type, listener) {
            var m;

            if (!isFunction(listener))
                throw TypeError('listener must be a function');

            if (!this._events)
                this._events = {};

            // To avoid recursion in the case that type === "newListener"! Before
            // adding it to the listeners, first emit "newListener".
            if (this._events.newListener)
                this.emit('newListener', type,
                    isFunction(listener.listener) ?
                        listener.listener : listener);

            if (!this._events[type])
            // Optimize the case of one listener. Don't need the extra array object.
                this._events[type] = listener;
            else if (isObject(this._events[type]))
            // If we've already got an array, just append.
                this._events[type].push(listener);
            else
            // Adding the second element, need to change to array.
                this._events[type] = [this._events[type], listener];

            // Check for listener leak
            if (isObject(this._events[type]) && !this._events[type].warned) {
                if (!isUndefined(this._maxListeners)) {
                    m = this._maxListeners;
                } else {
                    m = EventEmitter.defaultMaxListeners;
                }

                if (m && m > 0 && this._events[type].length > m) {
                    this._events[type].warned = true;
                    console.error('(node) warning: possible EventEmitter memory ' +
                        'leak detected. %d listeners added. ' +
                        'Use emitter.setMaxListeners() to increase limit.',
                        this._events[type].length);
                    if (typeof console.trace === 'function') {
                        // not supported in IE 10
                        console.trace();
                    }
                }
            }

            return this;
        };

        EventEmitter.prototype.on = EventEmitter.prototype.addListener;

        EventEmitter.prototype.once = function (type, listener) {
            if (!isFunction(listener))
                throw TypeError('listener must be a function');

            var fired = false;

            function g() {
                this.removeListener(type, g);

                if (!fired) {
                    fired = true;
                    listener.apply(this, arguments);
                }
            }

            g.listener = listener;
            this.on(type, g);

            return this;
        };

// emits a 'removeListener' event iff the listener was removed
        EventEmitter.prototype.removeListener = function (type, listener) {
            var list, position, length, i;

            if (!isFunction(listener))
                throw TypeError('listener must be a function');

            if (!this._events || !this._events[type])
                return this;

            list = this._events[type];
            length = list.length;
            position = -1;

            if (list === listener ||
                (isFunction(list.listener) && list.listener === listener)) {
                delete this._events[type];
                if (this._events.removeListener)
                    this.emit('removeListener', type, listener);

            } else if (isObject(list)) {
                for (i = length; i-- > 0;) {
                    if (list[i] === listener ||
                        (list[i].listener && list[i].listener === listener)) {
                        position = i;
                        break;
                    }
                }

                if (position < 0)
                    return this;

                if (list.length === 1) {
                    list.length = 0;
                    delete this._events[type];
                } else {
                    list.splice(position, 1);
                }

                if (this._events.removeListener)
                    this.emit('removeListener', type, listener);
            }

            return this;
        };

        EventEmitter.prototype.removeAllListeners = function (type) {
            var key, listeners;

            if (!this._events)
                return this;

            // not listening for removeListener, no need to emit
            if (!this._events.removeListener) {
                if (arguments.length === 0)
                    this._events = {};
                else if (this._events[type])
                    delete this._events[type];
                return this;
            }

            // emit removeListener for all listeners on all events
            if (arguments.length === 0) {
                for (key in this._events) {
                    if (key === 'removeListener') continue;
                    this.removeAllListeners(key);
                }
                this.removeAllListeners('removeListener');
                this._events = {};
                return this;
            }

            listeners = this._events[type];

            if (isFunction(listeners)) {
                this.removeListener(type, listeners);
            } else if (listeners) {
                // LIFO order
                while (listeners.length)
                    this.removeListener(type, listeners[listeners.length - 1]);
            }
            delete this._events[type];

            return this;
        };

        EventEmitter.prototype.listeners = function (type) {
            var ret;
            if (!this._events || !this._events[type])
                ret = [];
            else if (isFunction(this._events[type]))
                ret = [this._events[type]];
            else
                ret = this._events[type].slice();
            return ret;
        };

        EventEmitter.prototype.listenerCount = function (type) {
            if (this._events) {
                var evlistener = this._events[type];

                if (isFunction(evlistener))
                    return 1;
                else if (evlistener)
                    return evlistener.length;
            }
            return 0;
        };

        EventEmitter.listenerCount = function (emitter, type) {
            return emitter.listenerCount(type);
        };

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

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

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

        function isUndefined(arg) {
            return arg === void 0;
        }

    }, {}],
    41: [function (require, module, exports) {
        if (typeof Object.create === 'function') {
            // implementation from standard node.js 'util' module
            module.exports = function inherits(ctor, superCtor) {
                ctor.super_ = superCtor
                ctor.prototype = Object.create(superCtor.prototype, {
                    constructor: {
                        value: ctor,
                        enumerable: false,
                        writable: true,
                        configurable: true
                    }
                });
            };
        } else {
            // old school shim for old browsers
            module.exports = function inherits(ctor, superCtor) {
                ctor.super_ = superCtor
                var TempCtor = function () {
                }
                TempCtor.prototype = superCtor.prototype
                ctor.prototype = new TempCtor()
                ctor.prototype.constructor = ctor
            }
        }

    }, {}],
    42: [function (require, module, exports) {
        /**
         * Determine if an object is Buffer
         *
         * Author:   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
         * License:  MIT
         *
         * `npm install is-buffer`
         */

        module.exports = function (obj) {
            return !!(obj != null &&
                (obj._isBuffer || // For Safari 5-7 (missing Object.prototype.constructor)
                    (obj.constructor &&
                        typeof obj.constructor.isBuffer === 'function' &&
                        obj.constructor.isBuffer(obj))
                ))
        }

    }, {}],
    43: [function (require, module, exports) {
// shim for using process in browser

        var process = module.exports = {};
        var queue = [];
        var draining = false;
        var currentQueue;
        var queueIndex = -1;

        function cleanUpNextTick() {
            draining = false;
            if (currentQueue.length) {
                queue = currentQueue.concat(queue);
            } else {
                queueIndex = -1;
            }
            if (queue.length) {
                drainQueue();
            }
        }

        function drainQueue() {
            if (draining) {
                return;
            }
            var timeout = setTimeout(cleanUpNextTick);
            draining = true;

            var len = queue.length;
            while (len) {
                currentQueue = queue;
                queue = [];
                while (++queueIndex < len) {
                    if (currentQueue) {
                        currentQueue[queueIndex].run();
                    }
                }
                queueIndex = -1;
                len = queue.length;
            }
            currentQueue = null;
            draining = false;
            clearTimeout(timeout);
        }

        process.nextTick = function (fun) {
            var args = new Array(arguments.length - 1);
            if (arguments.length > 1) {
                for (var i = 1; i < arguments.length; i++) {
                    args[i - 1] = arguments[i];
                }
            }
            queue.push(new Item(fun, args));
            if (queue.length === 1 && !draining) {
                setTimeout(drainQueue, 0);
            }
        };

// v8 likes predictible objects
        function Item(fun, array) {
            this.fun = fun;
            this.array = array;
        }

        Item.prototype.run = function () {
            this.fun.apply(null, this.array);
        };
        process.title = 'browser';
        process.browser = true;
        process.env = {};
        process.argv = [];
        process.version = ''; // empty string to avoid regexp issues
        process.versions = {};

        function noop() {
        }

        process.on = noop;
        process.addListener = noop;
        process.once = noop;
        process.off = noop;
        process.removeListener = noop;
        process.removeAllListeners = noop;
        process.emit = noop;

        process.binding = function (name) {
            throw new Error('process.binding is not supported');
        };

        process.cwd = function () {
            return '/'
        };
        process.chdir = function (dir) {
            throw new Error('process.chdir is not supported');
        };
        process.umask = function () {
            return 0;
        };

    }, {}],
    44: [function (require, module, exports) {
        module.exports = require("./lib/_stream_duplex.js")

    }, {"./lib/_stream_duplex.js": 45}],
    45: [function (require, module, exports) {
// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.

        'use strict';

        /*<replacement>*/

        var objectKeys = Object.keys || function (obj) {
            var keys = [];
            for (var key in obj) {
                keys.push(key);
            }
            return keys;
        };
        /*</replacement>*/

        module.exports = Duplex;

        /*<replacement>*/
        var processNextTick = require('process-nextick-args');
        /*</replacement>*/

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        var Readable = require('./_stream_readable');
        var Writable = require('./_stream_writable');

        util.inherits(Duplex, Readable);

        var keys = objectKeys(Writable.prototype);
        for (var v = 0; v < keys.length; v++) {
            var method = keys[v];
            if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
        }

        function Duplex(options) {
            if (!(this instanceof Duplex)) return new Duplex(options);

            Readable.call(this, options);
            Writable.call(this, options);

            if (options && options.readable === false) this.readable = false;

            if (options && options.writable === false) this.writable = false;

            this.allowHalfOpen = true;
            if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;

            this.once('end', onend);
        }

// the no-half-open enforcer
        function onend() {
            // if we allow half-open state, or if the writable side ended,
            // then we're ok.
            if (this.allowHalfOpen || this._writableState.ended) return;

            // no more data can be written.
            // But allow more writes to happen in this tick.
            processNextTick(onEndNT, this);
        }

        function onEndNT(self) {
            self.end();
        }

        function forEach(xs, f) {
            for (var i = 0, l = xs.length; i < l; i++) {
                f(xs[i], i);
            }
        }
    }, {
        "./_stream_readable": 47,
        "./_stream_writable": 49,
        "core-util-is": 50,
        "inherits": 41,
        "process-nextick-args": 52
    }],
    46: [function (require, module, exports) {
// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.

        'use strict';

        module.exports = PassThrough;

        var Transform = require('./_stream_transform');

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        util.inherits(PassThrough, Transform);

        function PassThrough(options) {
            if (!(this instanceof PassThrough)) return new PassThrough(options);

            Transform.call(this, options);
        }

        PassThrough.prototype._transform = function (chunk, encoding, cb) {
            cb(null, chunk);
        };
    }, {"./_stream_transform": 48, "core-util-is": 50, "inherits": 41}],
    47: [function (require, module, exports) {
        (function (process) {
            'use strict';

            module.exports = Readable;

            /*<replacement>*/
            var processNextTick = require('process-nextick-args');
            /*</replacement>*/

            /*<replacement>*/
            var isArray = require('isarray');
            /*</replacement>*/

            /*<replacement>*/
            var Buffer = require('buffer').Buffer;
            /*</replacement>*/

            Readable.ReadableState = ReadableState;

            var EE = require('events');

            /*<replacement>*/
            var EElistenerCount = function (emitter, type) {
                return emitter.listeners(type).length;
            };
            /*</replacement>*/

            /*<replacement>*/
            var Stream;
            (function () {
                try {
                    Stream = require('st' + 'ream');
                } catch (_) {
                } finally {
                    if (!Stream) Stream = require('events').EventEmitter;
                }
            })();
            /*</replacement>*/

            var Buffer = require('buffer').Buffer;

            /*<replacement>*/
            var util = require('core-util-is');
            util.inherits = require('inherits');
            /*</replacement>*/

            /*<replacement>*/
            var debugUtil = require('util');
            var debug = undefined;
            if (debugUtil && debugUtil.debuglog) {
                debug = debugUtil.debuglog('stream');
            } else {
                debug = function () {
                };
            }
            /*</replacement>*/

            var StringDecoder;

            util.inherits(Readable, Stream);

            var Duplex;

            function ReadableState(options, stream) {
                Duplex = Duplex || require('./_stream_duplex');

                options = options || {};

                // object stream flag. Used to make read(n) ignore n and to
                // make all the buffer merging and length checks go away
                this.objectMode = !!options.objectMode;

                if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;

                // the point at which it stops calling _read() to fill the buffer
                // Note: 0 is a valid value, means "don't call _read preemptively ever"
                var hwm = options.highWaterMark;
                var defaultHwm = this.objectMode ? 16 : 16 * 1024;
                this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;

                // cast to ints.
                this.highWaterMark = ~~this.highWaterMark;

                this.buffer = [];
                this.length = 0;
                this.pipes = null;
                this.pipesCount = 0;
                this.flowing = null;
                this.ended = false;
                this.endEmitted = false;
                this.reading = false;

                // a flag to be able to tell if the onwrite cb is called immediately,
                // or on a later tick.  We set this to true at first, because any
                // actions that shouldn't happen until "later" should generally also
                // not happen before the first write call.
                this.sync = true;

                // whenever we return null, then we set a flag to say
                // that we're awaiting a 'readable' event emission.
                this.needReadable = false;
                this.emittedReadable = false;
                this.readableListening = false;
                this.resumeScheduled = false;

                // Crypto is kind of old and crusty.  Historically, its default string
                // encoding is 'binary' so we have to make this configurable.
                // Everything else in the universe uses 'utf8', though.
                this.defaultEncoding = options.defaultEncoding || 'utf8';

                // when piping, we only care about 'readable' events that happen
                // after read()ing all the bytes and not getting any pushback.
                this.ranOut = false;

                // the number of writers that are awaiting a drain event in .pipe()s
                this.awaitDrain = 0;

                // if true, a maybeReadMore has been scheduled
                this.readingMore = false;

                this.decoder = null;
                this.encoding = null;
                if (options.encoding) {
                    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
                    this.decoder = new StringDecoder(options.encoding);
                    this.encoding = options.encoding;
                }
            }

            var Duplex;

            function Readable(options) {
                Duplex = Duplex || require('./_stream_duplex');

                if (!(this instanceof Readable)) return new Readable(options);

                this._readableState = new ReadableState(options, this);

                // legacy
                this.readable = true;

                if (options && typeof options.read === 'function') this._read = options.read;

                Stream.call(this);
            }

// Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
            Readable.prototype.push = function (chunk, encoding) {
                var state = this._readableState;

                if (!state.objectMode && typeof chunk === 'string') {
                    encoding = encoding || state.defaultEncoding;
                    if (encoding !== state.encoding) {
                        chunk = new Buffer(chunk, encoding);
                        encoding = '';
                    }
                }

                return readableAddChunk(this, state, chunk, encoding, false);
            };

// Unshift should *always* be something directly out of read()
            Readable.prototype.unshift = function (chunk) {
                var state = this._readableState;
                return readableAddChunk(this, state, chunk, '', true);
            };

            Readable.prototype.isPaused = function () {
                return this._readableState.flowing === false;
            };

            function readableAddChunk(stream, state, chunk, encoding, addToFront) {
                var er = chunkInvalid(state, chunk);
                if (er) {
                    stream.emit('error', er);
                } else if (chunk === null) {
                    state.reading = false;
                    onEofChunk(stream, state);
                } else if (state.objectMode || chunk && chunk.length > 0) {
                    if (state.ended && !addToFront) {
                        var e = new Error('stream.push() after EOF');
                        stream.emit('error', e);
                    } else if (state.endEmitted && addToFront) {
                        var e = new Error('stream.unshift() after end event');
                        stream.emit('error', e);
                    } else {
                        var skipAdd;
                        if (state.decoder && !addToFront && !encoding) {
                            chunk = state.decoder.write(chunk);
                            skipAdd = !state.objectMode && chunk.length === 0;
                        }

                        if (!addToFront) state.reading = false;

                        // Don't add to the buffer if we've decoded to an empty string chunk and
                        // we're not in object mode
                        if (!skipAdd) {
                            // if we want the data now, just emit it.
                            if (state.flowing && state.length === 0 && !state.sync) {
                                stream.emit('data', chunk);
                                stream.read(0);
                            } else {
                                // update the buffer info.
                                state.length += state.objectMode ? 1 : chunk.length;
                                if (addToFront) state.buffer.unshift(chunk); else state.buffer.push(chunk);

                                if (state.needReadable) emitReadable(stream);
                            }
                        }

                        maybeReadMore(stream, state);
                    }
                } else if (!addToFront) {
                    state.reading = false;
                }

                return needMoreData(state);
            }

// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes.  This is to work around cases where hwm=0,
// such as the repl.  Also, if the push() triggered a
// readable event, and the user called read(largeNumber) such that
// needReadable was set, then we ought to push more, so that another
// 'readable' event will be triggered.
            function needMoreData(state) {
                return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
            }

// backwards compatibility.
            Readable.prototype.setEncoding = function (enc) {
                if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
                this._readableState.decoder = new StringDecoder(enc);
                this._readableState.encoding = enc;
                return this;
            };

// Don't raise the hwm > 8MB
            var MAX_HWM = 0x800000;

            function computeNewHighWaterMark(n) {
                if (n >= MAX_HWM) {
                    n = MAX_HWM;
                } else {
                    // Get the next highest power of 2
                    n--;
                    n |= n >>> 1;
                    n |= n >>> 2;
                    n |= n >>> 4;
                    n |= n >>> 8;
                    n |= n >>> 16;
                    n++;
                }
                return n;
            }

            function howMuchToRead(n, state) {
                if (state.length === 0 && state.ended) return 0;

                if (state.objectMode) return n === 0 ? 0 : 1;

                if (n === null || isNaN(n)) {
                    // only flow one buffer at a time
                    if (state.flowing && state.buffer.length) return state.buffer[0].length; else return state.length;
                }

                if (n <= 0) return 0;

                // If we're asking for more than the target buffer level,
                // then raise the water mark.  Bump up to the next highest
                // power of 2, to prevent increasing it excessively in tiny
                // amounts.
                if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);

                // don't have that much.  return null, unless we've ended.
                if (n > state.length) {
                    if (!state.ended) {
                        state.needReadable = true;
                        return 0;
                    } else {
                        return state.length;
                    }
                }

                return n;
            }

// you can override either this method, or the async _read(n) below.
            Readable.prototype.read = function (n) {
                debug('read', n);
                var state = this._readableState;
                var nOrig = n;

                if (typeof n !== 'number' || n > 0) state.emittedReadable = false;

                // if we're doing read(0) to trigger a readable event, but we
                // already have a bunch of data in the buffer, then just trigger
                // the 'readable' event and move on.
                if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
                    debug('read: emitReadable', state.length, state.ended);
                    if (state.length === 0 && state.ended) endReadable(this); else emitReadable(this);
                    return null;
                }

                n = howMuchToRead(n, state);

                // if we've ended, and we're now clear, then finish it up.
                if (n === 0 && state.ended) {
                    if (state.length === 0) endReadable(this);
                    return null;
                }

                // All the actual chunk generation logic needs to be
                // *below* the call to _read.  The reason is that in certain
                // synthetic stream cases, such as passthrough streams, _read
                // may be a completely synchronous operation which may change
                // the state of the read buffer, providing enough data when
                // before there was *not* enough.
                //
                // So, the steps are:
                // 1. Figure out what the state of things will be after we do
                // a read from the buffer.
                //
                // 2. If that resulting state will trigger a _read, then call _read.
                // Note that this may be asynchronous, or synchronous.  Yes, it is
                // deeply ugly to write APIs this way, but that still doesn't mean
                // that the Readable class should behave improperly, as streams are
                // designed to be sync/async agnostic.
                // Take note if the _read call is sync or async (ie, if the read call
                // has returned yet), so that we know whether or not it's safe to emit
                // 'readable' etc.
                //
                // 3. Actually pull the requested chunks out of the buffer and return.

                // if we need a readable event, then we need to do some reading.
                var doRead = state.needReadable;
                debug('need readable', doRead);

                // if we currently have less than the highWaterMark, then also read some
                if (state.length === 0 || state.length - n < state.highWaterMark) {
                    doRead = true;
                    debug('length less than watermark', doRead);
                }

                // however, if we've ended, then there's no point, and if we're already
                // reading, then it's unnecessary.
                if (state.ended || state.reading) {
                    doRead = false;
                    debug('reading or ended', doRead);
                }

                if (doRead) {
                    debug('do read');
                    state.reading = true;
                    state.sync = true;
                    // if the length is currently zero, then we *need* a readable event.
                    if (state.length === 0) state.needReadable = true;
                    // call internal read method
                    this._read(state.highWaterMark);
                    state.sync = false;
                }

                // If _read pushed data synchronously, then `reading` will be false,
                // and we need to re-evaluate how much data we can return to the user.
                if (doRead && !state.reading) n = howMuchToRead(nOrig, state);

                var ret;
                if (n > 0) ret = fromList(n, state); else ret = null;

                if (ret === null) {
                    state.needReadable = true;
                    n = 0;
                }

                state.length -= n;

                // If we have nothing in the buffer, then we want to know
                // as soon as we *do* get something into the buffer.
                if (state.length === 0 && !state.ended) state.needReadable = true;

                // If we tried to read() past the EOF, then emit end on the next tick.
                if (nOrig !== n && state.ended && state.length === 0) endReadable(this);

                if (ret !== null) this.emit('data', ret);

                return ret;
            };

            function chunkInvalid(state, chunk) {
                var er = null;
                if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
                    er = new TypeError('Invalid non-string/buffer chunk');
                }
                return er;
            }

            function onEofChunk(stream, state) {
                if (state.ended) return;
                if (state.decoder) {
                    var chunk = state.decoder.end();
                    if (chunk && chunk.length) {
                        state.buffer.push(chunk);
                        state.length += state.objectMode ? 1 : chunk.length;
                    }
                }
                state.ended = true;

                // emit 'readable' now to make sure it gets picked up.
                emitReadable(stream);
            }

// Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow.  This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
            function emitReadable(stream) {
                var state = stream._readableState;
                state.needReadable = false;
                if (!state.emittedReadable) {
                    debug('emitReadable', state.flowing);
                    state.emittedReadable = true;
                    if (state.sync) processNextTick(emitReadable_, stream); else emitReadable_(stream);
                }
            }

            function emitReadable_(stream) {
                debug('emit readable');
                stream.emit('readable');
                flow(stream);
            }

// at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data.  that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
            function maybeReadMore(stream, state) {
                if (!state.readingMore) {
                    state.readingMore = true;
                    processNextTick(maybeReadMore_, stream, state);
                }
            }

            function maybeReadMore_(stream, state) {
                var len = state.length;
                while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
                    debug('maybeReadMore read 0');
                    stream.read(0);
                    if (len === state.length)
                    // didn't get any data, stop spinning.
                        break; else len = state.length;
                }
                state.readingMore = false;
            }

// abstract method.  to be overridden in specific implementation classes.
// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
            Readable.prototype._read = function (n) {
                this.emit('error', new Error('not implemented'));
            };

            Readable.prototype.pipe = function (dest, pipeOpts) {
                var src = this;
                var state = this._readableState;

                switch (state.pipesCount) {
                    case 0:
                        state.pipes = dest;
                        break;
                    case 1:
                        state.pipes = [state.pipes, dest];
                        break;
                    default:
                        state.pipes.push(dest);
                        break;
                }
                state.pipesCount += 1;
                debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);

                var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;

                var endFn = doEnd ? onend : cleanup;
                if (state.endEmitted) processNextTick(endFn); else src.once('end', endFn);

                dest.on('unpipe', onunpipe);

                function onunpipe(readable) {
                    debug('onunpipe');
                    if (readable === src) {
                        cleanup();
                    }
                }

                function onend() {
                    debug('onend');
                    dest.end();
                }

                // when the dest drains, it reduces the awaitDrain counter
                // on the source.  This would be more elegant with a .once()
                // handler in flow(), but adding and removing repeatedly is
                // too slow.
                var ondrain = pipeOnDrain(src);
                dest.on('drain', ondrain);

                var cleanedUp = false;

                function cleanup() {
                    debug('cleanup');
                    // cleanup event handlers once the pipe is broken
                    dest.removeListener('close', onclose);
                    dest.removeListener('finish', onfinish);
                    dest.removeListener('drain', ondrain);
                    dest.removeListener('error', onerror);
                    dest.removeListener('unpipe', onunpipe);
                    src.removeListener('end', onend);
                    src.removeListener('end', cleanup);
                    src.removeListener('data', ondata);

                    cleanedUp = true;

                    // if the reader is waiting for a drain event from this
                    // specific writer, then it would cause it to never start
                    // flowing again.
                    // So, if this is awaiting a drain, then we just call it now.
                    // If we don't know, then assume that we are waiting for one.
                    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
                }

                src.on('data', ondata);

                function ondata(chunk) {
                    debug('ondata');
                    var ret = dest.write(chunk);
                    if (false === ret) {
                        // If the user unpiped during `dest.write()`, it is possible
                        // to get stuck in a permanently paused state if that write
                        // also returned false.
                        if (state.pipesCount === 1 && state.pipes[0] === dest && src.listenerCount('data') === 1 && !cleanedUp) {
                            debug('false write response, pause', src._readableState.awaitDrain);
                            src._readableState.awaitDrain++;
                        }
                        src.pause();
                    }
                }

                // if the dest has an error, then stop piping into it.
                // however, don't suppress the throwing behavior for this.
                function onerror(er) {
                    debug('onerror', er);
                    unpipe();
                    dest.removeListener('error', onerror);
                    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
                }

                // This is a brutally ugly hack to make sure that our error handler
                // is attached before any userland ones.  NEVER DO THIS.
                if (!dest._events || !dest._events.error) dest.on('error', onerror); else if (isArray(dest._events.error)) dest._events.error.unshift(onerror); else dest._events.error = [onerror, dest._events.error];

                // Both close and finish should trigger unpipe, but only once.
                function onclose() {
                    dest.removeListener('finish', onfinish);
                    unpipe();
                }

                dest.once('close', onclose);

                function onfinish() {
                    debug('onfinish');
                    dest.removeListener('close', onclose);
                    unpipe();
                }

                dest.once('finish', onfinish);

                function unpipe() {
                    debug('unpipe');
                    src.unpipe(dest);
                }

                // tell the dest that it's being piped to
                dest.emit('pipe', src);

                // start the flow if it hasn't been started already.
                if (!state.flowing) {
                    debug('pipe resume');
                    src.resume();
                }

                return dest;
            };

            function pipeOnDrain(src) {
                return function () {
                    var state = src._readableState;
                    debug('pipeOnDrain', state.awaitDrain);
                    if (state.awaitDrain) state.awaitDrain--;
                    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
                        state.flowing = true;
                        flow(src);
                    }
                };
            }

            Readable.prototype.unpipe = function (dest) {
                var state = this._readableState;

                // if we're not piping anywhere, then do nothing.
                if (state.pipesCount === 0) return this;

                // just one destination.  most common case.
                if (state.pipesCount === 1) {
                    // passed in one, but it's not the right one.
                    if (dest && dest !== state.pipes) return this;

                    if (!dest) dest = state.pipes;

                    // got a match.
                    state.pipes = null;
                    state.pipesCount = 0;
                    state.flowing = false;
                    if (dest) dest.emit('unpipe', this);
                    return this;
                }

                // slow case. multiple pipe destinations.

                if (!dest) {
                    // remove all.
                    var dests = state.pipes;
                    var len = state.pipesCount;
                    state.pipes = null;
                    state.pipesCount = 0;
                    state.flowing = false;

                    for (var _i = 0; _i < len; _i++) {
                        dests[_i].emit('unpipe', this);
                    }
                    return this;
                }

                // try to find the right one.
                var i = indexOf(state.pipes, dest);
                if (i === -1) return this;

                state.pipes.splice(i, 1);
                state.pipesCount -= 1;
                if (state.pipesCount === 1) state.pipes = state.pipes[0];

                dest.emit('unpipe', this);

                return this;
            };

// set up data events if they are asked for
// Ensure readable listeners eventually get something
            Readable.prototype.on = function (ev, fn) {
                var res = Stream.prototype.on.call(this, ev, fn);

                // If listening to data, and it has not explicitly been paused,
                // then call resume to start the flow of data on the next tick.
                if (ev === 'data' && false !== this._readableState.flowing) {
                    this.resume();
                }

                if (ev === 'readable' && !this._readableState.endEmitted) {
                    var state = this._readableState;
                    if (!state.readableListening) {
                        state.readableListening = true;
                        state.emittedReadable = false;
                        state.needReadable = true;
                        if (!state.reading) {
                            processNextTick(nReadingNextTick, this);
                        } else if (state.length) {
                            emitReadable(this, state);
                        }
                    }
                }

                return res;
            };
            Readable.prototype.addListener = Readable.prototype.on;

            function nReadingNextTick(self) {
                debug('readable nexttick read 0');
                self.read(0);
            }

// pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
            Readable.prototype.resume = function () {
                var state = this._readableState;
                if (!state.flowing) {
                    debug('resume');
                    state.flowing = true;
                    resume(this, state);
                }
                return this;
            };

            function resume(stream, state) {
                if (!state.resumeScheduled) {
                    state.resumeScheduled = true;
                    processNextTick(resume_, stream, state);
                }
            }

            function resume_(stream, state) {
                if (!state.reading) {
                    debug('resume read 0');
                    stream.read(0);
                }

                state.resumeScheduled = false;
                stream.emit('resume');
                flow(stream);
                if (state.flowing && !state.reading) stream.read(0);
            }

            Readable.prototype.pause = function () {
                debug('call pause flowing=%j', this._readableState.flowing);
                if (false !== this._readableState.flowing) {
                    debug('pause');
                    this._readableState.flowing = false;
                    this.emit('pause');
                }
                return this;
            };

            function flow(stream) {
                var state = stream._readableState;
                debug('flow', state.flowing);
                if (state.flowing) {
                    do {
                        var chunk = stream.read();
                    } while (null !== chunk && state.flowing);
                }
            }

// wrap an old-style stream as the async data source.
// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
            Readable.prototype.wrap = function (stream) {
                var state = this._readableState;
                var paused = false;

                var self = this;
                stream.on('end', function () {
                    debug('wrapped end');
                    if (state.decoder && !state.ended) {
                        var chunk = state.decoder.end();
                        if (chunk && chunk.length) self.push(chunk);
                    }

                    self.push(null);
                });

                stream.on('data', function (chunk) {
                    debug('wrapped data');
                    if (state.decoder) chunk = state.decoder.write(chunk);

                    // don't skip over falsy values in objectMode
                    if (state.objectMode && (chunk === null || chunk === undefined)) return; else if (!state.objectMode && (!chunk || !chunk.length)) return;

                    var ret = self.push(chunk);
                    if (!ret) {
                        paused = true;
                        stream.pause();
                    }
                });

                // proxy all the other methods.
                // important when wrapping filters and duplexes.
                for (var i in stream) {
                    if (this[i] === undefined && typeof stream[i] === 'function') {
                        this[i] = function (method) {
                            return function () {
                                return stream[method].apply(stream, arguments);
                            };
                        }(i);
                    }
                }

                // proxy certain important events.
                var events = ['error', 'close', 'destroy', 'pause', 'resume'];
                forEach(events, function (ev) {
                    stream.on(ev, self.emit.bind(self, ev));
                });

                // when we try to consume some more bytes, simply unpause the
                // underlying stream.
                self._read = function (n) {
                    debug('wrapped _read', n);
                    if (paused) {
                        paused = false;
                        stream.resume();
                    }
                };

                return self;
            };

// exposed for testing purposes only.
            Readable._fromList = fromList;

// Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
            function fromList(n, state) {
                var list = state.buffer;
                var length = state.length;
                var stringMode = !!state.decoder;
                var objectMode = !!state.objectMode;
                var ret;

                // nothing in the list, definitely empty.
                if (list.length === 0) return null;

                if (length === 0) ret = null; else if (objectMode) ret = list.shift(); else if (!n || n >= length) {
                    // read it all, truncate the array.
                    if (stringMode) ret = list.join(''); else if (list.length === 1) ret = list[0]; else ret = Buffer.concat(list, length);
                    list.length = 0;
                } else {
                    // read just some of it.
                    if (n < list[0].length) {
                        // just take a part of the first list item.
                        // slice is the same for buffers and strings.
                        var buf = list[0];
                        ret = buf.slice(0, n);
                        list[0] = buf.slice(n);
                    } else if (n === list[0].length) {
                        // first list is a perfect match
                        ret = list.shift();
                    } else {
                        // complex case.
                        // we have enough to cover it, but it spans past the first buffer.
                        if (stringMode) ret = ''; else ret = new Buffer(n);

                        var c = 0;
                        for (var i = 0, l = list.length; i < l && c < n; i++) {
                            var buf = list[0];
                            var cpy = Math.min(n - c, buf.length);

                            if (stringMode) ret += buf.slice(0, cpy); else buf.copy(ret, c, 0, cpy);

                            if (cpy < buf.length) list[0] = buf.slice(cpy); else list.shift();

                            c += cpy;
                        }
                    }
                }

                return ret;
            }

            function endReadable(stream) {
                var state = stream._readableState;

                // If we get here before consuming all the bytes, then that is a
                // bug in node.  Should never happen.
                if (state.length > 0) throw new Error('endReadable called on non-empty stream');

                if (!state.endEmitted) {
                    state.ended = true;
                    processNextTick(endReadableNT, state, stream);
                }
            }

            function endReadableNT(state, stream) {
                // Check that we didn't get one last unshift.
                if (!state.endEmitted && state.length === 0) {
                    state.endEmitted = true;
                    stream.readable = false;
                    stream.emit('end');
                }
            }

            function forEach(xs, f) {
                for (var i = 0, l = xs.length; i < l; i++) {
                    f(xs[i], i);
                }
            }

            function indexOf(xs, x) {
                for (var i = 0, l = xs.length; i < l; i++) {
                    if (xs[i] === x) return i;
                }
                return -1;
            }
        }).call(this, require('_process'))
    }, {
        "./_stream_duplex": 45,
        "_process": 43,
        "buffer": 36,
        "core-util-is": 50,
        "events": 40,
        "inherits": 41,
        "isarray": 51,
        "process-nextick-args": 52,
        "string_decoder/": 59,
        "util": 35
    }],
    48: [function (require, module, exports) {
// a transform stream is a readable/writable stream where you do
// something with the data.  Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored.  (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation.  For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes.  When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up.  When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer.  When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks.  If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk.  However,
// a pathological inflate type of transform can cause excessive buffering
// here.  For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output.  In this case, you could write a very small
// amount of input, and end up with a very large amount of output.  In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform.  A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.

        'use strict';

        module.exports = Transform;

        var Duplex = require('./_stream_duplex');

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        util.inherits(Transform, Duplex);

        function TransformState(stream) {
            this.afterTransform = function (er, data) {
                return afterTransform(stream, er, data);
            };

            this.needTransform = false;
            this.transforming = false;
            this.writecb = null;
            this.writechunk = null;
            this.writeencoding = null;
        }

        function afterTransform(stream, er, data) {
            var ts = stream._transformState;
            ts.transforming = false;

            var cb = ts.writecb;

            if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));

            ts.writechunk = null;
            ts.writecb = null;

            if (data !== null && data !== undefined) stream.push(data);

            cb(er);

            var rs = stream._readableState;
            rs.reading = false;
            if (rs.needReadable || rs.length < rs.highWaterMark) {
                stream._read(rs.highWaterMark);
            }
        }

        function Transform(options) {
            if (!(this instanceof Transform)) return new Transform(options);

            Duplex.call(this, options);

            this._transformState = new TransformState(this);

            // when the writable side finishes, then flush out anything remaining.
            var stream = this;

            // start out asking for a readable event once data is transformed.
            this._readableState.needReadable = true;

            // we have implemented the _read method, and done the other things
            // that Readable wants before the first _read call, so unset the
            // sync guard flag.
            this._readableState.sync = false;

            if (options) {
                if (typeof options.transform === 'function') this._transform = options.transform;

                if (typeof options.flush === 'function') this._flush = options.flush;
            }

            this.once('prefinish', function () {
                if (typeof this._flush === 'function') this._flush(function (er) {
                    done(stream, er);
                }); else done(stream);
            });
        }

        Transform.prototype.push = function (chunk, encoding) {
            this._transformState.needTransform = false;
            return Duplex.prototype.push.call(this, chunk, encoding);
        };

// This is the part where you do stuff!
// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side.  You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk.  If you pass
// an error, then that'll put the hurt on the whole operation.  If you
// never call cb(), then you'll never get another chunk.
        Transform.prototype._transform = function (chunk, encoding, cb) {
            throw new Error('not implemented');
        };

        Transform.prototype._write = function (chunk, encoding, cb) {
            var ts = this._transformState;
            ts.writecb = cb;
            ts.writechunk = chunk;
            ts.writeencoding = encoding;
            if (!ts.transforming) {
                var rs = this._readableState;
                if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
            }
        };

// Doesn't matter what the args are here.
// _transform does all the work.
// That we got here means that the readable side wants more data.
        Transform.prototype._read = function (n) {
            var ts = this._transformState;

            if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
                ts.transforming = true;
                this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
            } else {
                // mark that we need a transform, so that any data that comes in
                // will get processed, now that we've asked for it.
                ts.needTransform = true;
            }
        };

        function done(stream, er) {
            if (er) return stream.emit('error', er);

            // if there's nothing in the write buffer, then that means
            // that nothing more will ever be provided
            var ws = stream._writableState;
            var ts = stream._transformState;

            if (ws.length) throw new Error('calling transform done when ws.length != 0');

            if (ts.transforming) throw new Error('calling transform done when still transforming');

            return stream.push(null);
        }
    }, {"./_stream_duplex": 45, "core-util-is": 50, "inherits": 41}],
    49: [function (require, module, exports) {
        (function (process) {
// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.

            'use strict';

            module.exports = Writable;

            /*<replacement>*/
            var processNextTick = require('process-nextick-args');
            /*</replacement>*/

            /*<replacement>*/
            var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;
            /*</replacement>*/

            /*<replacement>*/
            var Buffer = require('buffer').Buffer;
            /*</replacement>*/

            Writable.WritableState = WritableState;

            /*<replacement>*/
            var util = require('core-util-is');
            util.inherits = require('inherits');
            /*</replacement>*/

            /*<replacement>*/
            var internalUtil = {
                deprecate: require('util-deprecate')
            };
            /*</replacement>*/

            /*<replacement>*/
            var Stream;
            (function () {
                try {
                    Stream = require('st' + 'ream');
                } catch (_) {
                } finally {
                    if (!Stream) Stream = require('events').EventEmitter;
                }
            })();
            /*</replacement>*/

            var Buffer = require('buffer').Buffer;

            util.inherits(Writable, Stream);

            function nop() {
            }

            function WriteReq(chunk, encoding, cb) {
                this.chunk = chunk;
                this.encoding = encoding;
                this.callback = cb;
                this.next = null;
            }

            var Duplex;

            function WritableState(options, stream) {
                Duplex = Duplex || require('./_stream_duplex');

                options = options || {};

                // object stream flag to indicate whether or not this stream
                // contains buffers or objects.
                this.objectMode = !!options.objectMode;

                if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;

                // the point at which write() starts returning false
                // Note: 0 is a valid value, means that we always return false if
                // the entire buffer is not flushed immediately on write()
                var hwm = options.highWaterMark;
                var defaultHwm = this.objectMode ? 16 : 16 * 1024;
                this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;

                // cast to ints.
                this.highWaterMark = ~~this.highWaterMark;

                this.needDrain = false;
                // at the start of calling end()
                this.ending = false;
                // when end() has been called, and returned
                this.ended = false;
                // when 'finish' is emitted
                this.finished = false;

                // should we decode strings into buffers before passing to _write?
                // this is here so that some node-core streams can optimize string
                // handling at a lower level.
                var noDecode = options.decodeStrings === false;
                this.decodeStrings = !noDecode;

                // Crypto is kind of old and crusty.  Historically, its default string
                // encoding is 'binary' so we have to make this configurable.
                // Everything else in the universe uses 'utf8', though.
                this.defaultEncoding = options.defaultEncoding || 'utf8';

                // not an actual buffer we keep track of, but a measurement
                // of how much we're waiting to get pushed to some underlying
                // socket or file.
                this.length = 0;

                // a flag to see when we're in the middle of a write.
                this.writing = false;

                // when true all writes will be buffered until .uncork() call
                this.corked = 0;

                // a flag to be able to tell if the onwrite cb is called immediately,
                // or on a later tick.  We set this to true at first, because any
                // actions that shouldn't happen until "later" should generally also
                // not happen before the first write call.
                this.sync = true;

                // a flag to know if we're processing previously buffered items, which
                // may call the _write() callback in the same tick, so that we don't
                // end up in an overlapped onwrite situation.
                this.bufferProcessing = false;

                // the callback that's passed to _write(chunk,cb)
                this.onwrite = function (er) {
                    onwrite(stream, er);
                };

                // the callback that the user supplies to write(chunk,encoding,cb)
                this.writecb = null;

                // the amount that is being written when _write is called.
                this.writelen = 0;

                this.bufferedRequest = null;
                this.lastBufferedRequest = null;

                // number of pending user-supplied write callbacks
                // this must be 0 before 'finish' can be emitted
                this.pendingcb = 0;

                // emit prefinish if the only thing we're waiting for is _write cbs
                // This is relevant for synchronous Transform streams
                this.prefinished = false;

                // True if the error was already emitted and should not be thrown again
                this.errorEmitted = false;

                // count buffered requests
                this.bufferedRequestCount = 0;

                // create the two objects needed to store the corked requests
                // they are not a linked list, as no new elements are inserted in there
                this.corkedRequestsFree = new CorkedRequest(this);
                this.corkedRequestsFree.next = new CorkedRequest(this);
            }

            WritableState.prototype.getBuffer = function writableStateGetBuffer() {
                var current = this.bufferedRequest;
                var out = [];
                while (current) {
                    out.push(current);
                    current = current.next;
                }
                return out;
            };

            (function () {
                try {
                    Object.defineProperty(WritableState.prototype, 'buffer', {
                        get: internalUtil.deprecate(function () {
                            return this.getBuffer();
                        }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
                    });
                } catch (_) {
                }
            })();

            var Duplex;

            function Writable(options) {
                Duplex = Duplex || require('./_stream_duplex');

                // Writable ctor is applied to Duplexes, though they're not
                // instanceof Writable, they're instanceof Readable.
                if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options);

                this._writableState = new WritableState(options, this);

                // legacy.
                this.writable = true;

                if (options) {
                    if (typeof options.write === 'function') this._write = options.write;

                    if (typeof options.writev === 'function') this._writev = options.writev;
                }

                Stream.call(this);
            }

// Otherwise people can pipe Writable streams, which is just wrong.
            Writable.prototype.pipe = function () {
                this.emit('error', new Error('Cannot pipe. Not readable.'));
            };

            function writeAfterEnd(stream, cb) {
                var er = new Error('write after end');
                // TODO: defer error events consistently everywhere, not just the cb
                stream.emit('error', er);
                processNextTick(cb, er);
            }

// If we get something that is not a buffer, string, null, or undefined,
// and we're not in objectMode, then that's an error.
// Otherwise stream chunks are all considered to be of length=1, and the
// watermarks determine how many objects to keep in the buffer, rather than
// how many bytes or characters.
            function validChunk(stream, state, chunk, cb) {
                var valid = true;

                if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {
                    var er = new TypeError('Invalid non-string/buffer chunk');
                    stream.emit('error', er);
                    processNextTick(cb, er);
                    valid = false;
                }
                return valid;
            }

            Writable.prototype.write = function (chunk, encoding, cb) {
                var state = this._writableState;
                var ret = false;

                if (typeof encoding === 'function') {
                    cb = encoding;
                    encoding = null;
                }

                if (Buffer.isBuffer(chunk)) encoding = 'buffer'; else if (!encoding) encoding = state.defaultEncoding;

                if (typeof cb !== 'function') cb = nop;

                if (state.ended) writeAfterEnd(this, cb); else if (validChunk(this, state, chunk, cb)) {
                    state.pendingcb++;
                    ret = writeOrBuffer(this, state, chunk, encoding, cb);
                }

                return ret;
            };

            Writable.prototype.cork = function () {
                var state = this._writableState;

                state.corked++;
            };

            Writable.prototype.uncork = function () {
                var state = this._writableState;

                if (state.corked) {
                    state.corked--;

                    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
                }
            };

            Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
                // node::ParseEncoding() requires lower case.
                if (typeof encoding === 'string') encoding = encoding.toLowerCase();
                if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
                this._writableState.defaultEncoding = encoding;
            };

            function decodeChunk(state, chunk, encoding) {
                if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
                    chunk = new Buffer(chunk, encoding);
                }
                return chunk;
            }

// if we're already writing something, then just put this
// in the queue, and wait our turn.  Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
            function writeOrBuffer(stream, state, chunk, encoding, cb) {
                chunk = decodeChunk(state, chunk, encoding);

                if (Buffer.isBuffer(chunk)) encoding = 'buffer';
                var len = state.objectMode ? 1 : chunk.length;

                state.length += len;

                var ret = state.length < state.highWaterMark;
                // we must ensure that previous needDrain will not be reset to false.
                if (!ret) state.needDrain = true;

                if (state.writing || state.corked) {
                    var last = state.lastBufferedRequest;
                    state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
                    if (last) {
                        last.next = state.lastBufferedRequest;
                    } else {
                        state.bufferedRequest = state.lastBufferedRequest;
                    }
                    state.bufferedRequestCount += 1;
                } else {
                    doWrite(stream, state, false, len, chunk, encoding, cb);
                }

                return ret;
            }

            function doWrite(stream, state, writev, len, chunk, encoding, cb) {
                state.writelen = len;
                state.writecb = cb;
                state.writing = true;
                state.sync = true;
                if (writev) stream._writev(chunk, state.onwrite); else stream._write(chunk, encoding, state.onwrite);
                state.sync = false;
            }

            function onwriteError(stream, state, sync, er, cb) {
                --state.pendingcb;
                if (sync) processNextTick(cb, er); else cb(er);

                stream._writableState.errorEmitted = true;
                stream.emit('error', er);
            }

            function onwriteStateUpdate(state) {
                state.writing = false;
                state.writecb = null;
                state.length -= state.writelen;
                state.writelen = 0;
            }

            function onwrite(stream, er) {
                var state = stream._writableState;
                var sync = state.sync;
                var cb = state.writecb;

                onwriteStateUpdate(state);

                if (er) onwriteError(stream, state, sync, er, cb); else {
                    // Check if we're actually ready to finish, but don't emit yet
                    var finished = needFinish(state);

                    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
                        clearBuffer(stream, state);
                    }

                    if (sync) {
                        /*<replacement>*/
                        asyncWrite(afterWrite, stream, state, finished, cb);
                        /*</replacement>*/
                    } else {
                        afterWrite(stream, state, finished, cb);
                    }
                }
            }

            function afterWrite(stream, state, finished, cb) {
                if (!finished) onwriteDrain(stream, state);
                state.pendingcb--;
                cb();
                finishMaybe(stream, state);
            }

// Must force callback to be called on nextTick, so that we don't
// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
            function onwriteDrain(stream, state) {
                if (state.length === 0 && state.needDrain) {
                    state.needDrain = false;
                    stream.emit('drain');
                }
            }

// if there's something in the buffer waiting, then process it
            function clearBuffer(stream, state) {
                state.bufferProcessing = true;
                var entry = state.bufferedRequest;

                if (stream._writev && entry && entry.next) {
                    // Fast case, write everything using _writev()
                    var l = state.bufferedRequestCount;
                    var buffer = new Array(l);
                    var holder = state.corkedRequestsFree;
                    holder.entry = entry;

                    var count = 0;
                    while (entry) {
                        buffer[count] = entry;
                        entry = entry.next;
                        count += 1;
                    }

                    doWrite(stream, state, true, state.length, buffer, '', holder.finish);

                    // doWrite is always async, defer these to save a bit of time
                    // as the hot path ends with doWrite
                    state.pendingcb++;
                    state.lastBufferedRequest = null;
                    state.corkedRequestsFree = holder.next;
                    holder.next = null;
                } else {
                    // Slow case, write chunks one-by-one
                    while (entry) {
                        var chunk = entry.chunk;
                        var encoding = entry.encoding;
                        var cb = entry.callback;
                        var len = state.objectMode ? 1 : chunk.length;

                        doWrite(stream, state, false, len, chunk, encoding, cb);
                        entry = entry.next;
                        // if we didn't call the onwrite immediately, then
                        // it means that we need to wait until it does.
                        // also, that means that the chunk and cb are currently
                        // being processed, so move the buffer counter past them.
                        if (state.writing) {
                            break;
                        }
                    }

                    if (entry === null) state.lastBufferedRequest = null;
                }

                state.bufferedRequestCount = 0;
                state.bufferedRequest = entry;
                state.bufferProcessing = false;
            }

            Writable.prototype._write = function (chunk, encoding, cb) {
                cb(new Error('not implemented'));
            };

            Writable.prototype._writev = null;

            Writable.prototype.end = function (chunk, encoding, cb) {
                var state = this._writableState;

                if (typeof chunk === 'function') {
                    cb = chunk;
                    chunk = null;
                    encoding = null;
                } else if (typeof encoding === 'function') {
                    cb = encoding;
                    encoding = null;
                }

                if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);

                // .end() fully uncorks
                if (state.corked) {
                    state.corked = 1;
                    this.uncork();
                }

                // ignore unnecessary end() calls.
                if (!state.ending && !state.finished) endWritable(this, state, cb);
            };

            function needFinish(state) {
                return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
            }

            function prefinish(stream, state) {
                if (!state.prefinished) {
                    state.prefinished = true;
                    stream.emit('prefinish');
                }
            }

            function finishMaybe(stream, state) {
                var need = needFinish(state);
                if (need) {
                    if (state.pendingcb === 0) {
                        prefinish(stream, state);
                        state.finished = true;
                        stream.emit('finish');
                    } else {
                        prefinish(stream, state);
                    }
                }
                return need;
            }

            function endWritable(stream, state, cb) {
                state.ending = true;
                finishMaybe(stream, state);
                if (cb) {
                    if (state.finished) processNextTick(cb); else stream.once('finish', cb);
                }
                state.ended = true;
                stream.writable = false;
            }

// It seems a linked list but it is not
// there will be only 2 of these for each stream
            function CorkedRequest(state) {
                var _this = this;

                this.next = null;
                this.entry = null;

                this.finish = function (err) {
                    var entry = _this.entry;
                    _this.entry = null;
                    while (entry) {
                        var cb = entry.callback;
                        state.pendingcb--;
                        cb(err);
                        entry = entry.next;
                    }
                    if (state.corkedRequestsFree) {
                        state.corkedRequestsFree.next = _this;
                    } else {
                        state.corkedRequestsFree = _this;
                    }
                };
            }
        }).call(this, require('_process'))
    }, {
        "./_stream_duplex": 45,
        "_process": 43,
        "buffer": 36,
        "core-util-is": 50,
        "events": 40,
        "inherits": 41,
        "process-nextick-args": 52,
        "util-deprecate": 53
    }],
    50: [function (require, module, exports) {
        (function (Buffer) {
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.

            function isArray(arg) {
                if (Array.isArray) {
                    return Array.isArray(arg);
                }
                return objectToString(arg) === '[object Array]';
            }

            exports.isArray = isArray;

            function isBoolean(arg) {
                return typeof arg === 'boolean';
            }

            exports.isBoolean = isBoolean;

            function isNull(arg) {
                return arg === null;
            }

            exports.isNull = isNull;

            function isNullOrUndefined(arg) {
                return arg == null;
            }

            exports.isNullOrUndefined = isNullOrUndefined;

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

            exports.isNumber = isNumber;

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

            exports.isString = isString;

            function isSymbol(arg) {
                return typeof arg === 'symbol';
            }

            exports.isSymbol = isSymbol;

            function isUndefined(arg) {
                return arg === void 0;
            }

            exports.isUndefined = isUndefined;

            function isRegExp(re) {
                return objectToString(re) === '[object RegExp]';
            }

            exports.isRegExp = isRegExp;

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

            exports.isObject = isObject;

            function isDate(d) {
                return objectToString(d) === '[object Date]';
            }

            exports.isDate = isDate;

            function isError(e) {
                return (objectToString(e) === '[object Error]' || e instanceof Error);
            }

            exports.isError = isError;

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

            exports.isFunction = isFunction;

            function isPrimitive(arg) {
                return arg === null ||
                    typeof arg === 'boolean' ||
                    typeof arg === 'number' ||
                    typeof arg === 'string' ||
                    typeof arg === 'symbol' ||  // ES6 symbol
                    typeof arg === 'undefined';
            }

            exports.isPrimitive = isPrimitive;

            exports.isBuffer = Buffer.isBuffer;

            function objectToString(o) {
                return Object.prototype.toString.call(o);
            }

        }).call(this, {"isBuffer": require("../../../../insert-module-globals/node_modules/is-buffer/index.js")})
    }, {"../../../../insert-module-globals/node_modules/is-buffer/index.js": 42}],
    51: [function (require, module, exports) {
        arguments[4][39][0].apply(exports, arguments)
    }, {"dup": 39}],
    52: [function (require, module, exports) {
        (function (process) {
            'use strict';

            if (!process.version ||
                process.version.indexOf('v0.') === 0 ||
                process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
                module.exports = nextTick;
            } else {
                module.exports = process.nextTick;
            }

            function nextTick(fn) {
                var args = new Array(arguments.length - 1);
                var i = 0;
                while (i < args.length) {
                    args[i++] = arguments[i];
                }
                process.nextTick(function afterTick() {
                    fn.apply(null, args);
                });
            }

        }).call(this, require('_process'))
    }, {"_process": 43}],
    53: [function (require, module, exports) {
        (function (global) {

            /**
             * Module exports.
             */

            module.exports = deprecate;

            /**
             * Mark that a method should not be used.
             * Returns a modified function which warns once by default.
             *
             * If `localStorage.noDeprecation = true` is set, then it is a no-op.
             *
             * If `localStorage.throwDeprecation = true` is set, then deprecated functions
             * will throw an Error when invoked.
             *
             * If `localStorage.traceDeprecation = true` is set, then deprecated functions
             * will invoke `console.trace()` instead of `console.error()`.
             *
             * @param {Function} fn - the function to deprecate
             * @param {String} msg - the string to print to the console when `fn` is invoked
             * @returns {Function} a new "deprecated" version of `fn`
             * @api public
             */

            function deprecate(fn, msg) {
                if (config('noDeprecation')) {
                    return fn;
                }

                var warned = false;

                function deprecated() {
                    if (!warned) {
                        if (config('throwDeprecation')) {
                            throw new Error(msg);
                        } else if (config('traceDeprecation')) {
                            console.trace(msg);
                        } else {
                            console.warn(msg);
                        }
                        warned = true;
                    }
                    return fn.apply(this, arguments);
                }

                return deprecated;
            }

            /**
             * Checks `localStorage` for boolean values for the given `name`.
             *
             * @param {String} name
             * @returns {Boolean}
             * @api private
             */

            function config(name) {
                // accessing global.localStorage can trigger a DOMException in sandboxed iframes
                try {
                    if (!global.localStorage) return false;
                } catch (_) {
                    return false;
                }
                var val = global.localStorage[name];
                if (null == val) return false;
                return String(val).toLowerCase() === 'true';
            }

        }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}],
    54: [function (require, module, exports) {
        module.exports = require("./lib/_stream_passthrough.js")

    }, {"./lib/_stream_passthrough.js": 46}],
    55: [function (require, module, exports) {
        var Stream = (function () {
            try {
                return require('st' + 'ream'); // hack to fix a circular dependency issue when used with browserify
            } catch (_) {
            }
        }());
        exports = module.exports = require('./lib/_stream_readable.js');
        exports.Stream = Stream || exports;
        exports.Readable = exports;
        exports.Writable = require('./lib/_stream_writable.js');
        exports.Duplex = require('./lib/_stream_duplex.js');
        exports.Transform = require('./lib/_stream_transform.js');
        exports.PassThrough = require('./lib/_stream_passthrough.js');

    }, {
        "./lib/_stream_duplex.js": 45,
        "./lib/_stream_passthrough.js": 46,
        "./lib/_stream_readable.js": 47,
        "./lib/_stream_transform.js": 48,
        "./lib/_stream_writable.js": 49
    }],
    56: [function (require, module, exports) {
        module.exports = require("./lib/_stream_transform.js")

    }, {"./lib/_stream_transform.js": 48}],
    57: [function (require, module, exports) {
        module.exports = require("./lib/_stream_writable.js")

    }, {"./lib/_stream_writable.js": 49}],
    58: [function (require, module, exports) {
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

        module.exports = Stream;

        var EE = require('events').EventEmitter;
        var inherits = require('inherits');

        inherits(Stream, EE);
        Stream.Readable = require('readable-stream/readable.js');
        Stream.Writable = require('readable-stream/writable.js');
        Stream.Duplex = require('readable-stream/duplex.js');
        Stream.Transform = require('readable-stream/transform.js');
        Stream.PassThrough = require('readable-stream/passthrough.js');

// Backwards-compat with node 0.4.x
        Stream.Stream = Stream;


// old-style streams.  Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.

        function Stream() {
            EE.call(this);
        }

        Stream.prototype.pipe = function (dest, options) {
            var source = this;

            function ondata(chunk) {
                if (dest.writable) {
                    if (false === dest.write(chunk) && source.pause) {
                        source.pause();
                    }
                }
            }

            source.on('data', ondata);

            function ondrain() {
                if (source.readable && source.resume) {
                    source.resume();
                }
            }

            dest.on('drain', ondrain);

            // If the 'end' option is not supplied, dest.end() will be called when
            // source gets the 'end' or 'close' events.  Only dest.end() once.
            if (!dest._isStdio && (!options || options.end !== false)) {
                source.on('end', onend);
                source.on('close', onclose);
            }

            var didOnEnd = false;

            function onend() {
                if (didOnEnd) return;
                didOnEnd = true;

                dest.end();
            }


            function onclose() {
                if (didOnEnd) return;
                didOnEnd = true;

                if (typeof dest.destroy === 'function') dest.destroy();
            }

            // don't leave dangling pipes when there are errors.
            function onerror(er) {
                cleanup();
                if (EE.listenerCount(this, 'error') === 0) {
                    throw er; // Unhandled stream error in pipe.
                }
            }

            source.on('error', onerror);
            dest.on('error', onerror);

            // remove all the event listeners that were added.
            function cleanup() {
                source.removeListener('data', ondata);
                dest.removeListener('drain', ondrain);

                source.removeListener('end', onend);
                source.removeListener('close', onclose);

                source.removeListener('error', onerror);
                dest.removeListener('error', onerror);

                source.removeListener('end', cleanup);
                source.removeListener('close', cleanup);

                dest.removeListener('close', cleanup);
            }

            source.on('end', cleanup);
            source.on('close', cleanup);

            dest.on('close', cleanup);

            dest.emit('pipe', source);

            // Allow for unix-like usage: A.pipe(B).pipe(C)
            return dest;
        };

    }, {
        "events": 40,
        "inherits": 41,
        "readable-stream/duplex.js": 44,
        "readable-stream/passthrough.js": 54,
        "readable-stream/readable.js": 55,
        "readable-stream/transform.js": 56,
        "readable-stream/writable.js": 57
    }],
    59: [function (require, module, exports) {
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

        var Buffer = require('buffer').Buffer;

        var isBufferEncoding = Buffer.isEncoding
            || function (encoding) {
                switch (encoding && encoding.toLowerCase()) {
                    case 'hex':
                    case 'utf8':
                    case 'utf-8':
                    case 'ascii':
                    case 'binary':
                    case 'base64':
                    case 'ucs2':
                    case 'ucs-2':
                    case 'utf16le':
                    case 'utf-16le':
                    case 'raw':
                        return true;
                    default:
                        return false;
                }
            }


        function assertEncoding(encoding) {
            if (encoding && !isBufferEncoding(encoding)) {
                throw new Error('Unknown encoding: ' + encoding);
            }
        }

// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters. CESU-8 is handled as part of the UTF-8 encoding.
//
// @TODO Handling all encodings inside a single object makes it very difficult
// to reason about this code, so it should be split up in the future.
// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
// points as used by CESU-8.
        var StringDecoder = exports.StringDecoder = function (encoding) {
            this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
            assertEncoding(encoding);
            switch (this.encoding) {
                case 'utf8':
                    // CESU-8 represents each of Surrogate Pair by 3-bytes
                    this.surrogateSize = 3;
                    break;
                case 'ucs2':
                case 'utf16le':
                    // UTF-16 represents each of Surrogate Pair by 2-bytes
                    this.surrogateSize = 2;
                    this.detectIncompleteChar = utf16DetectIncompleteChar;
                    break;
                case 'base64':
                    // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
                    this.surrogateSize = 3;
                    this.detectIncompleteChar = base64DetectIncompleteChar;
                    break;
                default:
                    this.write = passThroughWrite;
                    return;
            }

            // Enough space to store all bytes of a single character. UTF-8 needs 4
            // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
            this.charBuffer = new Buffer(6);
            // Number of bytes received for the current incomplete multi-byte character.
            this.charReceived = 0;
            // Number of bytes expected for the current incomplete multi-byte character.
            this.charLength = 0;
        };


// write decodes the given buffer and returns it as JS string that is
// guaranteed to not contain any partial multi-byte characters. Any partial
// character found at the end of the buffer is buffered up, and will be
// returned when calling write again with the remaining bytes.
//
// Note: Converting a Buffer containing an orphan surrogate to a String
// currently works, but converting a String to a Buffer (via `new Buffer`, or
// Buffer#write) will replace incomplete surrogates with the unicode
// replacement character. See https://codereview.chromium.org/121173009/ .
        StringDecoder.prototype.write = function (buffer) {
            var charStr = '';
            // if our last write ended with an incomplete multibyte character
            while (this.charLength) {
                // determine how many remaining bytes this buffer has to offer for this char
                var available = (buffer.length >= this.charLength - this.charReceived) ?
                    this.charLength - this.charReceived :
                    buffer.length;

                // add the new bytes to the char buffer
                buffer.copy(this.charBuffer, this.charReceived, 0, available);
                this.charReceived += available;

                if (this.charReceived < this.charLength) {
                    // still not enough chars in this buffer? wait for more ...
                    return '';
                }

                // remove bytes belonging to the current character from the buffer
                buffer = buffer.slice(available, buffer.length);

                // get the character that was split
                charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);

                // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
                var charCode = charStr.charCodeAt(charStr.length - 1);
                if (charCode >= 0xD800 && charCode <= 0xDBFF) {
                    this.charLength += this.surrogateSize;
                    charStr = '';
                    continue;
                }
                this.charReceived = this.charLength = 0;

                // if there are no more bytes in this buffer, just emit our char
                if (buffer.length === 0) {
                    return charStr;
                }
                break;
            }

            // determine and set charLength / charReceived
            this.detectIncompleteChar(buffer);

            var end = buffer.length;
            if (this.charLength) {
                // buffer the incomplete character bytes we got
                buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
                end -= this.charReceived;
            }

            charStr += buffer.toString(this.encoding, 0, end);

            var end = charStr.length - 1;
            var charCode = charStr.charCodeAt(end);
            // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
            if (charCode >= 0xD800 && charCode <= 0xDBFF) {
                var size = this.surrogateSize;
                this.charLength += size;
                this.charReceived += size;
                this.charBuffer.copy(this.charBuffer, size, 0, size);
                buffer.copy(this.charBuffer, 0, 0, size);
                return charStr.substring(0, end);
            }

            // or just emit the charStr
            return charStr;
        };

// detectIncompleteChar determines if there is an incomplete UTF-8 character at
// the end of the given buffer. If so, it sets this.charLength to the byte
// length that character, and sets this.charReceived to the number of bytes
// that are available for this character.
        StringDecoder.prototype.detectIncompleteChar = function (buffer) {
            // determine how many bytes we have to check at the end of this buffer
            var i = (buffer.length >= 3) ? 3 : buffer.length;

            // Figure out if one of the last i bytes of our buffer announces an
            // incomplete char.
            for (; i > 0; i--) {
                var c = buffer[buffer.length - i];

                // See http://en.wikipedia.org/wiki/UTF-8#Description

                // 110XXXXX
                if (i == 1 && c >> 5 == 0x06) {
                    this.charLength = 2;
                    break;
                }

                // 1110XXXX
                if (i <= 2 && c >> 4 == 0x0E) {
                    this.charLength = 3;
                    break;
                }

                // 11110XXX
                if (i <= 3 && c >> 3 == 0x1E) {
                    this.charLength = 4;
                    break;
                }
            }
            this.charReceived = i;
        };

        StringDecoder.prototype.end = function (buffer) {
            var res = '';
            if (buffer && buffer.length)
                res = this.write(buffer);

            if (this.charReceived) {
                var cr = this.charReceived;
                var buf = this.charBuffer;
                var enc = this.encoding;
                res += buf.slice(0, cr).toString(enc);
            }

            return res;
        };

        function passThroughWrite(buffer) {
            return buffer.toString(this.encoding);
        }

        function utf16DetectIncompleteChar(buffer) {
            this.charReceived = buffer.length % 2;
            this.charLength = this.charReceived ? 2 : 0;
        }

        function base64DetectIncompleteChar(buffer) {
            this.charReceived = buffer.length % 3;
            this.charLength = this.charReceived ? 3 : 0;
        }

    }, {"buffer": 36}],
    60: [function (require, module, exports) {
        module.exports = function isBuffer(arg) {
            return arg && typeof arg === 'object'
                && typeof arg.copy === 'function'
                && typeof arg.fill === 'function'
                && typeof arg.readUInt8 === 'function';
        }
    }, {}],
    61: [function (require, module, exports) {
        (function (process, global) {
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.

            var formatRegExp = /%[sdj%]/g;
            exports.format = function (f) {
                if (!isString(f)) {
                    var objects = [];
                    for (var i = 0; i < arguments.length; i++) {
                        objects.push(inspect(arguments[i]));
                    }
                    return objects.join(' ');
                }

                var i = 1;
                var args = arguments;
                var len = args.length;
                var str = String(f).replace(formatRegExp, function (x) {
                    if (x === '%%') return '%';
                    if (i >= len) return x;
                    switch (x) {
                        case '%s':
                            return String(args[i++]);
                        case '%d':
                            return Number(args[i++]);
                        case '%j':
                            try {
                                return JSON.stringify(args[i++]);
                            } catch (_) {
                                return '[Circular]';
                            }
                        default:
                            return x;
                    }
                });
                for (var x = args[i]; i < len; x = args[++i]) {
                    if (isNull(x) || !isObject(x)) {
                        str += ' ' + x;
                    } else {
                        str += ' ' + inspect(x);
                    }
                }
                return str;
            };


// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
            exports.deprecate = function (fn, msg) {
                // Allow for deprecating things in the process of starting up.
                if (isUndefined(global.process)) {
                    return function () {
                        return exports.deprecate(fn, msg).apply(this, arguments);
                    };
                }

                if (process.noDeprecation === true) {
                    return fn;
                }

                var warned = false;

                function deprecated() {
                    if (!warned) {
                        if (process.throwDeprecation) {
                            throw new Error(msg);
                        } else if (process.traceDeprecation) {
                            console.trace(msg);
                        } else {
                            console.error(msg);
                        }
                        warned = true;
                    }
                    return fn.apply(this, arguments);
                }

                return deprecated;
            };


            var debugs = {};
            var debugEnviron;
            exports.debuglog = function (set) {
                if (isUndefined(debugEnviron))
                    debugEnviron = process.env.NODE_DEBUG || '';
                set = set.toUpperCase();
                if (!debugs[set]) {
                    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
                        var pid = process.pid;
                        debugs[set] = function () {
                            var msg = exports.format.apply(exports, arguments);
                            console.error('%s %d: %s', set, pid, msg);
                        };
                    } else {
                        debugs[set] = function () {
                        };
                    }
                }
                return debugs[set];
            };


            /**
             * Echos the value of a value. Trys to print the value out
             * in the best way possible given the different types.
             *
             * @param {Object} obj The object to print out.
             * @param {Object} opts Optional options object that alters the output.
             */

            /* legacy: obj, showHidden, depth, colors*/
            function inspect(obj, opts) {
                // default options
                var ctx = {
                    seen: [],
                    stylize: stylizeNoColor
                };
                // legacy...
                if (arguments.length >= 3) ctx.depth = arguments[2];
                if (arguments.length >= 4) ctx.colors = arguments[3];
                if (isBoolean(opts)) {
                    // legacy...
                    ctx.showHidden = opts;
                } else if (opts) {
                    // got an "options" object
                    exports._extend(ctx, opts);
                }
                // set default options
                if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
                if (isUndefined(ctx.depth)) ctx.depth = 2;
                if (isUndefined(ctx.colors)) ctx.colors = false;
                if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
                if (ctx.colors) ctx.stylize = stylizeWithColor;
                return formatValue(ctx, obj, ctx.depth);
            }

            exports.inspect = inspect;


// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
            inspect.colors = {
                'bold': [1, 22],
                'italic': [3, 23],
                'underline': [4, 24],
                'inverse': [7, 27],
                'white': [37, 39],
                'grey': [90, 39],
                'black': [30, 39],
                'blue': [34, 39],
                'cyan': [36, 39],
                'green': [32, 39],
                'magenta': [35, 39],
                'red': [31, 39],
                'yellow': [33, 39]
            };

// Don't use 'blue' not visible on cmd.exe
            inspect.styles = {
                'special': 'cyan',
                'number': 'yellow',
                'boolean': 'yellow',
                'undefined': 'grey',
                'null': 'bold',
                'string': 'green',
                'date': 'magenta',
                // "name": intentionally not styling
                'regexp': 'red'
            };


            function stylizeWithColor(str, styleType) {
                var style = inspect.styles[styleType];

                if (style) {
                    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
                        '\u001b[' + inspect.colors[style][1] + 'm';
                } else {
                    return str;
                }
            }


            function stylizeNoColor(str, styleType) {
                return str;
            }


            function arrayToHash(array) {
                var hash = {};

                array.forEach(function (val, idx) {
                    hash[val] = true;
                });

                return hash;
            }


            function formatValue(ctx, value, recurseTimes) {
                // Provide a hook for user-specified inspect functions.
                // Check that value is an object with an inspect function on it
                if (ctx.customInspect &&
                    value &&
                    isFunction(value.inspect) &&
                    // Filter out the util module, it's inspect function is special
                    value.inspect !== exports.inspect &&
                    // Also filter out any prototype objects using the circular check.
                    !(value.constructor && value.constructor.prototype === value)) {
                    var ret = value.inspect(recurseTimes, ctx);
                    if (!isString(ret)) {
                        ret = formatValue(ctx, ret, recurseTimes);
                    }
                    return ret;
                }

                // Primitive types cannot have properties
                var primitive = formatPrimitive(ctx, value);
                if (primitive) {
                    return primitive;
                }

                // Look up the keys of the object.
                var keys = Object.keys(value);
                var visibleKeys = arrayToHash(keys);

                if (ctx.showHidden) {
                    keys = Object.getOwnPropertyNames(value);
                }

                // IE doesn't make error fields non-enumerable
                // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
                if (isError(value)
                    && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
                    return formatError(value);
                }

                // Some type of object without properties can be shortcutted.
                if (keys.length === 0) {
                    if (isFunction(value)) {
                        var name = value.name ? ': ' + value.name : '';
                        return ctx.stylize('[Function' + name + ']', 'special');
                    }
                    if (isRegExp(value)) {
                        return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
                    }
                    if (isDate(value)) {
                        return ctx.stylize(Date.prototype.toString.call(value), 'date');
                    }
                    if (isError(value)) {
                        return formatError(value);
                    }
                }

                var base = '', array = false, braces = ['{', '}'];

                // Make Array say that they are Array
                if (isArray(value)) {
                    array = true;
                    braces = ['[', ']'];
                }

                // Make functions say that they are functions
                if (isFunction(value)) {
                    var n = value.name ? ': ' + value.name : '';
                    base = ' [Function' + n + ']';
                }

                // Make RegExps say that they are RegExps
                if (isRegExp(value)) {
                    base = ' ' + RegExp.prototype.toString.call(value);
                }

                // Make dates with properties first say the date
                if (isDate(value)) {
                    base = ' ' + Date.prototype.toUTCString.call(value);
                }

                // Make error with message first say the error
                if (isError(value)) {
                    base = ' ' + formatError(value);
                }

                if (keys.length === 0 && (!array || value.length == 0)) {
                    return braces[0] + base + braces[1];
                }

                if (recurseTimes < 0) {
                    if (isRegExp(value)) {
                        return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
                    } else {
                        return ctx.stylize('[Object]', 'special');
                    }
                }

                ctx.seen.push(value);

                var output;
                if (array) {
                    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
                } else {
                    output = keys.map(function (key) {
                        return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
                    });
                }

                ctx.seen.pop();

                return reduceToSingleString(output, base, braces);
            }


            function formatPrimitive(ctx, value) {
                if (isUndefined(value))
                    return ctx.stylize('undefined', 'undefined');
                if (isString(value)) {
                    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                        .replace(/'/g, "\\'")
                        .replace(/\\"/g, '"') + '\'';
                    return ctx.stylize(simple, 'string');
                }
                if (isNumber(value))
                    return ctx.stylize('' + value, 'number');
                if (isBoolean(value))
                    return ctx.stylize('' + value, 'boolean');
                // For some reason typeof null is "object", so special case here.
                if (isNull(value))
                    return ctx.stylize('null', 'null');
            }


            function formatError(value) {
                return '[' + Error.prototype.toString.call(value) + ']';
            }


            function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
                var output = [];
                for (var i = 0, l = value.length; i < l; ++i) {
                    if (hasOwnProperty(value, String(i))) {
                        output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                            String(i), true));
                    } else {
                        output.push('');
                    }
                }
                keys.forEach(function (key) {
                    if (!key.match(/^\d+$/)) {
                        output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                            key, true));
                    }
                });
                return output;
            }


            function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
                var name, str, desc;
                desc = Object.getOwnPropertyDescriptor(value, key) || {value: value[key]};
                if (desc.get) {
                    if (desc.set) {
                        str = ctx.stylize('[Getter/Setter]', 'special');
                    } else {
                        str = ctx.stylize('[Getter]', 'special');
                    }
                } else {
                    if (desc.set) {
                        str = ctx.stylize('[Setter]', 'special');
                    }
                }
                if (!hasOwnProperty(visibleKeys, key)) {
                    name = '[' + key + ']';
                }
                if (!str) {
                    if (ctx.seen.indexOf(desc.value) < 0) {
                        if (isNull(recurseTimes)) {
                            str = formatValue(ctx, desc.value, null);
                        } else {
                            str = formatValue(ctx, desc.value, recurseTimes - 1);
                        }
                        if (str.indexOf('\n') > -1) {
                            if (array) {
                                str = str.split('\n').map(function (line) {
                                    return '  ' + line;
                                }).join('\n').substr(2);
                            } else {
                                str = '\n' + str.split('\n').map(function (line) {
                                    return '   ' + line;
                                }).join('\n');
                            }
                        }
                    } else {
                        str = ctx.stylize('[Circular]', 'special');
                    }
                }
                if (isUndefined(name)) {
                    if (array && key.match(/^\d+$/)) {
                        return str;
                    }
                    name = JSON.stringify('' + key);
                    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
                        name = name.substr(1, name.length - 2);
                        name = ctx.stylize(name, 'name');
                    } else {
                        name = name.replace(/'/g, "\\'")
                            .replace(/\\"/g, '"')
                            .replace(/(^"|"$)/g, "'");
                        name = ctx.stylize(name, 'string');
                    }
                }

                return name + ': ' + str;
            }


            function reduceToSingleString(output, base, braces) {
                var numLinesEst = 0;
                var length = output.reduce(function (prev, cur) {
                    numLinesEst++;
                    if (cur.indexOf('\n') >= 0) numLinesEst++;
                    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
                }, 0);

                if (length > 60) {
                    return braces[0] +
                        (base === '' ? '' : base + '\n ') +
                        ' ' +
                        output.join(',\n  ') +
                        ' ' +
                        braces[1];
                }

                return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
            }


// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
            function isArray(ar) {
                return Array.isArray(ar);
            }

            exports.isArray = isArray;

            function isBoolean(arg) {
                return typeof arg === 'boolean';
            }

            exports.isBoolean = isBoolean;

            function isNull(arg) {
                return arg === null;
            }

            exports.isNull = isNull;

            function isNullOrUndefined(arg) {
                return arg == null;
            }

            exports.isNullOrUndefined = isNullOrUndefined;

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

            exports.isNumber = isNumber;

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

            exports.isString = isString;

            function isSymbol(arg) {
                return typeof arg === 'symbol';
            }

            exports.isSymbol = isSymbol;

            function isUndefined(arg) {
                return arg === void 0;
            }

            exports.isUndefined = isUndefined;

            function isRegExp(re) {
                return isObject(re) && objectToString(re) === '[object RegExp]';
            }

            exports.isRegExp = isRegExp;

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

            exports.isObject = isObject;

            function isDate(d) {
                return isObject(d) && objectToString(d) === '[object Date]';
            }

            exports.isDate = isDate;

            function isError(e) {
                return isObject(e) &&
                    (objectToString(e) === '[object Error]' || e instanceof Error);
            }

            exports.isError = isError;

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

            exports.isFunction = isFunction;

            function isPrimitive(arg) {
                return arg === null ||
                    typeof arg === 'boolean' ||
                    typeof arg === 'number' ||
                    typeof arg === 'string' ||
                    typeof arg === 'symbol' ||  // ES6 symbol
                    typeof arg === 'undefined';
            }

            exports.isPrimitive = isPrimitive;

            exports.isBuffer = require('./support/isBuffer');

            function objectToString(o) {
                return Object.prototype.toString.call(o);
            }


            function pad(n) {
                return n < 10 ? '0' + n.toString(10) : n.toString(10);
            }


            var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
                'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
            function timestamp() {
                var d = new Date();
                var time = [pad(d.getHours()),
                    pad(d.getMinutes()),
                    pad(d.getSeconds())].join(':');
                return [d.getDate(), months[d.getMonth()], time].join(' ');
            }


// log is just a thin wrapper to console.log that prepends a timestamp
            exports.log = function () {
                console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
            };


            /**
             * Inherit the prototype methods from one constructor into another.
             *
             * The Function.prototype.inherits from lang.js rewritten as a standalone
             * function (not on Function.prototype). NOTE: If this file is to be loaded
             * during bootstrapping this function needs to be rewritten using some native
             * functions as prototype setup using normal JavaScript does not work as
             * expected during bootstrapping (see mirror.js in r114903).
             *
             * @param {function} ctor Constructor function which needs to inherit the
             *     prototype.
             * @param {function} superCtor Constructor function to inherit prototype from.
             */
            exports.inherits = require('inherits');

            exports._extend = function (origin, add) {
                // Don't do anything if add isn't an object
                if (!add || !isObject(add)) return origin;

                var keys = Object.keys(add);
                var i = keys.length;
                while (i--) {
                    origin[keys[i]] = add[keys[i]];
                }
                return origin;
            };

            function hasOwnProperty(obj, prop) {
                return Object.prototype.hasOwnProperty.call(obj, prop);
            }

        }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {"./support/isBuffer": 60, "_process": 43, "inherits": 41}]
}, {}, [1]);