/******/ (function() { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 555:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

/* eslint-disable */
(function(f){if(true){module.exports=f()}else { var g; }})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=undefined;if(!f&&c)return require(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=undefined,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
        var promises = require("../../lib/promises");

        exports.Files = Files;


        function Files() {
            function read(uri) {
                return promises.reject(new Error("could not open external image: '" + uri + "'\ncannot open linked files from a web browser"));
            }

            return {
                read: read
            };
        }

    },{"../../lib/promises":23}],2:[function(require,module,exports){
        var promises = require("../lib/promises");
        var zipfile = require("../lib/zipfile");

        exports.openZip = openZip;

        function openZip(options) {
            if (options.arrayBuffer) {
                return promises.resolve(zipfile.openArrayBuffer(options.arrayBuffer));
            } else {
                return promises.reject(new Error("Could not find file in options"));
            }
        }

    },{"../lib/promises":23,"../lib/zipfile":39}],3:[function(require,module,exports){
        var _ = require("underscore");

        var promises = require("./promises");
        var documents = require("./documents");
        var htmlPaths = require("./styles/html-paths");
        var results = require("./results");
        var images = require("./images");
        var Html = require("./html");
        var writers = require("./writers");

        exports.DocumentConverter = DocumentConverter;
        exports.convertStyleForAttributes = convertStyleForAttributes

        function DocumentConverter(options) {
            return {
                convertToHtml: function(element) {
                    var comments = _.indexBy(
                        element.type === documents.types.document
                            ? element.comments
                            : [],
                        "commentId"
                    );
                    var conversion = new DocumentConversion(options, comments);
                    return conversion.convertToHtml(element);
                }
            };
        }

        function convertStyleForAttributes(element, options) {
            var styleMap = [];
            if (!options) {
                options = {};
            }
            if (element.alignment && element.alignment !== "both") {
                styleMap.push({key: "text-align", value: element.alignment});
            } else {
                styleMap.push({key: "text-align", value: 'left'});
            }

            if (element.color) {
                styleMap.push({key: "color", value: element.color});
            }
            if (element.bgColor) {
                styleMap.push({key: "background-color", value: element.bgColor});
            }
            if (element.fontSize) {
                styleMap.push({key: "font-size", value: element.fontSize + "px"});
            }
            if (element.isUnderline) {
                styleMap.push({key: "text-decoration", value: "underline"});
            }

            var styleStr = styleMap
                .map(function(item) {
                    return item.key + ":" + item.value;
                })
                .join(";");
            if (styleStr) {
                options.style = styleStr + ";" + (options.style || "");
            }
            return options;
        }
        function DocumentConversion(options, comments) {
            var noteNumber = 1;

            var noteReferences = [];

            var referencedComments = [];

            options = _.extend({ignoreEmptyParagraphs: true}, options);
            var idPrefix = options.idPrefix === undefined ? "" : options.idPrefix;
            var ignoreEmptyParagraphs = options.ignoreEmptyParagraphs;

            var styleMap = options.styleMap || [];



            function convertToHtml(document) {
                var messages = [];

                var html = elementToHtml(document, messages, {});

                var deferredNodes = [];
                walkHtml(html, function(node) {
                    if (node.type === "deferred") {
                        deferredNodes.push(node);
                    }
                });
                var deferredValues = {};
                return promises
                    .mapSeries(deferredNodes, function(deferred) {
                        return deferred.value().then(function(value) {
                            deferredValues[deferred.id] = value;
                        });
                    })
                    .then(function() {
                        function replaceDeferred(nodes) {
                            return flatMap(nodes, function(node) {
                                if (node.type === "deferred") {
                                    return deferredValues[node.id];
                                } else if (node.children) {
                                    return [
                                        _.extend({}, node, {
                                            children: replaceDeferred(node.children)
                                        })
                                    ];
                                } else {
                                    return [node];
                                }
                            });
                        }
                        var writer = writers.writer({
                            prettyPrint: options.prettyPrint,
                            outputFormat: options.outputFormat
                        });
                        Html.write(writer, Html.simplify(replaceDeferred(html)));
                        return new results.Result(writer.asString(), messages);
                    });
            }

            function convertElements(elements, messages, options) {
                return flatMap(elements, function(element) {
                    return elementToHtml(element, messages, options);
                });
            }

            function elementToHtml(element, messages, options) {
                if (!options) {
                    throw new Error("options not set");
                }
                var handler = elementConverters[element.type];
                if (handler) {
                    return handler(element, messages, options);
                } else {
                    return [];
                }
            }

            function convertParagraph(element, messages, options) {
                return htmlPathForParagraph(element, messages).wrap(function() {
                    var content = convertElements(element.children, messages, options);
                    if (ignoreEmptyParagraphs) {
                        return content;
                    } else {
                        return [Html.forceWrite].concat(content);
                    }
                }, element);
            }

            function htmlPathForParagraph(element, messages) {
                var style = findStyle(element);

                if (style) {
                    return style.to;
                } else {
                    if (element.styleId) {
                        messages.push(unrecognisedStyleWarning("paragraph", element));
                    }
                    return htmlPaths.topLevelElement(
                        "p",
                        convertStyleForAttributes(element)
                    );
                    // return defaultParagraphStyle;
                }
            }

            function convertRun(run, messages, options) {
                var nodes = function() {
                    return convertElements(run.children, messages, options);
                };
                var paths = [];
                var tagNumber = 0;
                var attributes = convertStyleForAttributes(run);
                if (run.isSmallCaps) {
                    paths.push(findHtmlPathForRunProperty("smallCaps"));
                }
                if (run.isAllCaps) {
                    paths.push(findHtmlPathForRunProperty("allCaps"));
                }
                if (run.isStrikethrough) {
                    paths.push(
                        findHtmlPathForRunProperty("strikethrough", "s", attributes)
                    );
                    tagNumber++;
                }
                // if (run.isUnderline) {
                //     paths.push(findHtmlPathForRunProperty("underline"));
                // }
                if (run.verticalAlignment === documents.verticalAlignment.subscript) {
                    paths.push(htmlPaths.element("sub", attributes, {fresh: false}));
                    tagNumber++;
                }
                if (run.verticalAlignment === documents.verticalAlignment.superscript) {
                    paths.push(htmlPaths.element("sup", attributes, {fresh: false}));
                    tagNumber++;
                }
                if (run.isItalic) {
                    paths.push(findHtmlPathForRunProperty("italic", "em", attributes));
                    tagNumber++;
                }
                if (run.isBold) {
                    paths.push(
                        findHtmlPathForRunProperty("bold", "strong", attributes)
                    );
                    tagNumber++;
                }
                var stylePath = htmlPaths.empty;
                var style = findStyle(run);
                if (style) {
                    stylePath = style.to;
                } else if (run.styleId) {
                    messages.push(unrecognisedStyleWarning("run", run));
                }

                if (attributes && attributes.style && tagNumber == 0) {
                    paths.push(htmlPaths.element("span", attributes, {fresh: false}));
                }

                paths.push(stylePath);

                paths.forEach(function(path) {
                    nodes = path.wrap.bind(path, nodes);
                });

                return nodes();
            }

            function findHtmlPathForRunProperty(
                elementType,
                defaultTagName,
                attributes
            ) {
                var path = findHtmlPath({type: elementType});
                if (path) {
                    return path;
                } else if (defaultTagName) {
                    return htmlPaths.element(defaultTagName, attributes || {}, {
                        fresh: false
                    });
                } else {
                    return htmlPaths.empty;
                }
            }

            function findHtmlPath(element, defaultPath) {
                var style = findStyle(element);
                return style ? style.to : defaultPath;
            }

            function findStyle(element) {
                for (var i = 0; i < styleMap.length; i++) {
                    if (styleMap[i].from.matches(element)) {
                        return styleMap[i];
                    }
                }
            }

            function recoveringConvertImage(convertImage) {
                return function(image, messages) {
                    return promises
                        .attempt(function() {
                            return convertImage(image, messages);
                        })
                        .caught(function(error) {
                            messages.push(results.error(error));
                            return [];
                        });
                };
            }

            function noteHtmlId(note) {
                return referentHtmlId(note.noteType, note.noteId);
            }

            function noteRefHtmlId(note) {
                return referenceHtmlId(note.noteType, note.noteId);
            }

            function referentHtmlId(referenceType, referenceId) {
                return htmlId(referenceType + "-" + referenceId);
            }

            function referenceHtmlId(referenceType, referenceId) {
                return htmlId(referenceType + "-ref-" + referenceId);
            }

            function htmlId(suffix) {
                return idPrefix + suffix;
            }

            var defaultTablePath = htmlPaths.elements([
                htmlPaths.element("table", {}, {fresh: true})
            ]);

            function convertTable(element, messages, options) {
                return findHtmlPath(element, defaultTablePath).wrap(function() {
                    return convertTableChildren(element, messages, options);
                });
            }

            function convertTableChildren(element, messages, options) {
                var bodyIndex = _.findIndex(element.children, function(child) {
                    return !child.type === documents.types.tableRow || !child.isHeader;
                });
                if (bodyIndex === -1) {
                    bodyIndex = element.children.length;
                }
                var children;
                if (bodyIndex === 0) {
                    children = convertElements(
                        element.children,
                        messages,
                        _.extend({}, options, {isTableHeader: false})
                    );
                } else {
                    var headRows = convertElements(
                        element.children.slice(0, bodyIndex),
                        messages,
                        _.extend({}, options, {isTableHeader: true})
                    );
                    var bodyRows = convertElements(
                        element.children.slice(bodyIndex),
                        messages,
                        _.extend({}, options, {isTableHeader: false})
                    );
                    children = [
                        Html.freshElement("thead", {}, headRows),
                        Html.freshElement("tbody", {}, bodyRows)
                    ];
                }
                return [Html.forceWrite].concat(children);
            }

            function convertTableRow(element, messages, options) {
                var children = convertElements(element.children, messages, options);
                return [
                    Html.freshElement("tr", {}, [Html.forceWrite].concat(children))
                ];
            }

            function convertTableCell(element, messages, options) {
                var tagName = options.isTableHeader ? "th" : "td";
                var children = convertElements(element.children, messages, options);
                var attributes = {};
                if (element.colSpan !== 1) {
                    attributes.colspan = element.colSpan.toString();
                }
                if (element.rowSpan !== 1) {
                    attributes.rowspan = element.rowSpan.toString();
                }

                return [
                    Html.freshElement(
                        tagName,
                        attributes,
                        [Html.forceWrite].concat(children)
                    )
                ];
            }

            function convertCommentReference(reference, messages, options) {
                return findHtmlPath(reference, htmlPaths.ignore).wrap(function() {
                    var comment = comments[reference.commentId];
                    var count = referencedComments.length + 1;
                    var label = "[" + commentAuthorLabel(comment) + count + "]";
                    referencedComments.push({label: label, comment: comment});
                    // TODO: remove duplication with note references
                    return [
                        Html.freshElement(
                            "a",
                            {
                                href:
                                    "#" +
                                    referentHtmlId("comment", reference.commentId),
                                id: referenceHtmlId("comment", reference.commentId)
                            },
                            [Html.text(label)]
                        )
                    ];
                });
            }

            function convertComment(referencedComment, messages, options) {
                // TODO: remove duplication with note references

                var label = referencedComment.label;
                var comment = referencedComment.comment;
                var body = convertElements(comment.body, messages, options).concat([
                    Html.nonFreshElement("p", {}, [
                        Html.text(" "),
                        Html.freshElement(
                            "a",
                            {href: "#" + referenceHtmlId("comment", comment.commentId)},
                            [Html.text("↑")]
                        )
                    ])
                ]);

                return [
                    Html.freshElement(
                        "dt",
                        {id: referentHtmlId("comment", comment.commentId)},
                        [Html.text("Comment " + label)]
                    ),
                    Html.freshElement("dd", {}, body)
                ];
            }

            function convertBreak(element, messages, options) {
                return htmlPathForBreak(element).wrap(function() {
                    return [];
                });
            }

            function htmlPathForBreak(element) {
                var style = findStyle(element);
                if (style) {
                    return style.to;
                } else if (element.breakType === "line") {
                    return htmlPaths.topLevelElement("br");
                } else {
                    return htmlPaths.empty;
                }
            }

            var elementConverters = {
                document: function(document, messages, options) {
                    var children = convertElements(
                        document.children,
                        messages,
                        options
                    );
                    var notes = noteReferences.map(function(noteReference) {
                        return document.notes.resolve(noteReference);
                    });
                    var notesNodes = convertElements(notes, messages, options);
                    return children.concat([
                        Html.freshElement("ol", {}, notesNodes),
                        Html.freshElement(
                            "dl",
                            {},
                            flatMap(referencedComments, function(referencedComment) {
                                return convertComment(
                                    referencedComment,
                                    messages,
                                    options
                                );
                            })
                        )
                    ]);
                },
                paragraph: convertParagraph,
                run: convertRun,
                text: function(element, messages, options) {
                    return [Html.text(element.value)];
                },
                tab: function(element, messages, options) {
                    return [Html.text("\t")];
                },
                hyperlink: function(element, messages, options) {
                    var href = element.anchor
                        ? "#" + htmlId(element.anchor)
                        : element.href;
                    var attributes = {href: href};
                    if (element.targetFrame != null) {
                        attributes.target = element.targetFrame;
                    }

                    var children = convertElements(element.children, messages, options);
                    return [Html.nonFreshElement("a", attributes, children)];
                },
                bookmarkStart: function(element, messages, options) {
                    var anchor = Html.freshElement(
                        "a",
                        {
                            id: htmlId(element.name)
                        },
                        [Html.forceWrite]
                    );
                    return [anchor];
                },
                noteReference: function(element, messages, options) {
                    noteReferences.push(element);
                    var anchor = Html.freshElement(
                        "a",
                        {
                            href: "#" + noteHtmlId(element),
                            id: noteRefHtmlId(element)
                        },
                        [Html.text("[" + noteNumber++ + "]")]
                    );

                    return [Html.freshElement("sup", {}, [anchor])];
                },
                note: function(element, messages, options) {
                    var children = convertElements(element.body, messages, options);
                    var backLink = Html.elementWithTag(
                        htmlPaths.element("p", {}, {fresh: false}),
                        [
                            Html.text(" "),
                            Html.freshElement(
                                "a",
                                {href: "#" + noteRefHtmlId(element)},
                                [Html.text("↑")]
                            )
                        ]
                    );
                    var body = children.concat([backLink]);

                    return Html.freshElement("li", {id: noteHtmlId(element)}, body);
                },
                commentReference: convertCommentReference,
                comment: convertComment,
                image: deferredConversion(
                    recoveringConvertImage(options.convertImage || images.dataUri)
                ),
                table: convertTable,
                tableRow: convertTableRow,
                tableCell: convertTableCell,
                break: convertBreak
            };
            return {
                convertToHtml: convertToHtml
            };
        }

        var deferredId = 1;

        function deferredConversion(func) {
            return function(element, messages, options) {
                return [
                    {
                        type: "deferred",
                        id: deferredId++,
                        value: function() {
                            return func(element, messages, options);
                        }
                    }
                ];
            };
        }

        function unrecognisedStyleWarning(type, element) {
            return results.warning(
                "Unrecognised " +
                type +
                " style: '" +
                element.styleName +
                "'" +
                " (Style ID: " +
                element.styleId +
                ")"
            );
        }

        function flatMap(values, func) {
            return _.flatten(values.map(func), true);
        }

        function walkHtml(nodes, callback) {
            nodes.forEach(function(node) {
                callback(node);
                if (node.children) {
                    walkHtml(node.children, callback);
                }
            });
        }

        var commentAuthorLabel = (exports.commentAuthorLabel =
            function commentAuthorLabel(comment) {
                return comment.authorInitials || "";
            });

    },{"./documents":4,"./html":18,"./images":20,"./promises":23,"./results":25,"./styles/html-paths":28,"./writers":33,"underscore":122}],4:[function(require,module,exports){
        var _ = require("underscore");

        var types = exports.types = {
            document: "document",
            paragraph: "paragraph",
            run: "run",
            text: "text",
            tab: "tab",
            hyperlink: "hyperlink",
            noteReference: "noteReference",
            image: "image",
            note: "note",
            commentReference: "commentReference",
            comment: "comment",
            table: "table",
            tableRow: "tableRow",
            tableCell: "tableCell",
            "break": "break",
            bookmarkStart: "bookmarkStart"
        };

        function Document(children, options) {
            options = options || {};
            return {
                type: types.document,
                children: children,
                notes: options.notes || new Notes({}),
                comments: options.comments || []
            };
        }

        function Paragraph(children, properties) {
            properties = properties || {};
            var indent = properties.indent || {};
            return {
                type: types.paragraph,
                children: children,
                styleId: properties.styleId || null,
                styleName: properties.styleName || null,
                numbering: properties.numbering || null,
                alignment: properties.alignment || null,
                indent: {
                    start: indent.start || null,
                    end: indent.end || null,
                    firstLine: indent.firstLine || null,
                    hanging: indent.hanging || null
                },
                bgColor: properties.bgColor || null
            };
        }

        function Run(children, properties) {
            properties = properties || {};
            return {
                type: types.run,
                children: children,
                styleId: properties.styleId || null,
                styleName: properties.styleName || null,
                isBold: properties.isBold,
                isUnderline: properties.isUnderline,
                isItalic: properties.isItalic,
                isStrikethrough: properties.isStrikethrough,
                isAllCaps: properties.isAllCaps,
                isSmallCaps: properties.isSmallCaps,
                verticalAlignment: properties.verticalAlignment || verticalAlignment.baseline,
                font: properties.font || null,
                fontSize: properties.fontSize || null,
                bgColor: properties.bgColor || null,
                color: properties.color
            };
        }

        var verticalAlignment = {
            baseline: "baseline",
            superscript: "superscript",
            subscript: "subscript"
        };

        function Text(value) {
            return {
                type: types.text,
                value: value
            };
        }

        function Tab() {
            return {
                type: types.tab
            };
        }

        function Hyperlink(children, options) {
            return {
                type: types.hyperlink,
                children: children,
                href: options.href,
                anchor: options.anchor,
                targetFrame: options.targetFrame
            };
        }

        function NoteReference(options) {
            return {
                type: types.noteReference,
                noteType: options.noteType,
                noteId: options.noteId
            };
        }

        function Notes(notes) {
            this._notes = _.indexBy(notes, function(note) {
                return noteKey(note.noteType, note.noteId);
            });
        }

        Notes.prototype.resolve = function(reference) {
            return this.findNoteByKey(noteKey(reference.noteType, reference.noteId));
        };

        Notes.prototype.findNoteByKey = function(key) {
            return this._notes[key] || null;
        };

        function Note(options) {
            return {
                type: types.note,
                noteType: options.noteType,
                noteId: options.noteId,
                body: options.body
            };
        }

        function commentReference(options) {
            return {
                type: types.commentReference,
                commentId: options.commentId
            };
        }

        function comment(options) {
            return {
                type: types.comment,
                commentId: options.commentId,
                body: options.body,
                authorName: options.authorName,
                authorInitials: options.authorInitials
            };
        }

        function noteKey(noteType, id) {
            return noteType + "-" + id;
        }

        function Image(options) {
            return {
                type: types.image,
                read: options.readImage,
                altText: options.altText,
                contentType: options.contentType
            };
        }

        function Table(children, properties) {
            properties = properties || {};
            return {
                type: types.table,
                children: children,
                styleId: properties.styleId || null,
                styleName: properties.styleName || null
            };
        }

        function TableRow(children, options) {
            options = options || {};
            return {
                type: types.tableRow,
                children: children,
                isHeader: options.isHeader || false
            };
        }

        function TableCell(children, options) {
            options = options || {};
            return {
                type: types.tableCell,
                children: children,
                colSpan: options.colSpan == null ? 1 : options.colSpan,
                rowSpan: options.rowSpan == null ? 1 : options.rowSpan
            };
        }

        function Break(breakType) {
            return {
                type: types["break"],
                breakType: breakType
            };
        }

        function BookmarkStart(options) {
            return {
                type: types.bookmarkStart,
                name: options.name
            };
        }

        exports.document = exports.Document = Document;
        exports.paragraph = exports.Paragraph = Paragraph;
        exports.run = exports.Run = Run;
        exports.Text = Text;
        exports.tab = exports.Tab = Tab;
        exports.Hyperlink = Hyperlink;
        exports.noteReference = exports.NoteReference = NoteReference;
        exports.Notes = Notes;
        exports.Note = Note;
        exports.commentReference = commentReference;
        exports.comment = comment;
        exports.Image = Image;
        exports.Table = Table;
        exports.TableRow = TableRow;
        exports.TableCell = TableCell;
        exports.lineBreak = Break("line");
        exports.pageBreak = Break("page");
        exports.columnBreak = Break("column");
        exports.BookmarkStart = BookmarkStart;

        exports.verticalAlignment = verticalAlignment;

    },{"underscore":122}],5:[function(require,module,exports){
        exports.createBodyReader = createBodyReader;
        exports._readNumberingProperties = readNumberingProperties;

        var dingbatToUnicode = require("dingbat-to-unicode");
        var _ = require("underscore");

        var documents = require("../documents");
        var Result = require("../results").Result;
        var warning = require("../results").warning;
        var uris = require("./uris");

        function createBodyReader(options) {
            return {
                readXmlElement: function(element) {
                    return new BodyReader(options).readXmlElement(element);
                },
                readXmlElements: function(elements) {
                    return new BodyReader(options).readXmlElements(elements);
                }
            };
        }

        function BodyReader(options) {
            var complexFieldStack = [];
            var currentInstrText = [];
            var relationships = options.relationships;
            var contentTypes = options.contentTypes;
            var docxFile = options.docxFile;
            var files = options.files;
            var numbering = options.numbering;
            var styles = options.styles;

            function readXmlElements(elements) {
                var results = elements.map(readXmlElement);
                return combineResults(results);
            }

            function readXmlElement(element) {
                if (element.type === "element") {
                    var handler = xmlElementReaders[element.name];
                    if (handler) {
                        return handler(element);
                    } else if (
                        !Object.prototype.hasOwnProperty.call(
                            ignoreElements,
                            element.name
                        )
                    ) {
                        var message = warning(
                            "An unrecognised element was ignored: " + element.name
                        );
                        return emptyResultWithMessages([message]);
                    }
                }
                return emptyResult();
            }

            function readParagraphIndent(element) {
                return {
                    start:
                        element.attributes["w:start"] || element.attributes["w:left"],
                    end: element.attributes["w:end"] || element.attributes["w:right"],
                    firstLine: element.attributes["w:firstLine"],
                    hanging: element.attributes["w:hanging"]
                };
            }

            function readRunProperties(element) {
                return readRunStyle(element).map(function(style) {
                    var fontSizeString =
                        element.firstOrEmpty("w:sz").attributes["w:val"];
                    // w:sz gives the font size in half points, so halve the value to get the size in points
                    var fontSize = /^[0-9]+$/.test(fontSizeString)
                        ? parseInt(fontSizeString, 10) / 2
                        : null;

                    return {
                        type: "runProperties",
                        styleId: style.styleId,
                        styleName: style.name,
                        verticalAlignment:
                            element.firstOrEmpty("w:vertAlign").attributes["w:val"],
                        font: element.firstOrEmpty("w:rFonts").attributes["w:ascii"],
                        fontSize: fontSize,
                        isBold: readBooleanElement(element.first("w:b")),
                        isUnderline: readUnderline(element.first("w:u")),
                        isItalic: readBooleanElement(element.first("w:i")),
                        isStrikethrough: readBooleanElement(element.first("w:strike")),
                        isAllCaps: readBooleanElement(element.first("w:caps")),
                        isSmallCaps: readBooleanElement(element.first("w:smallCaps")),
                        color: readColor(element.firstOrEmpty("w:color")),
                        bgColor: readColor(element.firstOrEmpty("w:highlight"))
                    };
                });
            }

            function readUnderline(element) {
                if (element) {
                    var value = element.attributes["w:val"];
                    return (
                        value !== undefined &&
                        value !== "false" &&
                        value !== "0" &&
                        value !== "none"
                    );
                } else {
                    return false;
                }
            }

            function readBooleanElement(element) {
                if (element) {
                    var value = element.attributes["w:val"];
                    return value !== "false" && value !== "0";
                } else {
                    return false;
                }
            }

            function readParagraphStyle(element) {
                return readStyle(
                    element,
                    "w:pStyle",
                    "Paragraph",
                    styles.findParagraphStyleById
                );
            }

            function readRunStyle(element) {
                return readStyle(
                    element,
                    "w:rStyle",
                    "Run",
                    styles.findCharacterStyleById
                );
            }

            function readTableStyle(element) {
                return readStyle(
                    element,
                    "w:tblStyle",
                    "Table",
                    styles.findTableStyleById
                );
            }

            function readStyle(element, styleTagName, styleType, findStyleById) {
                var messages = [];
                var styleElement = element.first(styleTagName);
                var styleId = null;
                var name = null;
                if (styleElement) {
                    styleId = styleElement.attributes["w:val"];
                    if (styleId) {
                        var style = findStyleById(styleId);
                        if (style) {
                            name = style.name;
                        } else {
                            messages.push(undefinedStyleWarning(styleType, styleId));
                        }
                    }
                }
                return elementResultWithMessages(
                    {styleId: styleId, name: name},
                    messages
                );
            }

            var unknownComplexField = {type: "unknown"};

            function readFldChar(element) {
                var type = element.attributes["w:fldCharType"];
                if (type === "begin") {
                    complexFieldStack.push(unknownComplexField);
                    currentInstrText = [];
                } else if (type === "end") {
                    complexFieldStack.pop();
                } else if (type === "separate") {
                    var hyperlinkOptions = parseHyperlinkFieldCode(
                        currentInstrText.join("")
                    );
                    var complexField =
                        hyperlinkOptions === null
                            ? unknownComplexField
                            : {type: "hyperlink", options: hyperlinkOptions};
                    complexFieldStack.pop();
                    complexFieldStack.push(complexField);
                }
                return emptyResult();
            }

            function currentHyperlinkOptions() {
                var topHyperlink = _.last(
                    complexFieldStack.filter(function(complexField) {
                        return complexField.type === "hyperlink";
                    })
                );
                return topHyperlink ? topHyperlink.options : null;
            }

            function parseHyperlinkFieldCode(code) {
                var externalLinkResult = /\s*HYPERLINK "(.*)"/.exec(code);
                if (externalLinkResult) {
                    return {href: externalLinkResult[1]};
                }

                var internalLinkResult = /\s*HYPERLINK\s+\\l\s+"(.*)"/.exec(code);
                if (internalLinkResult) {
                    return {anchor: internalLinkResult[1]};
                }

                return null;
            }

            function readInstrText(element) {
                currentInstrText.push(element.text());
                return emptyResult();
            }

            function readSymbol(element) {
                // See 17.3.3.30 sym (Symbol Character) of ECMA-376 4th edition Part 1
                var font = element.attributes["w:font"];
                var char = element.attributes["w:char"];
                var unicodeCharacter = dingbatToUnicode.hex(font, char);
                if (unicodeCharacter == null && /^F0..$/.test(char)) {
                    unicodeCharacter = dingbatToUnicode.hex(font, char.substring(2));
                }

                if (unicodeCharacter == null) {
                    return emptyResultWithMessages([
                        warning(
                            "A w:sym element with an unsupported character was ignored: char " +
                            char +
                            " in font " +
                            font
                        )
                    ]);
                } else {
                    return elementResult(new documents.Text(unicodeCharacter.string));
                }
            }

            function noteReferenceReader(noteType) {
                return function(element) {
                    var noteId = element.attributes["w:id"];
                    return elementResult(
                        new documents.NoteReference({
                            noteType: noteType,
                            noteId: noteId
                        })
                    );
                };
            }

            function readCommentReference(element) {
                return elementResult(
                    documents.commentReference({
                        commentId: element.attributes["w:id"]
                    })
                );
            }

            function readChildElements(element) {
                return readXmlElements(element.children);
            }

            var xmlElementReaders = {
                "w:p": function(element) {
                    return readXmlElements(element.children)
                        .map(function(children) {
                            var properties = _.find(children, isParagraphProperties);
                            return new documents.Paragraph(
                                children.filter(negate(isParagraphProperties)),
                                properties
                            );
                        })
                        .insertExtra();
                },
                "w:pPr": function(element) {
                    return readParagraphStyle(element).map(function(style) {
                        return {
                            type: "paragraphProperties",
                            styleId: style.styleId,
                            styleName: style.name,
                            alignment: element.firstOrEmpty("w:jc").attributes["w:val"],
                            numbering: readNumberingProperties(
                                style.styleId,
                                element.firstOrEmpty("w:numPr"),
                                numbering
                            ),
                            indent: readParagraphIndent(element.firstOrEmpty("w:ind")),
                            bgColor: readColor(element.firstOrEmpty("w:shd"))
                        };
                    });
                },
                "w:r": function(element) {
                    return readXmlElements(element.children).map(function(children) {
                        var properties = _.find(children, isRunProperties);
                        children = children.filter(negate(isRunProperties));

                        var hyperlinkOptions = currentHyperlinkOptions();
                        if (hyperlinkOptions !== null) {
                            children = [
                                new documents.Hyperlink(children, hyperlinkOptions)
                            ];
                        }

                        return new documents.Run(children, properties);
                    });
                },
                "w:rPr": readRunProperties,
                "w:fldChar": readFldChar,
                "w:instrText": readInstrText,
                "w:t": function(element) {
                    return elementResult(new documents.Text(element.text()));
                },
                "w:tab": function(element) {
                    return elementResult(new documents.Tab());
                },
                "w:noBreakHyphen": function() {
                    return elementResult(new documents.Text("\u2011"));
                },
                "w:softHyphen": function(element) {
                    return elementResult(new documents.Text("\u00AD"));
                },
                "w:sym": readSymbol,
                "w:hyperlink": function(element) {
                    var relationshipId = element.attributes["r:id"];
                    var anchor = element.attributes["w:anchor"];
                    return readXmlElements(element.children).map(function(children) {
                        function create(options) {
                            var targetFrame = element.attributes["w:tgtFrame"] || null;

                            return new documents.Hyperlink(
                                children,
                                _.extend({targetFrame: targetFrame}, options)
                            );
                        }

                        if (relationshipId) {
                            var href =
                                relationships.findTargetByRelationshipId(
                                    relationshipId
                                );
                            if (anchor) {
                                href = uris.replaceFragment(href, anchor);
                            }
                            return create({href: href});
                        } else if (anchor) {
                            return create({anchor: anchor});
                        } else {
                            return children;
                        }
                    });
                },
                "w:tbl": readTable,
                "w:tr": readTableRow,
                "w:tc": readTableCell,
                "w:footnoteReference": noteReferenceReader("footnote"),
                "w:endnoteReference": noteReferenceReader("endnote"),
                "w:commentReference": readCommentReference,
                "w:br": function(element) {
                    var breakType = element.attributes["w:type"];
                    if (breakType == null || breakType === "textWrapping") {
                        return elementResult(documents.lineBreak);
                    } else if (breakType === "page") {
                        return elementResult(documents.pageBreak);
                    } else if (breakType === "column") {
                        return elementResult(documents.columnBreak);
                    } else {
                        return emptyResultWithMessages([
                            warning("Unsupported break type: " + breakType)
                        ]);
                    }
                },
                "w:bookmarkStart": function(element) {
                    var name = element.attributes["w:name"];
                    if (name === "_GoBack") {
                        return emptyResult();
                    } else {
                        return elementResult(new documents.BookmarkStart({name: name}));
                    }
                },

                "mc:AlternateContent": function(element) {
                    return readChildElements(element.first("mc:Fallback"));
                },

                "w:sdt": function(element) {
                    return readXmlElements(
                        element.firstOrEmpty("w:sdtContent").children
                    );
                },

                "w:ins": readChildElements,
                "w:object": readChildElements,
                "w:smartTag": readChildElements,
                "w:drawing": readChildElements,
                "w:pict": function(element) {
                    return readChildElements(element).toExtra();
                },
                "v:roundrect": readChildElements,
                "v:shape": readChildElements,
                "v:textbox": readChildElements,
                "w:txbxContent": readChildElements,
                "wp:inline": readDrawingElement,
                "wp:anchor": readDrawingElement,
                "v:imagedata": readImageData,
                "v:group": readChildElements,
                "v:rect": readChildElements
            };

            return {
                readXmlElement: readXmlElement,
                readXmlElements: readXmlElements
            };

            function readColor(element) {
                var value = element.attributes["w:fill"] || element.attributes["w:val"];
                if (!value || value === "none") {
                    return null;
                }

                return /^([0-9a-fA-F]{6}|[0-9a-fA-F]{3})$/.test(value)
                    ? "#" + value
                    : value;
            }

            function readTable(element) {
                var propertiesResult = readTableProperties(
                    element.firstOrEmpty("w:tblPr")
                );
                return readXmlElements(element.children)
                    .flatMap(calculateRowSpans)
                    .flatMap(function(children) {
                        return propertiesResult.map(function(properties) {
                            return documents.Table(children, properties);
                        });
                    });
            }

            function readTableProperties(element) {
                return readTableStyle(element).map(function(style) {
                    return {
                        styleId: style.styleId,
                        styleName: style.name
                    };
                });
            }

            function readTableRow(element) {
                var properties = element.firstOrEmpty("w:trPr");
                var isHeader = !!properties.first("w:tblHeader");
                return readXmlElements(element.children).map(function(children) {
                    return documents.TableRow(children, {isHeader: isHeader});
                });
            }

            function readTableCell(element) {
                return readXmlElements(element.children).map(function(children) {
                    var properties = element.firstOrEmpty("w:tcPr");

                    var gridSpan =
                        properties.firstOrEmpty("w:gridSpan").attributes["w:val"];
                    var colSpan = gridSpan ? parseInt(gridSpan, 10) : 1;

                    var cell = documents.TableCell(children, {colSpan: colSpan});
                    cell._vMerge = readVMerge(properties);
                    return cell;
                });
            }

            function readVMerge(properties) {
                var element = properties.first("w:vMerge");
                if (element) {
                    var val = element.attributes["w:val"];
                    return val === "continue" || !val;
                } else {
                    return null;
                }
            }

            function calculateRowSpans(rows) {
                var unexpectedNonRows = _.any(rows, function(row) {
                    return row.type !== documents.types.tableRow;
                });
                if (unexpectedNonRows) {
                    return elementResultWithMessages(rows, [
                        warning(
                            "unexpected non-row element in table, cell merging may be incorrect"
                        )
                    ]);
                }
                var unexpectedNonCells = _.any(rows, function(row) {
                    return _.any(row.children, function(cell) {
                        return cell.type !== documents.types.tableCell;
                    });
                });
                if (unexpectedNonCells) {
                    return elementResultWithMessages(rows, [
                        warning(
                            "unexpected non-cell element in table row, cell merging may be incorrect"
                        )
                    ]);
                }

                var columns = {};

                rows.forEach(function(row) {
                    var cellIndex = 0;
                    row.children.forEach(function(cell) {
                        if (cell._vMerge && columns[cellIndex]) {
                            columns[cellIndex].rowSpan++;
                        } else {
                            columns[cellIndex] = cell;
                            cell._vMerge = false;
                        }
                        cellIndex += cell.colSpan;
                    });
                });

                rows.forEach(function(row) {
                    row.children = row.children.filter(function(cell) {
                        return !cell._vMerge;
                    });
                    row.children.forEach(function(cell) {
                        delete cell._vMerge;
                    });
                });

                return elementResult(rows);
            }

            function readDrawingElement(element) {
                var blips = element
                    .getElementsByTagName("a:graphic")
                    .getElementsByTagName("a:graphicData")
                    .getElementsByTagName("pic:pic")
                    .getElementsByTagName("pic:blipFill")
                    .getElementsByTagName("a:blip");

                return combineResults(blips.map(readBlip.bind(null, element)));
            }

            function readBlip(element, blip) {
                var properties = element.first("wp:docPr").attributes;
                var altText = isBlank(properties.descr)
                    ? properties.title
                    : properties.descr;
                var blipImageFile = findBlipImageFile(blip);
                if (blipImageFile === null) {
                    return emptyResultWithMessages([
                        warning("Could not find image file for a:blip element")
                    ]);
                } else {
                    return readImage(blipImageFile, altText);
                }
            }

            function isBlank(value) {
                return value == null || /^\s*$/.test(value);
            }

            function findBlipImageFile(blip) {
                var embedRelationshipId = blip.attributes["r:embed"];
                var linkRelationshipId = blip.attributes["r:link"];
                if (embedRelationshipId) {
                    return findEmbeddedImageFile(embedRelationshipId);
                } else if (linkRelationshipId) {
                    var imagePath =
                        relationships.findTargetByRelationshipId(linkRelationshipId);
                    return {
                        path: imagePath,
                        read: files.read.bind(files, imagePath)
                    };
                } else {
                    return null;
                }
            }

            function readImageData(element) {
                var relationshipId = element.attributes["r:id"];

                if (relationshipId) {
                    return readImage(
                        findEmbeddedImageFile(relationshipId),
                        element.attributes["o:title"]
                    );
                } else {
                    return emptyResultWithMessages([
                        warning(
                            "A v:imagedata element without a relationship ID was ignored"
                        )
                    ]);
                }
            }

            function findEmbeddedImageFile(relationshipId) {
                var path = uris.uriToZipEntryName(
                    "word",
                    relationships.findTargetByRelationshipId(relationshipId)
                );
                return {
                    path: path,
                    read: docxFile.read.bind(docxFile, path)
                };
            }

            function readImage(imageFile, altText) {
                var contentType = contentTypes.findContentType(imageFile.path);

                var image = documents.Image({
                    readImage: imageFile.read,
                    altText: altText,
                    contentType: contentType
                });
                var warnings = supportedImageTypes[contentType]
                    ? []
                    : warning(
                        "Image of type " +
                        contentType +
                        " is unlikely to display in web browsers"
                    );
                return elementResultWithMessages(image, warnings);
            }

            function undefinedStyleWarning(type, styleId) {
                return warning(
                    type +
                    " style with ID " +
                    styleId +
                    " was referenced but not defined in the document"
                );
            }
        }

        function readNumberingProperties(styleId, element, numbering) {
            if (styleId != null) {
                var levelByStyleId = numbering.findLevelByParagraphStyleId(styleId);
                if (levelByStyleId != null) {
                    return levelByStyleId;
                }
            }

            var level = element.firstOrEmpty("w:ilvl").attributes["w:val"];
            var numId = element.firstOrEmpty("w:numId").attributes["w:val"];
            if (level === undefined || numId === undefined) {
                return null;
            } else {
                return numbering.findLevel(numId, level);
            }
        }

        var supportedImageTypes = {
            "image/png": true,
            "image/gif": true,
            "image/jpeg": true,
            "image/svg+xml": true,
            "image/tiff": true
        };

        var ignoreElements = {
            "office-word:wrap": true,
            "v:shadow": true,
            "v:shapetype": true,
            "w:annotationRef": true,
            "w:bookmarkEnd": true,
            "w:sectPr": true,
            "w:proofErr": true,
            "w:lastRenderedPageBreak": true,
            "w:commentRangeStart": true,
            "w:commentRangeEnd": true,
            "w:del": true,
            "w:footnoteRef": true,
            "w:endnoteRef": true,
            "w:tblPr": true,
            "w:tblGrid": true,
            "w:trPr": true,
            "w:tcPr": true
        };

        function isParagraphProperties(element) {
            return element.type === "paragraphProperties";
        }

        function isRunProperties(element) {
            return element.type === "runProperties";
        }

        function negate(predicate) {
            return function(value) {
                return !predicate(value);
            };
        }

        function emptyResultWithMessages(messages) {
            return new ReadResult(null, null, messages);
        }

        function emptyResult() {
            return new ReadResult(null);
        }

        function elementResult(element) {
            return new ReadResult(element);
        }

        function elementResultWithMessages(element, messages) {
            return new ReadResult(element, null, messages);
        }

        function ReadResult(element, extra, messages) {
            this.value = element || [];
            this.extra = extra;
            this._result = new Result(
                {
                    element: this.value,
                    extra: extra
                },
                messages
            );
            this.messages = this._result.messages;
        }

        ReadResult.prototype.toExtra = function() {
            return new ReadResult(
                null,
                joinElements(this.extra, this.value),
                this.messages
            );
        };

        ReadResult.prototype.insertExtra = function() {
            var extra = this.extra;
            if (extra && extra.length) {
                return new ReadResult(
                    joinElements(this.value, extra),
                    null,
                    this.messages
                );
            } else {
                return this;
            }
        };

        ReadResult.prototype.map = function(func) {
            var result = this._result.map(function(value) {
                return func(value.element);
            });
            return new ReadResult(result.value, this.extra, result.messages);
        };

        ReadResult.prototype.flatMap = function(func) {
            var result = this._result.flatMap(function(value) {
                return func(value.element)._result;
            });
            return new ReadResult(
                result.value.element,
                joinElements(this.extra, result.value.extra),
                result.messages
            );
        };

        function combineResults(results) {
            var result = Result.combine(_.pluck(results, "_result"));
            return new ReadResult(
                _.flatten(_.pluck(result.value, "element")),
                _.filter(_.flatten(_.pluck(result.value, "extra")), identity),
                result.messages
            );
        }

        function joinElements(first, second) {
            return _.flatten([first, second]);
        }

        function identity(value) {
            return value;
        }

    },{"../documents":4,"../results":25,"./uris":16,"dingbat-to-unicode":80,"underscore":122}],6:[function(require,module,exports){
        var documents = require("../documents");
        var Result = require("../results").Result;

        function createCommentsReader(bodyReader) {
            function readCommentsXml(element) {
                return Result.combine(element.getElementsByTagName("w:comment")
                    .map(readCommentElement));
            }

            function readCommentElement(element) {
                var id = element.attributes["w:id"];

                function readOptionalAttribute(name) {
                    return (element.attributes[name] || "").trim() || null;
                }

                return bodyReader.readXmlElements(element.children)
                    .map(function(body) {
                        return documents.comment({
                            commentId: id,
                            body: body,
                            authorName: readOptionalAttribute("w:author"),
                            authorInitials: readOptionalAttribute("w:initials")
                        });
                    });
            }

            return readCommentsXml;
        }

        exports.createCommentsReader = createCommentsReader;

    },{"../documents":4,"../results":25}],7:[function(require,module,exports){
        exports.readContentTypesFromXml = readContentTypesFromXml;

        var fallbackContentTypes = {
            "png": "png",
            "gif": "gif",
            "jpeg": "jpeg",
            "jpg": "jpeg",
            "tif": "tiff",
            "tiff": "tiff",
            "bmp": "bmp"
        };

        exports.defaultContentTypes = contentTypes({}, {});


        function readContentTypesFromXml(element) {
            var extensionDefaults = {};
            var overrides = {};

            element.children.forEach(function(child) {
                if (child.name === "content-types:Default") {
                    extensionDefaults[child.attributes.Extension] = child.attributes.ContentType;
                }
                if (child.name === "content-types:Override") {
                    var name = child.attributes.PartName;
                    if (name.charAt(0) === "/") {
                        name = name.substring(1);
                    }
                    overrides[name] = child.attributes.ContentType;
                }
            });
            return contentTypes(overrides, extensionDefaults);
        }

        function contentTypes(overrides, extensionDefaults) {
            return {
                findContentType: function(path) {
                    var overrideContentType = overrides[path];
                    if (overrideContentType) {
                        return overrideContentType;
                    } else {
                        var pathParts = path.split(".");
                        var extension = pathParts[pathParts.length - 1];
                        if (extensionDefaults.hasOwnProperty(extension)) {
                            return extensionDefaults[extension];
                        } else {
                            var fallback = fallbackContentTypes[extension.toLowerCase()];
                            if (fallback) {
                                return "image/" + fallback;
                            } else {
                                return null;
                            }
                        }
                    }
                }
            };

        }

    },{}],8:[function(require,module,exports){
        exports.DocumentXmlReader = DocumentXmlReader;

        var documents = require("../documents");
        var Result = require("../results").Result;


        function DocumentXmlReader(options) {
            var bodyReader = options.bodyReader;

            function convertXmlToDocument(element) {
                var body = element.first("w:body");

                var result = bodyReader.readXmlElements(body.children)
                    .map(function(children) {
                        return new documents.Document(children, {
                            notes: options.notes,
                            comments: options.comments
                        });
                    });
                return new Result(result.value, result.messages);
            }

            return {
                convertXmlToDocument: convertXmlToDocument
            };
        }

    },{"../documents":4,"../results":25}],9:[function(require,module,exports){
        exports.read = read;
        exports._findPartPaths = findPartPaths;

        var path = require("path");

        var promises = require("../promises");
        var documents = require("../documents");
        var Result = require("../results").Result;
        var zipfile = require("../zipfile");

        var readXmlFromZipFile = require("./office-xml-reader").readXmlFromZipFile;
        var createBodyReader = require("./body-reader").createBodyReader;
        var DocumentXmlReader = require("./document-xml-reader").DocumentXmlReader;
        var relationshipsReader = require("./relationships-reader");
        var contentTypesReader = require("./content-types-reader");
        var numberingXml = require("./numbering-xml");
        var stylesReader = require("./styles-reader");
        var notesReader = require("./notes-reader");
        var commentsReader = require("./comments-reader");
        var Files = require("./files").Files;


        function read(docxFile, input) {
            input = input || {};

            return promises.props({
                contentTypes: readContentTypesFromZipFile(docxFile),
                partPaths: findPartPaths(docxFile),
                docxFile: docxFile,
                files: new Files(input.path ? path.dirname(input.path) : null)
            }).also(function(result) {
                return {
                    styles: readStylesFromZipFile(docxFile, result.partPaths.styles)
                };
            }).also(function(result) {
                return {
                    numbering: readNumberingFromZipFile(docxFile, result.partPaths.numbering, result.styles)
                };
            }).also(function(result) {
                return {
                    footnotes: readXmlFileWithBody(result.partPaths.footnotes, result, function(bodyReader, xml) {
                        if (xml) {
                            return notesReader.createFootnotesReader(bodyReader)(xml);
                        } else {
                            return new Result([]);
                        }
                    }),
                    endnotes: readXmlFileWithBody(result.partPaths.endnotes, result, function(bodyReader, xml) {
                        if (xml) {
                            return notesReader.createEndnotesReader(bodyReader)(xml);
                        } else {
                            return new Result([]);
                        }
                    }),
                    comments: readXmlFileWithBody(result.partPaths.comments, result, function(bodyReader, xml) {
                        if (xml) {
                            return commentsReader.createCommentsReader(bodyReader)(xml);
                        } else {
                            return new Result([]);
                        }
                    })
                };
            }).also(function(result) {
                return {
                    notes: result.footnotes.flatMap(function(footnotes) {
                        return result.endnotes.map(function(endnotes) {
                            return new documents.Notes(footnotes.concat(endnotes));
                        });
                    })
                };
            }).then(function(result) {
                return readXmlFileWithBody(result.partPaths.mainDocument, result, function(bodyReader, xml) {
                    return result.notes.flatMap(function(notes) {
                        return result.comments.flatMap(function(comments) {
                            var reader = new DocumentXmlReader({
                                bodyReader: bodyReader,
                                notes: notes,
                                comments: comments
                            });
                            return reader.convertXmlToDocument(xml);
                        });
                    });
                });
            });
        }

        function findPartPaths(docxFile) {
            return readPackageRelationships(docxFile).then(function(packageRelationships) {
                var mainDocumentPath = findPartPath({
                    docxFile: docxFile,
                    relationships: packageRelationships,
                    relationshipType: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
                    basePath: "",
                    fallbackPath: "word/document.xml"
                });

                if (!docxFile.exists(mainDocumentPath)) {
                    throw new Error("Could not find main document part. Are you sure this is a valid .docx file?");
                }

                return xmlFileReader({
                    filename: relationshipsFilename(mainDocumentPath),
                    readElement: relationshipsReader.readRelationships,
                    defaultValue: relationshipsReader.defaultValue
                })(docxFile).then(function(documentRelationships) {
                    function findPartRelatedToMainDocument(name) {
                        return findPartPath({
                            docxFile: docxFile,
                            relationships: documentRelationships,
                            relationshipType: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/" + name,
                            basePath: zipfile.splitPath(mainDocumentPath).dirname,
                            fallbackPath: "word/" + name + ".xml"
                        });
                    }

                    return {
                        mainDocument: mainDocumentPath,
                        comments: findPartRelatedToMainDocument("comments"),
                        endnotes: findPartRelatedToMainDocument("endnotes"),
                        footnotes: findPartRelatedToMainDocument("footnotes"),
                        numbering: findPartRelatedToMainDocument("numbering"),
                        styles: findPartRelatedToMainDocument("styles")
                    };
                });
            });
        }

        function findPartPath(options) {
            var docxFile = options.docxFile;
            var relationships = options.relationships;
            var relationshipType = options.relationshipType;
            var basePath = options.basePath;
            var fallbackPath = options.fallbackPath;

            var targets = relationships.findTargetsByType(relationshipType);
            var normalisedTargets = targets.map(function(target) {
                return stripPrefix(zipfile.joinPath(basePath, target), "/");
            });
            var validTargets = normalisedTargets.filter(function(target) {
                return docxFile.exists(target);
            });
            if (validTargets.length === 0) {
                return fallbackPath;
            } else {
                return validTargets[0];
            }
        }

        function stripPrefix(value, prefix) {
            if (value.substring(0, prefix.length) === prefix) {
                return value.substring(prefix.length);
            } else {
                return value;
            }
        }

        function xmlFileReader(options) {
            return function(zipFile) {
                return readXmlFromZipFile(zipFile, options.filename)
                    .then(function(element) {
                        return element ? options.readElement(element) : options.defaultValue;
                    });
            };
        }

        function readXmlFileWithBody(filename, options, func) {
            var readRelationshipsFromZipFile = xmlFileReader({
                filename: relationshipsFilename(filename),
                readElement: relationshipsReader.readRelationships,
                defaultValue: relationshipsReader.defaultValue
            });

            return readRelationshipsFromZipFile(options.docxFile).then(function(relationships) {
                var bodyReader = new createBodyReader({
                    relationships: relationships,
                    contentTypes: options.contentTypes,
                    docxFile: options.docxFile,
                    numbering: options.numbering,
                    styles: options.styles,
                    files: options.files
                });
                return readXmlFromZipFile(options.docxFile, filename)
                    .then(function(xml) {
                        return func(bodyReader, xml);
                    });
            });
        }

        function relationshipsFilename(filename) {
            var split = zipfile.splitPath(filename);
            return zipfile.joinPath(split.dirname, "_rels", split.basename + ".rels");
        }

        var readContentTypesFromZipFile = xmlFileReader({
            filename: "[Content_Types].xml",
            readElement: contentTypesReader.readContentTypesFromXml,
            defaultValue: contentTypesReader.defaultContentTypes
        });

        function readNumberingFromZipFile(zipFile, path, styles) {
            return xmlFileReader({
                filename: path,
                readElement: function(element) {
                    return numberingXml.readNumberingXml(element, {styles: styles});
                },
                defaultValue: numberingXml.defaultNumbering
            })(zipFile);
        }

        function readStylesFromZipFile(zipFile, path) {
            return xmlFileReader({
                filename: path,
                readElement: stylesReader.readStylesXml,
                defaultValue: stylesReader.defaultStyles
            })(zipFile);
        }

        var readPackageRelationships = xmlFileReader({
            filename: "_rels/.rels",
            readElement: relationshipsReader.readRelationships,
            defaultValue: relationshipsReader.defaultValue
        });

    },{"../documents":4,"../promises":23,"../results":25,"../zipfile":39,"./body-reader":5,"./comments-reader":6,"./content-types-reader":7,"./document-xml-reader":8,"./files":1,"./notes-reader":10,"./numbering-xml":11,"./office-xml-reader":12,"./relationships-reader":13,"./styles-reader":15,"path":100}],10:[function(require,module,exports){
        var documents = require("../documents");
        var Result = require("../results").Result;

        exports.createFootnotesReader = createReader.bind(this, "footnote");
        exports.createEndnotesReader = createReader.bind(this, "endnote");

        function createReader(noteType, bodyReader) {
            function readNotesXml(element) {
                return Result.combine(element.getElementsByTagName("w:" + noteType)
                    .filter(isFootnoteElement)
                    .map(readFootnoteElement));
            }

            function isFootnoteElement(element) {
                var type = element.attributes["w:type"];
                return type !== "continuationSeparator" && type !== "separator";
            }

            function readFootnoteElement(footnoteElement) {
                var id = footnoteElement.attributes["w:id"];
                return bodyReader.readXmlElements(footnoteElement.children)
                    .map(function(body) {
                        return documents.Note({noteType: noteType, noteId: id, body: body});
                    });
            }

            return readNotesXml;
        }

    },{"../documents":4,"../results":25}],11:[function(require,module,exports){
        var _ = require("underscore");

        exports.readNumberingXml = readNumberingXml;
        exports.Numbering = Numbering;
        exports.defaultNumbering = new Numbering({}, {});

        function Numbering(nums, abstractNums, styles) {
            var allLevels = _.flatten(_.values(abstractNums).map(function(abstractNum) {
                return _.values(abstractNum.levels);
            }));

            var levelsByParagraphStyleId = _.indexBy(
                allLevels.filter(function(level) {
                    return level.paragraphStyleId != null;
                }),
                "paragraphStyleId"
            );

            function findLevel(numId, level) {
                var num = nums[numId];
                if (num) {
                    var abstractNum = abstractNums[num.abstractNumId];
                    if (!abstractNum) {
                        return null;
                    } else if (abstractNum.numStyleLink == null) {
                        return abstractNums[num.abstractNumId].levels[level];
                    } else {
                        var style = styles.findNumberingStyleById(abstractNum.numStyleLink);
                        return findLevel(style.numId, level);
                    }
                } else {
                    return null;
                }
            }

            function findLevelByParagraphStyleId(styleId) {
                return levelsByParagraphStyleId[styleId] || null;
            }

            return {
                findLevel: findLevel,
                findLevelByParagraphStyleId: findLevelByParagraphStyleId
            };
        }

        function readNumberingXml(root, options) {
            if (!options || !options.styles) {
                throw new Error("styles is missing");
            }

            var abstractNums = readAbstractNums(root);
            var nums = readNums(root, abstractNums);
            return new Numbering(nums, abstractNums, options.styles);
        }

        function readAbstractNums(root) {
            var abstractNums = {};
            root.getElementsByTagName("w:abstractNum").forEach(function(element) {
                var id = element.attributes["w:abstractNumId"];
                abstractNums[id] = readAbstractNum(element);
            });
            return abstractNums;
        }

        function readAbstractNum(element) {
            var levels = {};
            element.getElementsByTagName("w:lvl").forEach(function(levelElement) {
                var levelIndex = levelElement.attributes["w:ilvl"];
                var numFmt = levelElement.first("w:numFmt").attributes["w:val"];
                var paragraphStyleId = levelElement.firstOrEmpty("w:pStyle").attributes["w:val"];

                levels[levelIndex] = {
                    isOrdered: numFmt !== "bullet",
                    level: levelIndex,
                    paragraphStyleId: paragraphStyleId
                };
            });

            var numStyleLink = element.firstOrEmpty("w:numStyleLink").attributes["w:val"];

            return {levels: levels, numStyleLink: numStyleLink};
        }

        function readNums(root) {
            var nums = {};
            root.getElementsByTagName("w:num").forEach(function(element) {
                var numId = element.attributes["w:numId"];
                var abstractNumId = element.first("w:abstractNumId").attributes["w:val"];
                nums[numId] = {abstractNumId: abstractNumId};
            });
            return nums;
        }

    },{"underscore":122}],12:[function(require,module,exports){
        var _ = require("underscore");

        var promises = require("../promises");
        var xml = require("../xml");


        exports.read = read;
        exports.readXmlFromZipFile = readXmlFromZipFile;

        var xmlNamespaceMap = {
            "http://schemas.openxmlformats.org/wordprocessingml/2006/main": "w",
            "http://schemas.openxmlformats.org/officeDocument/2006/relationships": "r",
            "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing": "wp",
            "http://schemas.openxmlformats.org/drawingml/2006/main": "a",
            "http://schemas.openxmlformats.org/drawingml/2006/picture": "pic",
            "http://schemas.openxmlformats.org/package/2006/content-types": "content-types",
            "urn:schemas-microsoft-com:vml": "v",
            "http://schemas.openxmlformats.org/markup-compatibility/2006": "mc",
            "urn:schemas-microsoft-com:office:word": "office-word"
        };


        function read(xmlString) {
            return xml.readString(xmlString, xmlNamespaceMap)
                .then(function(document) {
                    return collapseAlternateContent(document)[0];
                });
        }


        function readXmlFromZipFile(docxFile, path) {
            if (docxFile.exists(path)) {
                return docxFile.read(path, "utf-8")
                    .then(stripUtf8Bom)
                    .then(read);
            } else {
                return promises.resolve(null);
            }
        }


        function stripUtf8Bom(xmlString) {
            return xmlString.replace(/^\uFEFF/g, '');
        }


        function collapseAlternateContent(node) {
            if (node.type === "element") {
                if (node.name === "mc:AlternateContent") {
                    return node.first("mc:Fallback").children;
                } else {
                    node.children = _.flatten(node.children.map(collapseAlternateContent, true));
                    return [node];
                }
            } else {
                return [node];
            }
        }

    },{"../promises":23,"../xml":35,"underscore":122}],13:[function(require,module,exports){
        exports.readRelationships = readRelationships;
        exports.defaultValue = new Relationships([]);
        exports.Relationships = Relationships;


        function readRelationships(element) {
            var relationships = [];
            element.children.forEach(function(child) {
                if (child.name === "{http://schemas.openxmlformats.org/package/2006/relationships}Relationship") {
                    var relationship = {
                        relationshipId: child.attributes.Id,
                        target: child.attributes.Target,
                        type: child.attributes.Type
                    };
                    relationships.push(relationship);
                }
            });
            return new Relationships(relationships);
        }

        function Relationships(relationships) {
            var targetsByRelationshipId = {};
            relationships.forEach(function(relationship) {
                targetsByRelationshipId[relationship.relationshipId] = relationship.target;
            });

            var targetsByType = {};
            relationships.forEach(function(relationship) {
                if (!targetsByType[relationship.type]) {
                    targetsByType[relationship.type] = [];
                }
                targetsByType[relationship.type].push(relationship.target);
            });

            return {
                findTargetByRelationshipId: function(relationshipId) {
                    return targetsByRelationshipId[relationshipId];
                },
                findTargetsByType: function(type) {
                    return targetsByType[type] || [];
                }
            };
        }

    },{}],14:[function(require,module,exports){
        var _ = require("underscore");

        var promises = require("../promises");
        var xml = require("../xml");

        exports.writeStyleMap = writeStyleMap;
        exports.readStyleMap = readStyleMap;


        var schema = "http://schemas.zwobble.org/mammoth/style-map";
        var styleMapPath = "mammoth/style-map";
        var styleMapAbsolutePath = "/" + styleMapPath;

        function writeStyleMap(docxFile, styleMap) {
            docxFile.write(styleMapPath, styleMap);
            return updateRelationships(docxFile).then(function() {
                return updateContentTypes(docxFile);
            });
        }

        function updateRelationships(docxFile) {
            var path = "word/_rels/document.xml.rels";
            var relationshipsUri = "http://schemas.openxmlformats.org/package/2006/relationships";
            var relationshipElementName = "{" + relationshipsUri + "}Relationship";
            return docxFile.read(path, "utf8")
                .then(xml.readString)
                .then(function(relationshipsContainer) {
                    var relationships = relationshipsContainer.children;
                    addOrUpdateElement(relationships, relationshipElementName, "Id", {
                        "Id": "rMammothStyleMap",
                        "Type": schema,
                        "Target": styleMapAbsolutePath
                    });

                    var namespaces = {"": relationshipsUri};
                    return docxFile.write(path, xml.writeString(relationshipsContainer, namespaces));
                });
        }

        function updateContentTypes(docxFile) {
            var path = "[Content_Types].xml";
            var contentTypesUri = "http://schemas.openxmlformats.org/package/2006/content-types";
            var overrideName = "{" + contentTypesUri + "}Override";
            return docxFile.read(path, "utf8")
                .then(xml.readString)
                .then(function(typesElement) {
                    var children = typesElement.children;
                    addOrUpdateElement(children, overrideName, "PartName", {
                        "PartName": styleMapAbsolutePath,
                        "ContentType": "text/prs.mammoth.style-map"
                    });
                    var namespaces = {"": contentTypesUri};
                    return docxFile.write(path, xml.writeString(typesElement, namespaces));
                });
        }

        function addOrUpdateElement(elements, name, identifyingAttribute, attributes) {
            var existingElement = _.find(elements, function(element) {
                return element.name === name &&
                    element.attributes[identifyingAttribute] === attributes[identifyingAttribute];
            });
            if (existingElement) {
                existingElement.attributes = attributes;
            } else {
                elements.push(xml.element(name, attributes));
            }
        }

        function readStyleMap(docxFile) {
            if (docxFile.exists(styleMapPath)) {
                return docxFile.read(styleMapPath, "utf8");
            } else {
                return promises.resolve(null);
            }
        }

    },{"../promises":23,"../xml":35,"underscore":122}],15:[function(require,module,exports){
        exports.readStylesXml = readStylesXml;
        exports.Styles = Styles;
        exports.defaultStyles = new Styles({}, {});

        function Styles(paragraphStyles, characterStyles, tableStyles, numberingStyles) {
            return {
                findParagraphStyleById: function(styleId) {
                    return paragraphStyles[styleId];
                },
                findCharacterStyleById: function(styleId) {
                    return characterStyles[styleId];
                },
                findTableStyleById: function(styleId) {
                    return tableStyles[styleId];
                },
                findNumberingStyleById: function(styleId) {
                    return numberingStyles[styleId];
                }
            };
        }

        Styles.EMPTY = new Styles({}, {}, {}, {});

        function readStylesXml(root) {
            var paragraphStyles = {};
            var characterStyles = {};
            var tableStyles = {};
            var numberingStyles = {};

            var styles = {
                "paragraph": paragraphStyles,
                "character": characterStyles,
                "table": tableStyles
            };

            root.getElementsByTagName("w:style").forEach(function(styleElement) {
                var style = readStyleElement(styleElement);
                if (style.type === "numbering") {
                    numberingStyles[style.styleId] = readNumberingStyleElement(styleElement);
                } else {
                    var styleSet = styles[style.type];
                    if (styleSet) {
                        styleSet[style.styleId] = style;
                    }
                }
            });

            return new Styles(paragraphStyles, characterStyles, tableStyles, numberingStyles);
        }

        function readStyleElement(styleElement) {
            var type = styleElement.attributes["w:type"];
            var styleId = styleElement.attributes["w:styleId"];
            var name = styleName(styleElement);
            return {type: type, styleId: styleId, name: name};
        }

        function styleName(styleElement) {
            var nameElement = styleElement.first("w:name");
            return nameElement ? nameElement.attributes["w:val"] : null;
        }

        function readNumberingStyleElement(styleElement) {
            var numId = styleElement
                .firstOrEmpty("w:pPr")
                .firstOrEmpty("w:numPr")
                .firstOrEmpty("w:numId")
                .attributes["w:val"];
            return {numId: numId};
        }

    },{}],16:[function(require,module,exports){
        exports.uriToZipEntryName = uriToZipEntryName;
        exports.replaceFragment = replaceFragment;

        function uriToZipEntryName(base, uri) {
            if (uri.charAt(0) === "/") {
                return uri.substr(1);
            } else {
                // In general, we should check first and second for trailing and leading slashes,
                // but in our specific case this seems to be sufficient
                return base + "/" + uri;
            }
        }


        function replaceFragment(uri, fragment) {
            var hashIndex = uri.indexOf("#");
            if (hashIndex !== -1) {
                uri = uri.substring(0, hashIndex);
            }
            return uri + "#" + fragment;
        }

    },{}],17:[function(require,module,exports){
        var htmlPaths = require("../styles/html-paths");


        function nonFreshElement(tagName, attributes, children) {
            return elementWithTag(
                htmlPaths.element(tagName, attributes, {fresh: false}),
                children);
        }

        function freshElement(tagName, attributes, children) {
            var tag = htmlPaths.element(tagName, attributes, {fresh: true});
            return elementWithTag(tag, children);
        }

        function elementWithTag(tag, children) {
            return {
                type: "element",
                tag: tag,
                children: children || []
            };
        }

        function text(value) {
            return {
                type: "text",
                value: value
            };
        }

        var forceWrite = {
            type: "forceWrite"
        };

        exports.freshElement = freshElement;
        exports.nonFreshElement = nonFreshElement;
        exports.elementWithTag = elementWithTag;
        exports.text = text;
        exports.forceWrite = forceWrite;

        var voidTagNames = {
            "br": true,
            "hr": true,
            "img": true
        };

        function isVoidElement(node) {
            return (node.children.length === 0) && voidTagNames[node.tag.tagName];
        }

        exports.isVoidElement = isVoidElement;

    },{"../styles/html-paths":28}],18:[function(require,module,exports){
        var ast = require("./ast");

        exports.freshElement = ast.freshElement;
        exports.nonFreshElement = ast.nonFreshElement;
        exports.elementWithTag = ast.elementWithTag;
        exports.text = ast.text;
        exports.forceWrite = ast.forceWrite;

        exports.simplify = require("./simplify");

        function write(writer, nodes) {
            nodes.forEach(function(node) {
                writeNode(writer, node);
            });
        }

        function writeNode(writer, node) {
            toStrings[node.type](writer, node);
        }

        var toStrings = {
            element: generateElementString,
            text: generateTextString,
            forceWrite: function() { }
        };

        function generateElementString(writer, node) {
            if (ast.isVoidElement(node)) {
                writer.selfClosing(node.tag.tagName, node.tag.attributes);
            } else {
                writer.open(node.tag.tagName, node.tag.attributes);
                write(writer, node.children);
                writer.close(node.tag.tagName);
            }
        }

        function generateTextString(writer, node) {
            writer.text(node.value);
        }

        exports.write = write;

    },{"./ast":17,"./simplify":19}],19:[function(require,module,exports){
        var _ = require("underscore");

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

        function simplify(nodes) {
            return collapse(removeEmpty(nodes));
        }

        function collapse(nodes) {
            var children = [];

            nodes.map(collapseNode).forEach(function(child) {
                appendChild(children, child);
            });
            return children;
        }

        function collapseNode(node) {
            return collapsers[node.type](node);
        }

        var collapsers = {
            element: collapseElement,
            text: identity,
            forceWrite: identity
        };

        function collapseElement(node) {
            return ast.elementWithTag(node.tag, collapse(node.children));
        }

        function identity(value) {
            return value;
        }

        function appendChild(children, child) {
            var lastChild = children[children.length - 1];
            if (child.type === "element" && !child.tag.fresh && lastChild && lastChild.type === "element" && child.tag.matchesElement(lastChild.tag)) {
                if (child.tag.separator) {
                    appendChild(lastChild.children, ast.text(child.tag.separator));
                }
                child.children.forEach(function(grandChild) {
                    // Mutation is fine since simplifying elements create a copy of the children.
                    appendChild(lastChild.children, grandChild);
                });
            } else {
                children.push(child);
            }
        }

        function removeEmpty(nodes) {
            return flatMap(nodes, function(node) {
                return emptiers[node.type](node);
            });
        }

        function flatMap(values, func) {
            return _.flatten(_.map(values, func), true);
        }

        var emptiers = {
            element: elementEmptier,
            text: textEmptier,
            forceWrite: neverEmpty
        };

        function neverEmpty(node) {
            return [node];
        }

        function elementEmptier(element) {
            var children = removeEmpty(element.children);
            if (children.length === 0 && !ast.isVoidElement(element)) {
                return [];
            } else {
                return [ast.elementWithTag(element.tag, children)];
            }
        }

        function textEmptier(node) {
            if (node.value.length === 0) {
                return [];
            } else {
                return [node];
            }
        }

        module.exports = simplify;

    },{"./ast":17,"underscore":122}],20:[function(require,module,exports){
        var _ = require("underscore");

        var promises = require("./promises");
        var Html = require("./html");

        exports.imgElement = imgElement;

        function imgElement(func) {
            return function(element, messages) {
                return promises.when(func(element)).then(function(result) {
                    var attributes = _.clone(result);
                    if (element.altText) {
                        attributes.alt = element.altText;
                    }
                    return [Html.freshElement("img", attributes)];
                });
            };
        }

// Undocumented, but retained for backwards-compatibility with 0.3.x
        exports.inline = exports.imgElement;

        exports.dataUri = imgElement(function(element) {
            return element.read("base64").then(function(imageBuffer) {
                return {
                    src: "data:" + element.contentType + ";base64," + imageBuffer
                };
            });
        });

    },{"./html":18,"./promises":23,"underscore":122}],21:[function(require,module,exports){
        var _ = require("underscore");

        var docxReader = require("./docx/docx-reader");
        var docxStyleMap = require("./docx/style-map");
        var DocumentConverter = require("./document-to-html").DocumentConverter;
        var convertElementToRawText = require("./raw-text").convertElementToRawText;
        var readStyle = require("./style-reader").readStyle;
        var readOptions = require("./options-reader").readOptions;
        var unzip = require("./unzip");
        var Result = require("./results").Result;
        var htmlPaths = require('./styles/html-paths');

        exports.convertToHtml = convertToHtml;
        exports.convertToMarkdown = convertToMarkdown;
        exports.convert = convert;
        exports.extractRawText = extractRawText;
        exports.images = require("./images");
        exports.transforms = require("./transforms");
        exports.underline = require("./underline");
        exports.embedStyleMap = embedStyleMap;
        exports.readEmbeddedStyleMap = readEmbeddedStyleMap;

        function convertToHtml(input, options) {
            return convert(input, options);
        }

        function convertToMarkdown(input, options) {
            var markdownOptions = Object.create(options || {});
            markdownOptions.outputFormat = "markdown";
            return convert(input, markdownOptions);
        }

        function convert(input, options) {
            options = readOptions(options);

            return unzip.openZip(input)
                .tap(function(docxFile) {
                    return docxStyleMap.readStyleMap(docxFile).then(function(styleMap) {
                        options.embeddedStyleMap = styleMap;
                    });
                })
                .then(function(docxFile) {
                    return docxReader.read(docxFile, input)
                        .then(function(documentResult) {
                            return documentResult.map(options.transformDocument);
                        })
                        .then(function(documentResult) {
                            return convertDocumentToHtml(documentResult, options);
                        });
                });
        }

        function readEmbeddedStyleMap(input) {
            return unzip.openZip(input)
                .then(docxStyleMap.readStyleMap);
        }

        function convertDocumentToHtml(documentResult, options) {
            var elementById = {};
            (documentResult.value.children || []).forEach(function(item) {
                item.nodeId = Math.random();
                elementById[item.nodeId] = item;

            });
            htmlPaths.setElementById(elementById);

            var styleMapResult = parseStyleMap(options.readStyleMap());
            var parsedOptions = _.extend({}, options, {
                styleMap: styleMapResult.value
            });
            var documentConverter = new DocumentConverter(parsedOptions);

            return documentResult.flatMapThen(function(document) {
                return styleMapResult.flatMapThen(function(styleMap) {
                    return documentConverter.convertToHtml(document);
                });
            });
        }

        function parseStyleMap(styleMap) {
            return Result.combine((styleMap || []).map(readStyle))
                .map(function(styleMap) {
                    return styleMap.filter(function(styleMapping) {
                        return !!styleMapping;
                    });
                });
        }


        function extractRawText(input) {
            return unzip.openZip(input)
                .then(docxReader.read)
                .then(function(documentResult) {
                    return documentResult.map(convertElementToRawText);
                });
        }

        function embedStyleMap(input, styleMap) {
            return unzip.openZip(input)
                .tap(function(docxFile) {
                    return docxStyleMap.writeStyleMap(docxFile, styleMap);
                })
                .then(function(docxFile) {
                    return docxFile.toBuffer();
                })
                .then(function(buffer) {
                    return {
                        toBuffer: function() {
                            return buffer;
                        }
                    };
                });
        }

        exports.styleMapping = function() {
            throw new Error('Use a raw string instead of mammoth.styleMapping e.g. "p[style-name=\'Title\'] => h1" instead of mammoth.styleMapping("p[style-name=\'Title\'] => h1")');
        };

    },{"./document-to-html":3,"./docx/docx-reader":9,"./docx/style-map":14,"./images":20,"./options-reader":22,"./raw-text":24,"./results":25,"./style-reader":26,"./styles/html-paths":28,"./transforms":30,"./underline":31,"./unzip":2,"underscore":122}],22:[function(require,module,exports){
        exports.readOptions = readOptions;

        var _ = require("underscore");

        var defaultStyleMap = (exports._defaultStyleMap = [
            "p.Heading1 => h1:fresh",
            "p.Heading2 => h2:fresh",
            "p.Heading3 => h3:fresh",
            "p.Heading4 => h4:fresh",
            "p.Heading5 => h5:fresh",
            "p.Heading6 => h6:fresh",
            "p[style-name='Heading 1'] => h1:fresh",
            "p[style-name='Heading 2'] => h2:fresh",
            "p[style-name='Heading 3'] => h3:fresh",
            "p[style-name='Heading 4'] => h4:fresh",
            "p[style-name='Heading 5'] => h5:fresh",
            "p[style-name='Heading 6'] => h6:fresh",
            "p[style-name='heading 1'] => h1:fresh",
            "p[style-name='heading 2'] => h2:fresh",
            "p[style-name='heading 3'] => h3:fresh",
            "p[style-name='heading 4'] => h4:fresh",
            "p[style-name='heading 5'] => h5:fresh",
            "p[style-name='heading 6'] => h6:fresh",

            "r[style-name='Strong'] => strong",

            "p[style-name='footnote text'] => p:fresh",
            "r[style-name='footnote reference'] =>",
            "p[style-name='endnote text'] => p:fresh",
            "r[style-name='endnote reference'] =>",
            "p[style-name='annotation text'] => p:fresh",
            "r[style-name='annotation reference'] =>",

            // LibreOffice
            "p[style-name='Footnote'] => p:fresh",
            "r[style-name='Footnote anchor'] =>",
            "p[style-name='Endnote'] => p:fresh",
            "r[style-name='Endnote anchor'] =>",

            "p:unordered-list(1) => ul > li:fresh",
            "p:unordered-list(2) => ul|ol > li > ul > li:fresh",
            "p:unordered-list(3) => ul|ol > li > ul|ol > li > ul > li:fresh",
            "p:unordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh",
            "p:unordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ul > li:fresh",
            "p:ordered-list(1) => ol > li:fresh",
            "p:ordered-list(2) => ul|ol > li > ol > li:fresh",
            "p:ordered-list(3) => ul|ol > li > ul|ol > li > ol > li:fresh",
            "p:ordered-list(4) => ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh",
            "p:ordered-list(5) => ul|ol > li > ul|ol > li > ul|ol > li > ul|ol > li > ol > li:fresh",

            "r[style-name='Hyperlink'] =>",

            "p[style-name='Normal'] => p:fresh"
        ]);

        var standardOptions = (exports._standardOptions = {
            transformDocument: identity,
            includeDefaultStyleMap: true,
            includeEmbeddedStyleMap: true
        });

        function readOptions(options) {
            options = options || {};
            return _.extend({}, standardOptions, options, {
                customStyleMap: readStyleMap(options.styleMap),
                readStyleMap: function() {
                    var styleMap = this.customStyleMap;
                    if (this.includeEmbeddedStyleMap) {
                        styleMap = styleMap.concat(readStyleMap(this.embeddedStyleMap));
                    }
                    if (this.includeDefaultStyleMap) {
                        styleMap = styleMap.concat(defaultStyleMap);
                    }
                    return styleMap;
                }
            });
        }

        function readStyleMap(styleMap) {
            if (!styleMap) {
                return [];
            } else if (_.isString(styleMap)) {
                return styleMap
                    .split("\n")
                    .map(function(line) {
                        return line.trim();
                    })
                    .filter(function(line) {
                        return line !== "" && line.charAt(0) !== "#";
                    });
            } else {
                return styleMap;
            }
        }

        function identity(value) {
            return value;
        }

    },{"underscore":122}],23:[function(require,module,exports){
        var _ = require("underscore");
        var bluebird = require("bluebird/js/release/promise")();

        exports.defer = defer;
        exports.when = bluebird.resolve;
        exports.resolve = bluebird.resolve;
        exports.all = bluebird.all;
        exports.props = bluebird.props;
        exports.reject = bluebird.reject;
        exports.promisify = bluebird.promisify;
        exports.mapSeries = bluebird.mapSeries;
        exports.attempt = bluebird.attempt;

        exports.nfcall = function(func) {
            var args = Array.prototype.slice.call(arguments, 1);
            var promisedFunc = bluebird.promisify(func);
            return promisedFunc.apply(null, args);
        };

        bluebird.prototype.fail = bluebird.prototype.caught;

        bluebird.prototype.also = function(func) {
            return this.then(function(value) {
                var returnValue = _.extend({}, value, func(value));
                return bluebird.props(returnValue);
            });
        };

        function defer() {
            var resolve;
            var reject;
            var promise = new bluebird.Promise(function(resolveArg, rejectArg) {
                resolve = resolveArg;
                reject = rejectArg;
            });

            return {
                resolve: resolve,
                reject: reject,
                promise: promise
            };
        }

    },{"bluebird/js/release/promise":61,"underscore":122}],24:[function(require,module,exports){
        var documents = require("./documents");

        function convertElementToRawText(element) {
            if (element.type === "text") {
                return element.value;
            } else if (element.type === documents.types.tab) {
                return "\t";
            } else {
                var tail = element.type === "paragraph" ? "\n\n" : "";
                return (element.children || []).map(convertElementToRawText).join("") + tail;
            }
        }

        exports.convertElementToRawText = convertElementToRawText;

    },{"./documents":4}],25:[function(require,module,exports){
        var _ = require("underscore");


        exports.Result = Result;
        exports.success = success;
        exports.warning = warning;
        exports.error = error;


        function Result(value, messages) {
            this.value = value;
            this.messages = messages || [];
        }

        Result.prototype.map = function(func) {
            return new Result(func(this.value), this.messages);
        };

        Result.prototype.flatMap = function(func) {
            var funcResult = func(this.value);
            return new Result(funcResult.value, combineMessages([this, funcResult]));
        };

        Result.prototype.flatMapThen = function(func) {
            var that = this;
            return func(this.value).then(function(otherResult) {
                return new Result(otherResult.value, combineMessages([that, otherResult]));
            });
        };

        Result.combine = function(results) {
            var values = _.flatten(_.pluck(results, "value"));
            var messages = combineMessages(results);
            return new Result(values, messages);
        };

        function success(value) {
            return new Result(value, []);
        }

        function warning(message) {
            return {
                type: "warning",
                message: message
            };
        }

        function error(exception) {
            return {
                type: "error",
                message: exception.message,
                error: exception
            };
        }

        function combineMessages(results) {
            var messages = [];
            _.flatten(_.pluck(results, "messages"), true).forEach(function(message) {
                if (!containsMessage(messages, message)) {
                    messages.push(message);
                }
            });
            return messages;
        }

        function containsMessage(messages, message) {
            return _.find(messages, isSameMessage.bind(null, message)) !== undefined;
        }

        function isSameMessage(first, second) {
            return first.type === second.type && first.message === second.message;
        }

    },{"underscore":122}],26:[function(require,module,exports){
        var _ = require("underscore");
        var lop = require("lop");

        var documentMatchers = require("./styles/document-matchers");
        var htmlPaths = require("./styles/html-paths");
        var tokenise = require("./styles/parser/tokeniser").tokenise;
        var results = require("./results");

        exports.readHtmlPath = readHtmlPath;
        exports.readDocumentMatcher = readDocumentMatcher;
        exports.readStyle = readStyle;


        function readStyle(string) {
            return parseString(styleRule, string);
        }

        function createStyleRule() {
            return lop.rules.sequence(
                lop.rules.sequence.capture(documentMatcherRule()),
                lop.rules.tokenOfType("whitespace"),
                lop.rules.tokenOfType("arrow"),
                lop.rules.sequence.capture(lop.rules.optional(lop.rules.sequence(
                    lop.rules.tokenOfType("whitespace"),
                    lop.rules.sequence.capture(htmlPathRule())
                ).head())),
                lop.rules.tokenOfType("end")
            ).map(function(documentMatcher, htmlPath) {
                return {
                    from: documentMatcher,
                    to: htmlPath.valueOrElse(htmlPaths.empty)
                };
            });
        }

        function readDocumentMatcher(string) {
            return parseString(documentMatcherRule(), string);
        }

        function documentMatcherRule() {
            var sequence = lop.rules.sequence;

            var identifierToConstant = function(identifier, constant) {
                return lop.rules.then(
                    lop.rules.token("identifier", identifier),
                    function() {
                        return constant;
                    }
                );
            };

            var paragraphRule = identifierToConstant("p", documentMatchers.paragraph);
            var runRule = identifierToConstant("r", documentMatchers.run);

            var elementTypeRule = lop.rules.firstOf("p or r or table",
                paragraphRule,
                runRule
            );

            var styleIdRule = lop.rules.then(
                classRule,
                function(styleId) {
                    return {styleId: styleId};
                }
            );

            var styleNameMatcherRule = lop.rules.firstOf("style name matcher",
                lop.rules.then(
                    lop.rules.sequence(
                        lop.rules.tokenOfType("equals"),
                        lop.rules.sequence.cut(),
                        lop.rules.sequence.capture(stringRule)
                    ).head(),
                    function(styleName) {
                        return {styleName: documentMatchers.equalTo(styleName)};
                    }
                ),
                lop.rules.then(
                    lop.rules.sequence(
                        lop.rules.tokenOfType("startsWith"),
                        lop.rules.sequence.cut(),
                        lop.rules.sequence.capture(stringRule)
                    ).head(),
                    function(styleName) {
                        return {styleName: documentMatchers.startsWith(styleName)};
                    }
                )
            );

            var styleNameRule = lop.rules.sequence(
                lop.rules.tokenOfType("open-square-bracket"),
                lop.rules.sequence.cut(),
                lop.rules.token("identifier", "style-name"),
                lop.rules.sequence.capture(styleNameMatcherRule),
                lop.rules.tokenOfType("close-square-bracket")
            ).head();


            var listTypeRule = lop.rules.firstOf("list type",
                identifierToConstant("ordered-list", {isOrdered: true}),
                identifierToConstant("unordered-list", {isOrdered: false})
            );
            var listRule = sequence(
                lop.rules.tokenOfType("colon"),
                sequence.capture(listTypeRule),
                sequence.cut(),
                lop.rules.tokenOfType("open-paren"),
                sequence.capture(integerRule),
                lop.rules.tokenOfType("close-paren")
            ).map(function(listType, levelNumber) {
                return {
                    list: {
                        isOrdered: listType.isOrdered,
                        levelIndex: levelNumber - 1
                    }
                };
            });

            function createMatcherSuffixesRule(rules) {
                var matcherSuffix = lop.rules.firstOf.apply(
                    lop.rules.firstOf,
                    ["matcher suffix"].concat(rules)
                );
                var matcherSuffixes = lop.rules.zeroOrMore(matcherSuffix);
                return lop.rules.then(matcherSuffixes, function(suffixes) {
                    var matcherOptions = {};
                    suffixes.forEach(function(suffix) {
                        _.extend(matcherOptions, suffix);
                    });
                    return matcherOptions;
                });
            }

            var paragraphOrRun = sequence(
                sequence.capture(elementTypeRule),
                sequence.capture(createMatcherSuffixesRule([
                    styleIdRule,
                    styleNameRule,
                    listRule
                ]))
            ).map(function(createMatcher, matcherOptions) {
                return createMatcher(matcherOptions);
            });

            var table = sequence(
                lop.rules.token("identifier", "table"),
                sequence.capture(createMatcherSuffixesRule([
                    styleIdRule,
                    styleNameRule
                ]))
            ).map(function(options) {
                return documentMatchers.table(options);
            });

            var bold = identifierToConstant("b", documentMatchers.bold);
            var italic = identifierToConstant("i", documentMatchers.italic);
            var underline = identifierToConstant("u", documentMatchers.underline);
            var strikethrough = identifierToConstant("strike", documentMatchers.strikethrough);
            var allCaps = identifierToConstant("all-caps", documentMatchers.allCaps);
            var smallCaps = identifierToConstant("small-caps", documentMatchers.smallCaps);
            var commentReference = identifierToConstant("comment-reference", documentMatchers.commentReference);

            var breakMatcher = sequence(
                lop.rules.token("identifier", "br"),
                sequence.cut(),
                lop.rules.tokenOfType("open-square-bracket"),
                lop.rules.token("identifier", "type"),
                lop.rules.tokenOfType("equals"),
                sequence.capture(stringRule),
                lop.rules.tokenOfType("close-square-bracket")
            ).map(function(breakType) {
                switch (breakType) {
                    case "line":
                        return documentMatchers.lineBreak;
                    case "page":
                        return documentMatchers.pageBreak;
                    case "column":
                        return documentMatchers.columnBreak;
                    default:
                    // TODO: handle unknown document matchers
                }
            });

            return lop.rules.firstOf("element type",
                paragraphOrRun,
                table,
                bold,
                italic,
                underline,
                strikethrough,
                allCaps,
                smallCaps,
                commentReference,
                breakMatcher
            );
        }

        function readHtmlPath(string) {
            return parseString(htmlPathRule(), string);
        }

        function htmlPathRule() {
            var capture = lop.rules.sequence.capture;
            var whitespaceRule = lop.rules.tokenOfType("whitespace");
            var freshRule = lop.rules.then(
                lop.rules.optional(lop.rules.sequence(
                    lop.rules.tokenOfType("colon"),
                    lop.rules.token("identifier", "fresh")
                )),
                function(option) {
                    return option.map(function() {
                        return true;
                    }).valueOrElse(false);
                }
            );

            var separatorRule = lop.rules.then(
                lop.rules.optional(lop.rules.sequence(
                    lop.rules.tokenOfType("colon"),
                    lop.rules.token("identifier", "separator"),
                    lop.rules.tokenOfType("open-paren"),
                    capture(stringRule),
                    lop.rules.tokenOfType("close-paren")
                ).head()),
                function(option) {
                    return option.valueOrElse("");
                }
            );

            var tagNamesRule = lop.rules.oneOrMoreWithSeparator(
                identifierRule,
                lop.rules.tokenOfType("choice")
            );

            var styleElementRule = lop.rules.sequence(
                capture(tagNamesRule),
                capture(lop.rules.zeroOrMore(classRule)),
                capture(freshRule),
                capture(separatorRule)
            ).map(function(tagName, classNames, fresh, separator) {
                var attributes = {};
                var options = {};
                if (classNames.length > 0) {
                    attributes["class"] = classNames.join(" ");
                }
                if (fresh) {
                    options.fresh = true;
                }
                if (separator) {
                    options.separator = separator;
                }
                return htmlPaths.element(tagName, attributes, options);
            });

            return lop.rules.firstOf("html path",
                lop.rules.then(lop.rules.tokenOfType("bang"), function() {
                    return htmlPaths.ignore;
                }),
                lop.rules.then(
                    lop.rules.zeroOrMoreWithSeparator(
                        styleElementRule,
                        lop.rules.sequence(
                            whitespaceRule,
                            lop.rules.tokenOfType("gt"),
                            whitespaceRule
                        )
                    ),
                    htmlPaths.elements
                )
            );
        }

        var identifierRule = lop.rules.then(
            lop.rules.tokenOfType("identifier"),
            decodeEscapeSequences
        );
        var integerRule = lop.rules.tokenOfType("integer");

        var stringRule = lop.rules.then(
            lop.rules.tokenOfType("string"),
            decodeEscapeSequences
        );

        var escapeSequences = {
            "n": "\n",
            "r": "\r",
            "t": "\t"
        };

        function decodeEscapeSequences(value) {
            return value.replace(/\\(.)/g, function(match, code) {
                return escapeSequences[code] || code;
            });
        }

        var classRule = lop.rules.sequence(
            lop.rules.tokenOfType("dot"),
            lop.rules.sequence.cut(),
            lop.rules.sequence.capture(identifierRule)
        ).head();

        function parseString(rule, string) {
            var tokens = tokenise(string);
            var parser = lop.Parser();
            var parseResult = parser.parseTokens(rule, tokens);
            if (parseResult.isSuccess()) {
                return results.success(parseResult.value());
            } else {
                return new results.Result(null, [results.warning(describeFailure(string, parseResult))]);
            }
        }

        function describeFailure(input, parseResult) {
            return "Did not understand this style mapping, so ignored it: " + input + "\n" +
                parseResult.errors().map(describeError).join("\n");
        }

        function describeError(error) {
            return "Error was at character number " + error.characterNumber() + ": " +
                "Expected " + error.expected + " but got " + error.actual;
        }

        var styleRule = createStyleRule();

    },{"./results":25,"./styles/document-matchers":27,"./styles/html-paths":28,"./styles/parser/tokeniser":29,"lop":88,"underscore":122}],27:[function(require,module,exports){
        exports.paragraph = paragraph;
        exports.run = run;
        exports.table = table;
        exports.bold = new Matcher("bold");
        exports.italic = new Matcher("italic");
        exports.underline = new Matcher("underline");
        exports.strikethrough = new Matcher("strikethrough");
        exports.allCaps = new Matcher("allCaps");
        exports.smallCaps = new Matcher("smallCaps");
        exports.commentReference = new Matcher("commentReference");
        exports.lineBreak = new Matcher("break", {breakType: "line"});
        exports.pageBreak = new Matcher("break", {breakType: "page"});
        exports.columnBreak = new Matcher("break", {breakType: "column"});
        exports.equalTo = equalTo;
        exports.startsWith = startsWith;


        function paragraph(options) {
            return new Matcher("paragraph", options);
        }

        function run(options) {
            return new Matcher("run", options);
        }

        function table(options) {
            return new Matcher("table", options);
        }

        function Matcher(elementType, options) {
            options = options || {};
            this._elementType = elementType;
            this._styleId = options.styleId;
            this._styleName = options.styleName;
            if (options.list) {
                this._listIndex = options.list.levelIndex;
                this._listIsOrdered = options.list.isOrdered;
            }
        }

        Matcher.prototype.matches = function(element) {
            return element.type === this._elementType &&
                (this._styleId === undefined || element.styleId === this._styleId) &&
                (this._styleName === undefined || (element.styleName && this._styleName.operator(this._styleName.operand, element.styleName))) &&
                (this._listIndex === undefined || isList(element, this._listIndex, this._listIsOrdered)) &&
                (this._breakType === undefined || this._breakType === element.breakType);
        };

        function isList(element, levelIndex, isOrdered) {
            return element.numbering &&
                element.numbering.level == levelIndex &&
                element.numbering.isOrdered == isOrdered;
        }

        function equalTo(value) {
            return {
                operator: operatorEqualTo,
                operand: value
            };
        }

        function startsWith(value) {
            return {
                operator: operatorStartsWith,
                operand: value
            };
        }

        function operatorEqualTo(first, second) {
            return first.toUpperCase() === second.toUpperCase();
        }

        function operatorStartsWith(first, second) {
            return second.toUpperCase().indexOf(first.toUpperCase()) === 0;
        }

    },{}],28:[function(require,module,exports){
        var _ = require("underscore");

        var html = require("../html");
        var documentToHtml = require('../document-to-html');
        var cloneDeep = require('lodash').cloneDeep;
        exports.topLevelElement = topLevelElement;
        exports.elements = elements;
        exports.element = element;
        exports.setElementById = setElementById;

        var elementById = {};

        function setElementById(data){
            elementById = data;
        }
        function topLevelElement(tagName, attributes) {
            return elements([element(tagName, attributes, {fresh: true})]);
        }

        function elements(elementStyles) {
            return new HtmlPath(elementStyles.map(function(elementStyle) {
                if (_.isString(elementStyle)) {
                    return element(elementStyle);
                } else {
                    return elementStyle;
                }
            }));
        }

        function HtmlPath(elements) {
            this._elements = elements;
        }

        HtmlPath.prototype.wrap = function wrap(children, element) {
            var result = children();
            for (var index = this._elements.length - 1; index >= 0; index--) {
                result = this._elements[index].wrapNodes(result, element);
            }
            return result;
        };

        function element(tagName, attributes, options) {
            options = options || {};
            return new Element(tagName, attributes, options);
        }

        function Element(tagName, attributes, options) {
            var tagNames = {};
            if (_.isArray(tagName)) {
                tagName.forEach(function(tagName) {
                    tagNames[tagName] = true;
                });
                tagName = tagName[0];
            } else {
                tagNames[tagName] = true;
            }

            this.tagName = tagName;
            this.tagNames = tagNames;
            this.attributes = attributes || {};
            this.fresh = options.fresh;
            this.separator = options.separator;
        }

        Element.prototype.matchesElement = function(element) {
            return this.tagNames[element.tagName] && _.isEqual(this.attributes || {}, element.attributes || {});
        };

        Element.prototype.wrap = function wrap(generateNodes) {
            return this.wrapNodes(generateNodes());
        };

        Element.prototype.wrapNodes = function wrapNodes(nodes, element) {
            this.attributes.b = 'liyulin';
            var nodeId = element && element.nodeId || '';
            var attributes = {};
            if (nodeId && elementById && elementById[nodeId]){
                attributes = documentToHtml.convertStyleForAttributes(elementById[nodeId], {});
            }
            var that = cloneDeep(this);
            that.attributes.style =  (this.attributes.style || '') + (attributes.style || '');
            return [html.elementWithTag(that, nodes)];
        };

        exports.empty = elements([]);
        exports.ignore = {
            wrap: function() {
                return [];
            }
        };

    },{"../document-to-html":3,"../html":18,"lodash":87,"underscore":122}],29:[function(require,module,exports){
        var lop = require("lop");
        var RegexTokeniser = lop.RegexTokeniser;

        exports.tokenise = tokenise;

        var stringPrefix = "'((?:\\\\.|[^'])*)";

        function tokenise(string) {
            var identifierCharacter = "(?:[a-zA-Z\\-_]|\\\\.)";
            var tokeniser = new RegexTokeniser([
                {name: "identifier", regex: new RegExp("(" + identifierCharacter + "(?:" + identifierCharacter + "|[0-9])*)")},
                {name: "dot", regex: /\./},
                {name: "colon", regex: /:/},
                {name: "gt", regex: />/},
                {name: "whitespace", regex: /\s+/},
                {name: "arrow", regex: /=>/},
                {name: "equals", regex: /=/},
                {name: "startsWith", regex: /\^=/},
                {name: "open-paren", regex: /\(/},
                {name: "close-paren", regex: /\)/},
                {name: "open-square-bracket", regex: /\[/},
                {name: "close-square-bracket", regex: /\]/},
                {name: "string", regex: new RegExp(stringPrefix + "'")},
                {name: "unterminated-string", regex: new RegExp(stringPrefix)},
                {name: "integer", regex: /([0-9]+)/},
                {name: "choice", regex: /\|/},
                {name: "bang", regex: /(!)/}
            ]);
            return tokeniser.tokenise(string);
        }

    },{"lop":88}],30:[function(require,module,exports){
        var _ = require("underscore");

        exports.paragraph = paragraph;
        exports.run = run;
        exports._elements = elements;
        exports.getDescendantsOfType = getDescendantsOfType;
        exports.getDescendants = getDescendants;

        function paragraph(transform) {
            return elementsOfType("paragraph", transform);
        }

        function run(transform) {
            return elementsOfType("run", transform);
        }

        function elementsOfType(elementType, transform) {
            return elements(function(element) {
                if (element.type === elementType) {
                    return transform(element);
                } else {
                    return element;
                }
            });
        }

        function elements(transform) {
            return function transformElement(element) {
                if (element.children) {
                    var children = _.map(element.children, transformElement);
                    element = _.extend(element, {children: children});
                }
                return transform(element);
            };
        }


        function getDescendantsOfType(element, type) {
            return getDescendants(element).filter(function(descendant) {
                return descendant.type === type;
            });
        }

        function getDescendants(element) {
            var descendants = [];

            visitDescendants(element, function(descendant) {
                descendants.push(descendant);
            });

            return descendants;
        }

        function visitDescendants(element, visit) {
            if (element.children) {
                element.children.forEach(function(child) {
                    visitDescendants(child, visit);
                    visit(child);
                });
            }
        }

    },{"underscore":122}],31:[function(require,module,exports){
        var htmlPaths = require("./styles/html-paths");
        var Html = require("./html");


        exports.element = element;

        function element(name) {
            return function(html) {
                return Html.elementWithTag(htmlPaths.element(name), [html]);
            };
        }

    },{"./html":18,"./styles/html-paths":28}],32:[function(require,module,exports){
        var util = require("util");
        var _ = require("underscore");

        exports.writer = writer;

        function writer(options) {
            options = options || {};
            if (options.prettyPrint) {
                return prettyWriter();
            } else {
                return simpleWriter();
            }
        }


        var indentedElements = {
            div: true,
            p: true,
            ul: true,
            li: true
        };


        function prettyWriter() {
            var indentationLevel = 0;
            var indentation = "  ";
            var stack = [];
            var start = true;
            var inText = false;

            var writer = simpleWriter();

            function open(tagName, attributes) {
                if (indentedElements[tagName]) {
                    indent();
                }
                stack.push(tagName);
                writer.open(tagName, attributes);
                if (indentedElements[tagName]) {
                    indentationLevel++;
                }
                start = false;
            }

            function close(tagName) {
                if (indentedElements[tagName]) {
                    indentationLevel--;
                    indent();
                }
                stack.pop();
                writer.close(tagName);
            }

            function text(value) {
                startText();
                var text = isInPre() ? value : value.replace("\n", "\n" + indentation);
                writer.text(text);
            }

            function selfClosing(tagName, attributes) {
                indent();
                writer.selfClosing(tagName, attributes);
            }

            function insideIndentedElement() {
                return stack.length === 0 || indentedElements[stack[stack.length - 1]];
            }

            function startText() {
                if (!inText) {
                    indent();
                    inText = true;
                }
            }

            function indent() {
                inText = false;
                if (!start && insideIndentedElement() && !isInPre()) {
                    writer._append("\n");
                    for (var i = 0; i < indentationLevel; i++) {
                        writer._append(indentation);
                    }
                }
            }

            function isInPre() {
                return _.some(stack, function(tagName) {
                    return tagName === "pre";
                });
            }

            return {
                asString: writer.asString,
                open: open,
                close: close,
                text: text,
                selfClosing: selfClosing
            };
        }


        function simpleWriter() {
            var fragments = [];

            function open(tagName, attributes) {
                var attributeString = generateAttributeString(attributes);
                fragments.push(util.format("<%s%s>", tagName, attributeString));
            }

            function close(tagName) {
                fragments.push(util.format("</%s>", tagName));
            }

            function selfClosing(tagName, attributes) {
                var attributeString = generateAttributeString(attributes);
                fragments.push(util.format("<%s%s />", tagName, attributeString));
            }

            function generateAttributeString(attributes) {
                return _.map(attributes, function(value, key) {
                    return util.format(' %s="%s"', key, escapeHtmlAttribute(value));
                }).join("");
            }

            function text(value) {
                fragments.push(escapeHtmlText(value));
            }

            function append(html) {
                fragments.push(html);
            }

            function asString() {
                return fragments.join("");
            }

            return {
                asString: asString,
                open: open,
                close: close,
                text: text,
                selfClosing: selfClosing,
                _append: append
            };
        }

        function escapeHtmlText(value) {
            return value
                .replace(/&/g, '&amp;')
                .replace(/</g, '&lt;')
                .replace(/>/g, '&gt;');
        }

        function escapeHtmlAttribute(value) {
            return value
                .replace(/&/g, '&amp;')
                .replace(/"/g, '&quot;')
                .replace(/</g, '&lt;')
                .replace(/>/g, '&gt;');
        }

    },{"underscore":122,"util":125}],33:[function(require,module,exports){
        var htmlWriter = require("./html-writer");
        var markdownWriter = require("./markdown-writer");

        exports.writer = writer;


        function writer(options) {
            options = options || {};
            if (options.outputFormat === "markdown") {
                return markdownWriter.writer();
            } else {
                return htmlWriter.writer(options);
            }
        }

    },{"./html-writer":32,"./markdown-writer":34}],34:[function(require,module,exports){
        var _ = require("underscore");


        function symmetricMarkdownElement(end) {
            return markdownElement(end, end);
        }

        function markdownElement(start, end) {
            return function() {
                return {start: start, end: end};
            };
        }

        function markdownLink(attributes) {
            var href = attributes.href || "";
            if (href) {
                return {
                    start: "[",
                    end: "](" + href + ")",
                    anchorPosition: "before"
                };
            } else {
                return {};
            }
        }

        function markdownImage(attributes) {
            var src = attributes.src || "";
            var altText = attributes.alt || "";
            if (src || altText) {
                return {start: "![" + altText + "](" + src + ")"};
            } else {
                return {};
            }
        }

        function markdownList(options) {
            return function(attributes, list) {
                return {
                    start: list ? "\n" : "",
                    end: list ? "" : "\n",
                    list: {
                        isOrdered: options.isOrdered,
                        indent: list ? list.indent + 1 : 0,
                        count: 0
                    }
                };
            };
        }

        function markdownListItem(attributes, list, listItem) {
            list = list || {indent: 0, isOrdered: false, count: 0};
            list.count++;
            listItem.hasClosed = false;

            var bullet = list.isOrdered ? list.count + "." : "-";
            var start = repeatString("\t", list.indent) + bullet + " ";

            return {
                start: start,
                end: function() {
                    if (!listItem.hasClosed) {
                        listItem.hasClosed = true;
                        return "\n";
                    }
                }
            };
        }

        var htmlToMarkdown = {
            "p": markdownElement("", "\n\n"),
            "br": markdownElement("", "  \n"),
            "ul": markdownList({isOrdered: false}),
            "ol": markdownList({isOrdered: true}),
            "li": markdownListItem,
            "strong": symmetricMarkdownElement("__"),
            "em": symmetricMarkdownElement("*"),
            "a": markdownLink,
            "img": markdownImage
        };

        (function() {
            for (var i = 1; i <= 6; i++) {
                htmlToMarkdown["h" + i] = markdownElement(repeatString("#", i) + " ", "\n\n");
            }
        })();

        function repeatString(value, count) {
            return new Array(count + 1).join(value);
        }

        function markdownWriter() {
            var fragments = [];
            var elementStack = [];
            var list = null;
            var listItem = {};

            function open(tagName, attributes) {
                attributes = attributes || {};

                var createElement = htmlToMarkdown[tagName] || function() {
                    return {};
                };
                var element = createElement(attributes, list, listItem);
                elementStack.push({end: element.end, list: list});

                if (element.list) {
                    list = element.list;
                }

                var anchorBeforeStart = element.anchorPosition === "before";
                if (anchorBeforeStart) {
                    writeAnchor(attributes);
                }

                fragments.push(element.start || "");
                if (!anchorBeforeStart) {
                    writeAnchor(attributes);
                }
            }

            function writeAnchor(attributes) {
                if (attributes.id) {
                    fragments.push('<a id="' + attributes.id + '"></a>');
                }
            }

            function close(tagName) {
                var element = elementStack.pop();
                list = element.list;
                var end = _.isFunction(element.end) ? element.end() : element.end;
                fragments.push(end || "");
            }

            function selfClosing(tagName, attributes) {
                open(tagName, attributes);
                close(tagName);
            }

            function text(value) {
                fragments.push(escapeMarkdown(value));
            }

            function asString() {
                return fragments.join("");
            }

            return {
                asString: asString,
                open: open,
                close: close,
                text: text,
                selfClosing: selfClosing
            };
        }

        exports.writer = markdownWriter;

        function escapeMarkdown(value) {
            return value
                .replace(/\\/g, '\\\\')
                .replace(/([\`\*_\{\}\[\]\(\)\#\+\-\.\!])/g, '\\$1');
        }

    },{"underscore":122}],35:[function(require,module,exports){
        var nodes = require("./nodes");

        exports.Element = nodes.Element;
        exports.element = nodes.element;
        exports.text = nodes.text;
        exports.readString = require("./reader").readString;
        exports.writeString = require("./writer").writeString;

    },{"./nodes":36,"./reader":37,"./writer":38}],36:[function(require,module,exports){
        var _ = require("underscore");


        exports.Element = Element;
        exports.element = function(name, attributes, children) {
            return new Element(name, attributes, children);
        };
        exports.text = function(value) {
            return {
                type: "text",
                value: value
            };
        };


        var emptyElement = {
            first: function() {
                return null;
            },
            firstOrEmpty: function() {
                return emptyElement;
            },
            attributes: {}
        };

        function Element(name, attributes, children) {
            this.type = "element";
            this.name = name;
            this.attributes = attributes || {};
            this.children = children || [];
        }

        Element.prototype.first = function(name) {
            return _.find(this.children, function(child) {
                return child.name === name;
            });
        };

        Element.prototype.firstOrEmpty = function(name) {
            return this.first(name) || emptyElement;
        };

        Element.prototype.getElementsByTagName = function(name) {
            var elements = _.filter(this.children, function(child) {
                return child.name === name;
            });
            return toElementList(elements);
        };

        Element.prototype.text = function() {
            if (this.children.length === 0) {
                return "";
            } else if (this.children.length !== 1 || this.children[0].type !== "text") {
                throw new Error("Not implemented");
            }
            return this.children[0].value;
        };

        var elementListPrototype = {
            getElementsByTagName: function(name) {
                return toElementList(_.flatten(this.map(function(element) {
                    return element.getElementsByTagName(name);
                }, true)));
            }
        };

        function toElementList(array) {
            return _.extend(array, elementListPrototype);
        }

    },{"underscore":122}],37:[function(require,module,exports){
        var promises = require("../promises");
        var sax = require("sax");
        var _ = require("underscore");

        var nodes = require("./nodes");
        var Element = nodes.Element;

        exports.readString = readString;

        function readString(xmlString, namespaceMap) {
            namespaceMap = namespaceMap || {};

            var finished = false;
            var parser = sax.parser(true, {xmlns: true, position: false});

            var rootElement = {children: []};
            var currentElement = rootElement;
            var stack = [];

            var deferred = promises.defer();

            parser.onopentag = function(node) {
                var attributes = mapObject(node.attributes, function(attribute) {
                    return attribute.value;
                }, mapName);

                var element = new Element(mapName(node), attributes);
                currentElement.children.push(element);
                stack.push(currentElement);
                currentElement = element;
            };

            function mapName(node) {
                if (node.uri) {
                    var mappedPrefix = namespaceMap[node.uri];
                    var prefix;
                    if (mappedPrefix) {
                        prefix = mappedPrefix + ":";
                    } else {
                        prefix = "{" + node.uri + "}";
                    }
                    return prefix + node.local;
                } else {
                    return node.local;
                }
            }

            parser.onclosetag = function(node) {
                currentElement = stack.pop();
            };

            parser.ontext = function(text) {
                if (currentElement !== rootElement) {
                    currentElement.children.push(nodes.text(text));
                }
            };

            parser.onend = function() {
                if (!finished) {
                    finished = true;
                    deferred.resolve(rootElement.children[0]);
                }
            };

            parser.onerror = function(error) {
                if (!finished) {
                    finished = true;
                    deferred.reject(error);
                }
            };

            parser.write(xmlString).close();

            return deferred.promise;
        }

        function mapObject(input, valueFunc, keyFunc) {
            return _.reduce(input, function(result, value, key) {
                var mappedKey = keyFunc(value, key, input);
                result[mappedKey] = valueFunc(value, key, input);
                return result;
            }, {});
        }

    },{"../promises":23,"./nodes":36,"sax":117,"underscore":122}],38:[function(require,module,exports){
        var _ = require("underscore");
        var xmlbuilder = require("xmlbuilder");


        exports.writeString = writeString;


        function writeString(root, namespaces) {
            var uriToPrefix = _.invert(namespaces);

            var nodeWriters = {
                element: writeElement,
                text: writeTextNode
            };

            function writeNode(builder, node) {
                return nodeWriters[node.type](builder, node);
            }

            function writeElement(builder, element) {
                var elementBuilder = builder.element(mapElementName(element.name), element.attributes);
                element.children.forEach(function(child) {
                    writeNode(elementBuilder, child);
                });
            }

            function mapElementName(name) {
                var longFormMatch = /^\{(.*)\}(.*)$/.exec(name);
                if (longFormMatch) {
                    var prefix = uriToPrefix[longFormMatch[1]];
                    return prefix + (prefix === "" ? "" : ":") + longFormMatch[2];
                } else {
                    return name;
                }
            }

            function writeDocument(root) {
                var builder = xmlbuilder
                    .create(mapElementName(root.name), {
                        version: '1.0',
                        encoding: 'UTF-8',
                        standalone: true
                    });

                _.forEach(namespaces, function(uri, prefix) {
                    var key = "xmlns" + (prefix === "" ? "" : ":" + prefix);
                    builder.attribute(key, uri);
                });

                root.children.forEach(function(child) {
                    writeNode(builder, child);
                });
                return builder.end();
            }

            return writeDocument(root);
        }

        function writeTextNode(builder, node) {
            builder.text(node.value);
        }

    },{"underscore":122,"xmlbuilder":148}],39:[function(require,module,exports){
        (function (Buffer){(function (){
            var JSZip = require("jszip");

            exports.openArrayBuffer = openArrayBuffer;
            exports.splitPath = splitPath;
            exports.joinPath = joinPath;

            function openArrayBuffer(arrayBuffer) {
                return JSZip.loadAsync(arrayBuffer).then(function(zipFile) {
                    function exists(name) {
                        return zipFile.file(name) !== null;
                    }

                    function read(name, encoding) {
                        return zipFile.file(name).async("uint8array").then(function(array) {
                            var buffer = uint8ArrayToBuffer(array);
                            if (encoding) {
                                return buffer.toString(encoding);
                            } else {
                                return buffer;
                            }
                        });
                    }

                    function write(name, contents) {
                        zipFile.file(name, contents);
                    }

                    function toBuffer() {
                        return zipFile.generateAsync({type: "nodebuffer"});
                    }

                    return {
                        exists: exists,
                        read: read,
                        write: write,
                        toBuffer: toBuffer
                    };
                });
            }

            function uint8ArrayToBuffer(array) {
                if (Buffer.from && Buffer.from !== Uint8Array.from) {
                    return Buffer.from(array);
                } else {
                    return new Buffer(array);
                }
            }

            function splitPath(path) {
                var lastIndex = path.lastIndexOf("/");
                if (lastIndex === -1) {
                    return {dirname: "", basename: path};
                } else {
                    return {
                        dirname: path.substring(0, lastIndex),
                        basename: path.substring(lastIndex + 1)
                    };
                }
            }

            function joinPath() {
                var nonEmptyPaths = Array.prototype.filter.call(arguments, function(path) {
                    return path;
                });

                var relevantPaths = [];

                nonEmptyPaths.forEach(function(path) {
                    if (/^\//.test(path)) {
                        relevantPaths = [path];
                    } else {
                        relevantPaths.push(path);
                    }
                });

                return relevantPaths.join("/");
            }

        }).call(this)}).call(this,require("buffer").Buffer)
    },{"buffer":77,"jszip":86}],40:[function(require,module,exports){
        'use strict'

        exports.byteLength = byteLength
        exports.toByteArray = toByteArray
        exports.fromByteArray = fromByteArray

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

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

// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
        revLookup['-'.charCodeAt(0)] = 62
        revLookup['_'.charCodeAt(0)] = 63

        function getLens (b64) {
            var len = b64.length

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

            // Trim off extra bytes after placeholder bytes are found
            // See: https://github.com/beatgammit/base64-js/issues/42
            var validLen = b64.indexOf('=')
            if (validLen === -1) validLen = len

            var placeHoldersLen = validLen === len
                ? 0
                : 4 - (validLen % 4)

            return [validLen, placeHoldersLen]
        }

// base64 is 4/3 + up to two characters of the original data
        function byteLength (b64) {
            var lens = getLens(b64)
            var validLen = lens[0]
            var placeHoldersLen = lens[1]
            return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
        }

        function _byteLength (b64, validLen, placeHoldersLen) {
            return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
        }

        function toByteArray (b64) {
            var tmp
            var lens = getLens(b64)
            var validLen = lens[0]
            var placeHoldersLen = lens[1]

            var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

            var curByte = 0

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

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

            if (placeHoldersLen === 2) {
                tmp =
                    (revLookup[b64.charCodeAt(i)] << 2) |
                    (revLookup[b64.charCodeAt(i + 1)] >> 4)
                arr[curByte++] = tmp & 0xFF
            }

            if (placeHoldersLen === 1) {
                tmp =
                    (revLookup[b64.charCodeAt(i)] << 10) |
                    (revLookup[b64.charCodeAt(i + 1)] << 4) |
                    (revLookup[b64.charCodeAt(i + 2)] >> 2)
                arr[curByte++] = (tmp >> 8) & 0xFF
                arr[curByte++] = 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) & 0xFF0000) +
                    ((uint8[i + 1] << 8) & 0xFF00) +
                    (uint8[i + 2] & 0xFF)
                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 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]
                parts.push(
                    lookup[tmp >> 2] +
                    lookup[(tmp << 4) & 0x3F] +
                    '=='
                )
            } else if (extraBytes === 2) {
                tmp = (uint8[len - 2] << 8) + uint8[len - 1]
                parts.push(
                    lookup[tmp >> 10] +
                    lookup[(tmp >> 4) & 0x3F] +
                    lookup[(tmp << 2) & 0x3F] +
                    '='
                )
            }

            return parts.join('')
        }

    },{}],41:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise) {
            var SomePromiseArray = Promise._SomePromiseArray;
            function any(promises) {
                var ret = new SomePromiseArray(promises);
                var promise = ret.promise();
                ret.setHowMany(1);
                ret.setUnwrap();
                ret.init();
                return promise;
            }

            Promise.any = function (promises) {
                return any(promises);
            };

            Promise.prototype.any = function () {
                return any(this);
            };

        };

    },{}],42:[function(require,module,exports){
        (function (process){(function (){
            "use strict";
            var firstLineError;
            try {throw new Error(); } catch (e) {firstLineError = e;}
            var schedule = require("./schedule");
            var Queue = require("./queue");
            var util = require("./util");

            function Async() {
                this._customScheduler = false;
                this._isTickUsed = false;
                this._lateQueue = new Queue(16);
                this._normalQueue = new Queue(16);
                this._haveDrainedQueues = false;
                this._trampolineEnabled = true;
                var self = this;
                this.drainQueues = function () {
                    self._drainQueues();
                };
                this._schedule = schedule;
            }

            Async.prototype.setScheduler = function(fn) {
                var prev = this._schedule;
                this._schedule = fn;
                this._customScheduler = true;
                return prev;
            };

            Async.prototype.hasCustomScheduler = function() {
                return this._customScheduler;
            };

            Async.prototype.enableTrampoline = function() {
                this._trampolineEnabled = true;
            };

            Async.prototype.disableTrampolineIfNecessary = function() {
                if (util.hasDevTools) {
                    this._trampolineEnabled = false;
                }
            };

            Async.prototype.haveItemsQueued = function () {
                return this._isTickUsed || this._haveDrainedQueues;
            };


            Async.prototype.fatalError = function(e, isNode) {
                if (isNode) {
                    process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
                        "\n");
                    process.exit(2);
                } else {
                    this.throwLater(e);
                }
            };

            Async.prototype.throwLater = function(fn, arg) {
                if (arguments.length === 1) {
                    arg = fn;
                    fn = function () { throw arg; };
                }
                if (typeof setTimeout !== "undefined") {
                    setTimeout(function() {
                        fn(arg);
                    }, 0);
                } else try {
                    this._schedule(function() {
                        fn(arg);
                    });
                } catch (e) {
                    throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                }
            };

            function AsyncInvokeLater(fn, receiver, arg) {
                this._lateQueue.push(fn, receiver, arg);
                this._queueTick();
            }

            function AsyncInvoke(fn, receiver, arg) {
                this._normalQueue.push(fn, receiver, arg);
                this._queueTick();
            }

            function AsyncSettlePromises(promise) {
                this._normalQueue._pushOne(promise);
                this._queueTick();
            }

            if (!util.hasDevTools) {
                Async.prototype.invokeLater = AsyncInvokeLater;
                Async.prototype.invoke = AsyncInvoke;
                Async.prototype.settlePromises = AsyncSettlePromises;
            } else {
                Async.prototype.invokeLater = function (fn, receiver, arg) {
                    if (this._trampolineEnabled) {
                        AsyncInvokeLater.call(this, fn, receiver, arg);
                    } else {
                        this._schedule(function() {
                            setTimeout(function() {
                                fn.call(receiver, arg);
                            }, 100);
                        });
                    }
                };

                Async.prototype.invoke = function (fn, receiver, arg) {
                    if (this._trampolineEnabled) {
                        AsyncInvoke.call(this, fn, receiver, arg);
                    } else {
                        this._schedule(function() {
                            fn.call(receiver, arg);
                        });
                    }
                };

                Async.prototype.settlePromises = function(promise) {
                    if (this._trampolineEnabled) {
                        AsyncSettlePromises.call(this, promise);
                    } else {
                        this._schedule(function() {
                            promise._settlePromises();
                        });
                    }
                };
            }

            Async.prototype._drainQueue = function(queue) {
                while (queue.length() > 0) {
                    var fn = queue.shift();
                    if (typeof fn !== "function") {
                        fn._settlePromises();
                        continue;
                    }
                    var receiver = queue.shift();
                    var arg = queue.shift();
                    fn.call(receiver, arg);
                }
            };

            Async.prototype._drainQueues = function () {
                this._drainQueue(this._normalQueue);
                this._reset();
                this._haveDrainedQueues = true;
                this._drainQueue(this._lateQueue);
            };

            Async.prototype._queueTick = function () {
                if (!this._isTickUsed) {
                    this._isTickUsed = true;
                    this._schedule(this.drainQueues);
                }
            };

            Async.prototype._reset = function () {
                this._isTickUsed = false;
            };

            module.exports = Async;
            module.exports.firstLineError = firstLineError;

        }).call(this)}).call(this,require('_process'))
    },{"./queue":65,"./schedule":68,"./util":75,"_process":102}],43:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
            var calledBind = false;
            var rejectThis = function(_, e) {
                this._reject(e);
            };

            var targetRejected = function(e, context) {
                context.promiseRejectionQueued = true;
                context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
            };

            var bindingResolved = function(thisArg, context) {
                if (((this._bitField & 50397184) === 0)) {
                    this._resolveCallback(context.target);
                }
            };

            var bindingRejected = function(e, context) {
                if (!context.promiseRejectionQueued) this._reject(e);
            };

            Promise.prototype.bind = function (thisArg) {
                if (!calledBind) {
                    calledBind = true;
                    Promise.prototype._propagateFrom = debug.propagateFromFunction();
                    Promise.prototype._boundValue = debug.boundValueFunction();
                }
                var maybePromise = tryConvertToPromise(thisArg);
                var ret = new Promise(INTERNAL);
                ret._propagateFrom(this, 1);
                var target = this._target();
                ret._setBoundTo(maybePromise);
                if (maybePromise instanceof Promise) {
                    var context = {
                        promiseRejectionQueued: false,
                        promise: ret,
                        target: target,
                        bindingPromise: maybePromise
                    };
                    target._then(INTERNAL, targetRejected, undefined, ret, context);
                    maybePromise._then(
                        bindingResolved, bindingRejected, undefined, ret, context);
                    ret._setOnCancel(maybePromise);
                } else {
                    ret._resolveCallback(target);
                }
                return ret;
            };

            Promise.prototype._setBoundTo = function (obj) {
                if (obj !== undefined) {
                    this._bitField = this._bitField | 2097152;
                    this._boundTo = obj;
                } else {
                    this._bitField = this._bitField & (~2097152);
                }
            };

            Promise.prototype._isBound = function () {
                return (this._bitField & 2097152) === 2097152;
            };

            Promise.bind = function (thisArg, value) {
                return Promise.resolve(value).bind(thisArg);
            };
        };

    },{}],44:[function(require,module,exports){
        "use strict";
        var cr = Object.create;
        if (cr) {
            var callerCache = cr(null);
            var getterCache = cr(null);
            callerCache[" size"] = getterCache[" size"] = 0;
        }

        module.exports = function(Promise) {
            var util = require("./util");
            var canEvaluate = util.canEvaluate;
            var isIdentifier = util.isIdentifier;

            var getMethodCaller;
            var getGetter;
            if (true) {
                var makeMethodCaller = function (methodName) {
                    return new Function("ensureMethod", "                                    \n\
        return function(obj) {                                               \n\
            'use strict'                                                     \n\
            var len = this.length;                                           \n\
            ensureMethod(obj, 'methodName');                                 \n\
            switch(len) {                                                    \n\
                case 1: return obj.methodName(this[0]);                      \n\
                case 2: return obj.methodName(this[0], this[1]);             \n\
                case 3: return obj.methodName(this[0], this[1], this[2]);    \n\
                case 0: return obj.methodName();                             \n\
                default:                                                     \n\
                    return obj.methodName.apply(obj, this);                  \n\
            }                                                                \n\
        };                                                                   \n\
        ".replace(/methodName/g, methodName))(ensureMethod);
                };

                var makeGetter = function (propertyName) {
                    return new Function("obj", "                                             \n\
        'use strict';                                                        \n\
        return obj.propertyName;                                             \n\
        ".replace("propertyName", propertyName));
                };

                var getCompiled = function(name, compiler, cache) {
                    var ret = cache[name];
                    if (typeof ret !== "function") {
                        if (!isIdentifier(name)) {
                            return null;
                        }
                        ret = compiler(name);
                        cache[name] = ret;
                        cache[" size"]++;
                        if (cache[" size"] > 512) {
                            var keys = Object.keys(cache);
                            for (var i = 0; i < 256; ++i) delete cache[keys[i]];
                            cache[" size"] = keys.length - 256;
                        }
                    }
                    return ret;
                };

                getMethodCaller = function(name) {
                    return getCompiled(name, makeMethodCaller, callerCache);
                };

                getGetter = function(name) {
                    return getCompiled(name, makeGetter, getterCache);
                };
            }

            function ensureMethod(obj, methodName) {
                var fn;
                if (obj != null) fn = obj[methodName];
                if (typeof fn !== "function") {
                    var message = "Object " + util.classString(obj) + " has no method '" +
                        util.toString(methodName) + "'";
                    throw new Promise.TypeError(message);
                }
                return fn;
            }

            function caller(obj) {
                var methodName = this.pop();
                var fn = ensureMethod(obj, methodName);
                return fn.apply(obj, this);
            }
            Promise.prototype.call = function (methodName) {
                var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};
                if (true) {
                    if (canEvaluate) {
                        var maybeCaller = getMethodCaller(methodName);
                        if (maybeCaller !== null) {
                            return this._then(
                                maybeCaller, undefined, undefined, args, undefined);
                        }
                    }
                }
                args.push(methodName);
                return this._then(caller, undefined, undefined, args, undefined);
            };

            function namedGetter(obj) {
                return obj[this];
            }
            function indexedGetter(obj) {
                var index = +this;
                if (index < 0) index = Math.max(0, index + obj.length);
                return obj[index];
            }
            Promise.prototype.get = function (propertyName) {
                var isIndex = (typeof propertyName === "number");
                var getter;
                if (!isIndex) {
                    if (canEvaluate) {
                        var maybeGetter = getGetter(propertyName);
                        getter = maybeGetter !== null ? maybeGetter : namedGetter;
                    } else {
                        getter = namedGetter;
                    }
                } else {
                    getter = indexedGetter;
                }
                return this._then(getter, undefined, undefined, propertyName, undefined);
            };
        };

    },{"./util":75}],45:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, PromiseArray, apiRejection, debug) {
            var util = require("./util");
            var tryCatch = util.tryCatch;
            var errorObj = util.errorObj;
            var async = Promise._async;

            Promise.prototype["break"] = Promise.prototype.cancel = function() {
                if (!debug.cancellation()) return this._warn("cancellation is disabled");

                var promise = this;
                var child = promise;
                while (promise._isCancellable()) {
                    if (!promise._cancelBy(child)) {
                        if (child._isFollowing()) {
                            child._followee().cancel();
                        } else {
                            child._cancelBranched();
                        }
                        break;
                    }

                    var parent = promise._cancellationParent;
                    if (parent == null || !parent._isCancellable()) {
                        if (promise._isFollowing()) {
                            promise._followee().cancel();
                        } else {
                            promise._cancelBranched();
                        }
                        break;
                    } else {
                        if (promise._isFollowing()) promise._followee().cancel();
                        promise._setWillBeCancelled();
                        child = promise;
                        promise = parent;
                    }
                }
            };

            Promise.prototype._branchHasCancelled = function() {
                this._branchesRemainingToCancel--;
            };

            Promise.prototype._enoughBranchesHaveCancelled = function() {
                return this._branchesRemainingToCancel === undefined ||
                    this._branchesRemainingToCancel <= 0;
            };

            Promise.prototype._cancelBy = function(canceller) {
                if (canceller === this) {
                    this._branchesRemainingToCancel = 0;
                    this._invokeOnCancel();
                    return true;
                } else {
                    this._branchHasCancelled();
                    if (this._enoughBranchesHaveCancelled()) {
                        this._invokeOnCancel();
                        return true;
                    }
                }
                return false;
            };

            Promise.prototype._cancelBranched = function() {
                if (this._enoughBranchesHaveCancelled()) {
                    this._cancel();
                }
            };

            Promise.prototype._cancel = function() {
                if (!this._isCancellable()) return;
                this._setCancelled();
                async.invoke(this._cancelPromises, this, undefined);
            };

            Promise.prototype._cancelPromises = function() {
                if (this._length() > 0) this._settlePromises();
            };

            Promise.prototype._unsetOnCancel = function() {
                this._onCancelField = undefined;
            };

            Promise.prototype._isCancellable = function() {
                return this.isPending() && !this._isCancelled();
            };

            Promise.prototype.isCancellable = function() {
                return this.isPending() && !this.isCancelled();
            };

            Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
                if (util.isArray(onCancelCallback)) {
                    for (var i = 0; i < onCancelCallback.length; ++i) {
                        this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
                    }
                } else if (onCancelCallback !== undefined) {
                    if (typeof onCancelCallback === "function") {
                        if (!internalOnly) {
                            var e = tryCatch(onCancelCallback).call(this._boundValue());
                            if (e === errorObj) {
                                this._attachExtraTrace(e.e);
                                async.throwLater(e.e);
                            }
                        }
                    } else {
                        onCancelCallback._resultCancelled(this);
                    }
                }
            };

            Promise.prototype._invokeOnCancel = function() {
                var onCancelCallback = this._onCancel();
                this._unsetOnCancel();
                async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
            };

            Promise.prototype._invokeInternalOnCancel = function() {
                if (this._isCancellable()) {
                    this._doInvokeOnCancel(this._onCancel(), true);
                    this._unsetOnCancel();
                }
            };

            Promise.prototype._resultCancelled = function() {
                this.cancel();
            };

        };

    },{"./util":75}],46:[function(require,module,exports){
        "use strict";
        module.exports = function(NEXT_FILTER) {
            var util = require("./util");
            var getKeys = require("./es5").keys;
            var tryCatch = util.tryCatch;
            var errorObj = util.errorObj;

            function catchFilter(instances, cb, promise) {
                return function(e) {
                    var boundTo = promise._boundValue();
                    predicateLoop: for (var i = 0; i < instances.length; ++i) {
                        var item = instances[i];

                        if (item === Error ||
                            (item != null && item.prototype instanceof Error)) {
                            if (e instanceof item) {
                                return tryCatch(cb).call(boundTo, e);
                            }
                        } else if (typeof item === "function") {
                            var matchesPredicate = tryCatch(item).call(boundTo, e);
                            if (matchesPredicate === errorObj) {
                                return matchesPredicate;
                            } else if (matchesPredicate) {
                                return tryCatch(cb).call(boundTo, e);
                            }
                        } else if (util.isObject(e)) {
                            var keys = getKeys(item);
                            for (var j = 0; j < keys.length; ++j) {
                                var key = keys[j];
                                if (item[key] != e[key]) {
                                    continue predicateLoop;
                                }
                            }
                            return tryCatch(cb).call(boundTo, e);
                        }
                    }
                    return NEXT_FILTER;
                };
            }

            return catchFilter;
        };

    },{"./es5":52,"./util":75}],47:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise) {
            var longStackTraces = false;
            var contextStack = [];

            Promise.prototype._promiseCreated = function() {};
            Promise.prototype._pushContext = function() {};
            Promise.prototype._popContext = function() {return null;};
            Promise._peekContext = Promise.prototype._peekContext = function() {};

            function Context() {
                this._trace = new Context.CapturedTrace(peekContext());
            }
            Context.prototype._pushContext = function () {
                if (this._trace !== undefined) {
                    this._trace._promiseCreated = null;
                    contextStack.push(this._trace);
                }
            };

            Context.prototype._popContext = function () {
                if (this._trace !== undefined) {
                    var trace = contextStack.pop();
                    var ret = trace._promiseCreated;
                    trace._promiseCreated = null;
                    return ret;
                }
                return null;
            };

            function createContext() {
                if (longStackTraces) return new Context();
            }

            function peekContext() {
                var lastIndex = contextStack.length - 1;
                if (lastIndex >= 0) {
                    return contextStack[lastIndex];
                }
                return undefined;
            }
            Context.CapturedTrace = null;
            Context.create = createContext;
            Context.deactivateLongStackTraces = function() {};
            Context.activateLongStackTraces = function() {
                var Promise_pushContext = Promise.prototype._pushContext;
                var Promise_popContext = Promise.prototype._popContext;
                var Promise_PeekContext = Promise._peekContext;
                var Promise_peekContext = Promise.prototype._peekContext;
                var Promise_promiseCreated = Promise.prototype._promiseCreated;
                Context.deactivateLongStackTraces = function() {
                    Promise.prototype._pushContext = Promise_pushContext;
                    Promise.prototype._popContext = Promise_popContext;
                    Promise._peekContext = Promise_PeekContext;
                    Promise.prototype._peekContext = Promise_peekContext;
                    Promise.prototype._promiseCreated = Promise_promiseCreated;
                    longStackTraces = false;
                };
                longStackTraces = true;
                Promise.prototype._pushContext = Context.prototype._pushContext;
                Promise.prototype._popContext = Context.prototype._popContext;
                Promise._peekContext = Promise.prototype._peekContext = peekContext;
                Promise.prototype._promiseCreated = function() {
                    var ctx = this._peekContext();
                    if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
                };
            };
            return Context;
        };

    },{}],48:[function(require,module,exports){
        (function (process){(function (){
            "use strict";
            module.exports = function(Promise, Context) {
                var getDomain = Promise._getDomain;
                var async = Promise._async;
                var Warning = require("./errors").Warning;
                var util = require("./util");
                var canAttachTrace = util.canAttachTrace;
                var unhandledRejectionHandled;
                var possiblyUnhandledRejection;
                var bluebirdFramePattern =
                    /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
                var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/;
                var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/;
                var stackFramePattern = null;
                var formatStack = null;
                var indentStackFrames = false;
                var printWarning;
                var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
                    ( false ||
                        util.env("BLUEBIRD_DEBUG") ||
                        util.env("NODE_ENV") === "development"));

                var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
                    (debugging || util.env("BLUEBIRD_WARNINGS")));

                var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
                    (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));

                var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
                    (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));

                Promise.prototype.suppressUnhandledRejections = function() {
                    var target = this._target();
                    target._bitField = ((target._bitField & (~1048576)) |
                        524288);
                };

                Promise.prototype._ensurePossibleRejectionHandled = function () {
                    if ((this._bitField & 524288) !== 0) return;
                    this._setRejectionIsUnhandled();
                    async.invokeLater(this._notifyUnhandledRejection, this, undefined);
                };

                Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
                    fireRejectionEvent("rejectionHandled",
                        unhandledRejectionHandled, undefined, this);
                };

                Promise.prototype._setReturnedNonUndefined = function() {
                    this._bitField = this._bitField | 268435456;
                };

                Promise.prototype._returnedNonUndefined = function() {
                    return (this._bitField & 268435456) !== 0;
                };

                Promise.prototype._notifyUnhandledRejection = function () {
                    if (this._isRejectionUnhandled()) {
                        var reason = this._settledValue();
                        this._setUnhandledRejectionIsNotified();
                        fireRejectionEvent("unhandledRejection",
                            possiblyUnhandledRejection, reason, this);
                    }
                };

                Promise.prototype._setUnhandledRejectionIsNotified = function () {
                    this._bitField = this._bitField | 262144;
                };

                Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
                    this._bitField = this._bitField & (~262144);
                };

                Promise.prototype._isUnhandledRejectionNotified = function () {
                    return (this._bitField & 262144) > 0;
                };

                Promise.prototype._setRejectionIsUnhandled = function () {
                    this._bitField = this._bitField | 1048576;
                };

                Promise.prototype._unsetRejectionIsUnhandled = function () {
                    this._bitField = this._bitField & (~1048576);
                    if (this._isUnhandledRejectionNotified()) {
                        this._unsetUnhandledRejectionIsNotified();
                        this._notifyUnhandledRejectionIsHandled();
                    }
                };

                Promise.prototype._isRejectionUnhandled = function () {
                    return (this._bitField & 1048576) > 0;
                };

                Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
                    return warn(message, shouldUseOwnTrace, promise || this);
                };

                Promise.onPossiblyUnhandledRejection = function (fn) {
                    var domain = getDomain();
                    possiblyUnhandledRejection =
                        typeof fn === "function" ? (domain === null ?
                                fn : util.domainBind(domain, fn))
                            : undefined;
                };

                Promise.onUnhandledRejectionHandled = function (fn) {
                    var domain = getDomain();
                    unhandledRejectionHandled =
                        typeof fn === "function" ? (domain === null ?
                                fn : util.domainBind(domain, fn))
                            : undefined;
                };

                var disableLongStackTraces = function() {};
                Promise.longStackTraces = function () {
                    if (async.haveItemsQueued() && !config.longStackTraces) {
                        throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                    }
                    if (!config.longStackTraces && longStackTracesIsSupported()) {
                        var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
                        var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
                        config.longStackTraces = true;
                        disableLongStackTraces = function() {
                            if (async.haveItemsQueued() && !config.longStackTraces) {
                                throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                            }
                            Promise.prototype._captureStackTrace = Promise_captureStackTrace;
                            Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
                            Context.deactivateLongStackTraces();
                            async.enableTrampoline();
                            config.longStackTraces = false;
                        };
                        Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
                        Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
                        Context.activateLongStackTraces();
                        async.disableTrampolineIfNecessary();
                    }
                };

                Promise.hasLongStackTraces = function () {
                    return config.longStackTraces && longStackTracesIsSupported();
                };

                var fireDomEvent = (function() {
                    try {
                        if (typeof CustomEvent === "function") {
                            var event = new CustomEvent("CustomEvent");
                            util.global.dispatchEvent(event);
                            return function(name, event) {
                                var domEvent = new CustomEvent(name.toLowerCase(), {
                                    detail: event,
                                    cancelable: true
                                });
                                return !util.global.dispatchEvent(domEvent);
                            };
                        } else if (typeof Event === "function") {
                            var event = new Event("CustomEvent");
                            util.global.dispatchEvent(event);
                            return function(name, event) {
                                var domEvent = new Event(name.toLowerCase(), {
                                    cancelable: true
                                });
                                domEvent.detail = event;
                                return !util.global.dispatchEvent(domEvent);
                            };
                        } else {
                            var event = document.createEvent("CustomEvent");
                            event.initCustomEvent("testingtheevent", false, true, {});
                            util.global.dispatchEvent(event);
                            return function(name, event) {
                                var domEvent = document.createEvent("CustomEvent");
                                domEvent.initCustomEvent(name.toLowerCase(), false, true,
                                    event);
                                return !util.global.dispatchEvent(domEvent);
                            };
                        }
                    } catch (e) {}
                    return function() {
                        return false;
                    };
                })();

                var fireGlobalEvent = (function() {
                    if (util.isNode) {
                        return function() {
                            return process.emit.apply(process, arguments);
                        };
                    } else {
                        if (!util.global) {
                            return function() {
                                return false;
                            };
                        }
                        return function(name) {
                            var methodName = "on" + name.toLowerCase();
                            var method = util.global[methodName];
                            if (!method) return false;
                            method.apply(util.global, [].slice.call(arguments, 1));
                            return true;
                        };
                    }
                })();

                function generatePromiseLifecycleEventObject(name, promise) {
                    return {promise: promise};
                }

                var eventToObjectGenerator = {
                    promiseCreated: generatePromiseLifecycleEventObject,
                    promiseFulfilled: generatePromiseLifecycleEventObject,
                    promiseRejected: generatePromiseLifecycleEventObject,
                    promiseResolved: generatePromiseLifecycleEventObject,
                    promiseCancelled: generatePromiseLifecycleEventObject,
                    promiseChained: function(name, promise, child) {
                        return {promise: promise, child: child};
                    },
                    warning: function(name, warning) {
                        return {warning: warning};
                    },
                    unhandledRejection: function (name, reason, promise) {
                        return {reason: reason, promise: promise};
                    },
                    rejectionHandled: generatePromiseLifecycleEventObject
                };

                var activeFireEvent = function (name) {
                    var globalEventFired = false;
                    try {
                        globalEventFired = fireGlobalEvent.apply(null, arguments);
                    } catch (e) {
                        async.throwLater(e);
                        globalEventFired = true;
                    }

                    var domEventFired = false;
                    try {
                        domEventFired = fireDomEvent(name,
                            eventToObjectGenerator[name].apply(null, arguments));
                    } catch (e) {
                        async.throwLater(e);
                        domEventFired = true;
                    }

                    return domEventFired || globalEventFired;
                };

                Promise.config = function(opts) {
                    opts = Object(opts);
                    if ("longStackTraces" in opts) {
                        if (opts.longStackTraces) {
                            Promise.longStackTraces();
                        } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
                            disableLongStackTraces();
                        }
                    }
                    if ("warnings" in opts) {
                        var warningsOption = opts.warnings;
                        config.warnings = !!warningsOption;
                        wForgottenReturn = config.warnings;

                        if (util.isObject(warningsOption)) {
                            if ("wForgottenReturn" in warningsOption) {
                                wForgottenReturn = !!warningsOption.wForgottenReturn;
                            }
                        }
                    }
                    if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
                        if (async.haveItemsQueued()) {
                            throw new Error(
                                "cannot enable cancellation after promises are in use");
                        }
                        Promise.prototype._clearCancellationData =
                            cancellationClearCancellationData;
                        Promise.prototype._propagateFrom = cancellationPropagateFrom;
                        Promise.prototype._onCancel = cancellationOnCancel;
                        Promise.prototype._setOnCancel = cancellationSetOnCancel;
                        Promise.prototype._attachCancellationCallback =
                            cancellationAttachCancellationCallback;
                        Promise.prototype._execute = cancellationExecute;
                        propagateFromFunction = cancellationPropagateFrom;
                        config.cancellation = true;
                    }
                    if ("monitoring" in opts) {
                        if (opts.monitoring && !config.monitoring) {
                            config.monitoring = true;
                            Promise.prototype._fireEvent = activeFireEvent;
                        } else if (!opts.monitoring && config.monitoring) {
                            config.monitoring = false;
                            Promise.prototype._fireEvent = defaultFireEvent;
                        }
                    }
                    return Promise;
                };

                function defaultFireEvent() { return false; }

                Promise.prototype._fireEvent = defaultFireEvent;
                Promise.prototype._execute = function(executor, resolve, reject) {
                    try {
                        executor(resolve, reject);
                    } catch (e) {
                        return e;
                    }
                };
                Promise.prototype._onCancel = function () {};
                Promise.prototype._setOnCancel = function (handler) { ; };
                Promise.prototype._attachCancellationCallback = function(onCancel) {
                    ;
                };
                Promise.prototype._captureStackTrace = function () {};
                Promise.prototype._attachExtraTrace = function () {};
                Promise.prototype._clearCancellationData = function() {};
                Promise.prototype._propagateFrom = function (parent, flags) {
                    ;
                    ;
                };

                function cancellationExecute(executor, resolve, reject) {
                    var promise = this;
                    try {
                        executor(resolve, reject, function(onCancel) {
                            if (typeof onCancel !== "function") {
                                throw new TypeError("onCancel must be a function, got: " +
                                    util.toString(onCancel));
                            }
                            promise._attachCancellationCallback(onCancel);
                        });
                    } catch (e) {
                        return e;
                    }
                }

                function cancellationAttachCancellationCallback(onCancel) {
                    if (!this._isCancellable()) return this;

                    var previousOnCancel = this._onCancel();
                    if (previousOnCancel !== undefined) {
                        if (util.isArray(previousOnCancel)) {
                            previousOnCancel.push(onCancel);
                        } else {
                            this._setOnCancel([previousOnCancel, onCancel]);
                        }
                    } else {
                        this._setOnCancel(onCancel);
                    }
                }

                function cancellationOnCancel() {
                    return this._onCancelField;
                }

                function cancellationSetOnCancel(onCancel) {
                    this._onCancelField = onCancel;
                }

                function cancellationClearCancellationData() {
                    this._cancellationParent = undefined;
                    this._onCancelField = undefined;
                }

                function cancellationPropagateFrom(parent, flags) {
                    if ((flags & 1) !== 0) {
                        this._cancellationParent = parent;
                        var branchesRemainingToCancel = parent._branchesRemainingToCancel;
                        if (branchesRemainingToCancel === undefined) {
                            branchesRemainingToCancel = 0;
                        }
                        parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
                    }
                    if ((flags & 2) !== 0 && parent._isBound()) {
                        this._setBoundTo(parent._boundTo);
                    }
                }

                function bindingPropagateFrom(parent, flags) {
                    if ((flags & 2) !== 0 && parent._isBound()) {
                        this._setBoundTo(parent._boundTo);
                    }
                }
                var propagateFromFunction = bindingPropagateFrom;

                function boundValueFunction() {
                    var ret = this._boundTo;
                    if (ret !== undefined) {
                        if (ret instanceof Promise) {
                            if (ret.isFulfilled()) {
                                return ret.value();
                            } else {
                                return undefined;
                            }
                        }
                    }
                    return ret;
                }

                function longStackTracesCaptureStackTrace() {
                    this._trace = new CapturedTrace(this._peekContext());
                }

                function longStackTracesAttachExtraTrace(error, ignoreSelf) {
                    if (canAttachTrace(error)) {
                        var trace = this._trace;
                        if (trace !== undefined) {
                            if (ignoreSelf) trace = trace._parent;
                        }
                        if (trace !== undefined) {
                            trace.attachExtraTrace(error);
                        } else if (!error.__stackCleaned__) {
                            var parsed = parseStackAndMessage(error);
                            util.notEnumerableProp(error, "stack",
                                parsed.message + "\n" + parsed.stack.join("\n"));
                            util.notEnumerableProp(error, "__stackCleaned__", true);
                        }
                    }
                }

                function checkForgottenReturns(returnValue, promiseCreated, name, promise,
                                               parent) {
                    if (returnValue === undefined && promiseCreated !== null &&
                        wForgottenReturn) {
                        if (parent !== undefined && parent._returnedNonUndefined()) return;
                        if ((promise._bitField & 65535) === 0) return;

                        if (name) name = name + " ";
                        var handlerLine = "";
                        var creatorLine = "";
                        if (promiseCreated._trace) {
                            var traceLines = promiseCreated._trace.stack.split("\n");
                            var stack = cleanStack(traceLines);
                            for (var i = stack.length - 1; i >= 0; --i) {
                                var line = stack[i];
                                if (!nodeFramePattern.test(line)) {
                                    var lineMatches = line.match(parseLinePattern);
                                    if (lineMatches) {
                                        handlerLine  = "at " + lineMatches[1] +
                                            ":" + lineMatches[2] + ":" + lineMatches[3] + " ";
                                    }
                                    break;
                                }
                            }

                            if (stack.length > 0) {
                                var firstUserLine = stack[0];
                                for (var i = 0; i < traceLines.length; ++i) {

                                    if (traceLines[i] === firstUserLine) {
                                        if (i > 0) {
                                            creatorLine = "\n" + traceLines[i - 1];
                                        }
                                        break;
                                    }
                                }

                            }
                        }
                        var msg = "a promise was created in a " + name +
                            "handler " + handlerLine + "but was not returned from it, " +
                            "see http://goo.gl/rRqMUw" +
                            creatorLine;
                        promise._warn(msg, true, promiseCreated);
                    }
                }

                function deprecated(name, replacement) {
                    var message = name +
                        " is deprecated and will be removed in a future version.";
                    if (replacement) message += " Use " + replacement + " instead.";
                    return warn(message);
                }

                function warn(message, shouldUseOwnTrace, promise) {
                    if (!config.warnings) return;
                    var warning = new Warning(message);
                    var ctx;
                    if (shouldUseOwnTrace) {
                        promise._attachExtraTrace(warning);
                    } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
                        ctx.attachExtraTrace(warning);
                    } else {
                        var parsed = parseStackAndMessage(warning);
                        warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
                    }

                    if (!activeFireEvent("warning", warning)) {
                        formatAndLogError(warning, "", true);
                    }
                }

                function reconstructStack(message, stacks) {
                    for (var i = 0; i < stacks.length - 1; ++i) {
                        stacks[i].push("From previous event:");
                        stacks[i] = stacks[i].join("\n");
                    }
                    if (i < stacks.length) {
                        stacks[i] = stacks[i].join("\n");
                    }
                    return message + "\n" + stacks.join("\n");
                }

                function removeDuplicateOrEmptyJumps(stacks) {
                    for (var i = 0; i < stacks.length; ++i) {
                        if (stacks[i].length === 0 ||
                            ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
                            stacks.splice(i, 1);
                            i--;
                        }
                    }
                }

                function removeCommonRoots(stacks) {
                    var current = stacks[0];
                    for (var i = 1; i < stacks.length; ++i) {
                        var prev = stacks[i];
                        var currentLastIndex = current.length - 1;
                        var currentLastLine = current[currentLastIndex];
                        var commonRootMeetPoint = -1;

                        for (var j = prev.length - 1; j >= 0; --j) {
                            if (prev[j] === currentLastLine) {
                                commonRootMeetPoint = j;
                                break;
                            }
                        }

                        for (var j = commonRootMeetPoint; j >= 0; --j) {
                            var line = prev[j];
                            if (current[currentLastIndex] === line) {
                                current.pop();
                                currentLastIndex--;
                            } else {
                                break;
                            }
                        }
                        current = prev;
                    }
                }

                function cleanStack(stack) {
                    var ret = [];
                    for (var i = 0; i < stack.length; ++i) {
                        var line = stack[i];
                        var isTraceLine = "    (No stack trace)" === line ||
                            stackFramePattern.test(line);
                        var isInternalFrame = isTraceLine && shouldIgnore(line);
                        if (isTraceLine && !isInternalFrame) {
                            if (indentStackFrames && line.charAt(0) !== " ") {
                                line = "    " + line;
                            }
                            ret.push(line);
                        }
                    }
                    return ret;
                }

                function stackFramesAsArray(error) {
                    var stack = error.stack.replace(/\s+$/g, "").split("\n");
                    for (var i = 0; i < stack.length; ++i) {
                        var line = stack[i];
                        if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
                            break;
                        }
                    }
                    if (i > 0 && error.name != "SyntaxError") {
                        stack = stack.slice(i);
                    }
                    return stack;
                }

                function parseStackAndMessage(error) {
                    var stack = error.stack;
                    var message = error.toString();
                    stack = typeof stack === "string" && stack.length > 0
                        ? stackFramesAsArray(error) : ["    (No stack trace)"];
                    return {
                        message: message,
                        stack: error.name == "SyntaxError" ? stack : cleanStack(stack)
                    };
                }

                function formatAndLogError(error, title, isSoft) {
                    if (typeof console !== "undefined") {
                        var message;
                        if (util.isObject(error)) {
                            var stack = error.stack;
                            message = title + formatStack(stack, error);
                        } else {
                            message = title + String(error);
                        }
                        if (typeof printWarning === "function") {
                            printWarning(message, isSoft);
                        } else if (typeof console.log === "function" ||
                            typeof console.log === "object") {
                            console.log(message);
                        }
                    }
                }

                function fireRejectionEvent(name, localHandler, reason, promise) {
                    var localEventFired = false;
                    try {
                        if (typeof localHandler === "function") {
                            localEventFired = true;
                            if (name === "rejectionHandled") {
                                localHandler(promise);
                            } else {
                                localHandler(reason, promise);
                            }
                        }
                    } catch (e) {
                        async.throwLater(e);
                    }

                    if (name === "unhandledRejection") {
                        if (!activeFireEvent(name, reason, promise) && !localEventFired) {
                            formatAndLogError(reason, "Unhandled rejection ");
                        }
                    } else {
                        activeFireEvent(name, promise);
                    }
                }

                function formatNonError(obj) {
                    var str;
                    if (typeof obj === "function") {
                        str = "[function " +
                            (obj.name || "anonymous") +
                            "]";
                    } else {
                        str = obj && typeof obj.toString === "function"
                            ? obj.toString() : util.toString(obj);
                        var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
                        if (ruselessToString.test(str)) {
                            try {
                                var newStr = JSON.stringify(obj);
                                str = newStr;
                            }
                            catch(e) {

                            }
                        }
                        if (str.length === 0) {
                            str = "(empty array)";
                        }
                    }
                    return ("(<" + snip(str) + ">, no stack trace)");
                }

                function snip(str) {
                    var maxChars = 41;
                    if (str.length < maxChars) {
                        return str;
                    }
                    return str.substr(0, maxChars - 3) + "...";
                }

                function longStackTracesIsSupported() {
                    return typeof captureStackTrace === "function";
                }

                var shouldIgnore = function() { return false; };
                var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
                function parseLineInfo(line) {
                    var matches = line.match(parseLineInfoRegex);
                    if (matches) {
                        return {
                            fileName: matches[1],
                            line: parseInt(matches[2], 10)
                        };
                    }
                }

                function setBounds(firstLineError, lastLineError) {
                    if (!longStackTracesIsSupported()) return;
                    var firstStackLines = firstLineError.stack.split("\n");
                    var lastStackLines = lastLineError.stack.split("\n");
                    var firstIndex = -1;
                    var lastIndex = -1;
                    var firstFileName;
                    var lastFileName;
                    for (var i = 0; i < firstStackLines.length; ++i) {
                        var result = parseLineInfo(firstStackLines[i]);
                        if (result) {
                            firstFileName = result.fileName;
                            firstIndex = result.line;
                            break;
                        }
                    }
                    for (var i = 0; i < lastStackLines.length; ++i) {
                        var result = parseLineInfo(lastStackLines[i]);
                        if (result) {
                            lastFileName = result.fileName;
                            lastIndex = result.line;
                            break;
                        }
                    }
                    if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
                        firstFileName !== lastFileName || firstIndex >= lastIndex) {
                        return;
                    }

                    shouldIgnore = function(line) {
                        if (bluebirdFramePattern.test(line)) return true;
                        var info = parseLineInfo(line);
                        if (info) {
                            if (info.fileName === firstFileName &&
                                (firstIndex <= info.line && info.line <= lastIndex)) {
                                return true;
                            }
                        }
                        return false;
                    };
                }

                function CapturedTrace(parent) {
                    this._parent = parent;
                    this._promisesCreated = 0;
                    var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
                    captureStackTrace(this, CapturedTrace);
                    if (length > 32) this.uncycle();
                }
                util.inherits(CapturedTrace, Error);
                Context.CapturedTrace = CapturedTrace;

                CapturedTrace.prototype.uncycle = function() {
                    var length = this._length;
                    if (length < 2) return;
                    var nodes = [];
                    var stackToIndex = {};

                    for (var i = 0, node = this; node !== undefined; ++i) {
                        nodes.push(node);
                        node = node._parent;
                    }
                    length = this._length = i;
                    for (var i = length - 1; i >= 0; --i) {
                        var stack = nodes[i].stack;
                        if (stackToIndex[stack] === undefined) {
                            stackToIndex[stack] = i;
                        }
                    }
                    for (var i = 0; i < length; ++i) {
                        var currentStack = nodes[i].stack;
                        var index = stackToIndex[currentStack];
                        if (index !== undefined && index !== i) {
                            if (index > 0) {
                                nodes[index - 1]._parent = undefined;
                                nodes[index - 1]._length = 1;
                            }
                            nodes[i]._parent = undefined;
                            nodes[i]._length = 1;
                            var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;

                            if (index < length - 1) {
                                cycleEdgeNode._parent = nodes[index + 1];
                                cycleEdgeNode._parent.uncycle();
                                cycleEdgeNode._length =
                                    cycleEdgeNode._parent._length + 1;
                            } else {
                                cycleEdgeNode._parent = undefined;
                                cycleEdgeNode._length = 1;
                            }
                            var currentChildLength = cycleEdgeNode._length + 1;
                            for (var j = i - 2; j >= 0; --j) {
                                nodes[j]._length = currentChildLength;
                                currentChildLength++;
                            }
                            return;
                        }
                    }
                };

                CapturedTrace.prototype.attachExtraTrace = function(error) {
                    if (error.__stackCleaned__) return;
                    this.uncycle();
                    var parsed = parseStackAndMessage(error);
                    var message = parsed.message;
                    var stacks = [parsed.stack];

                    var trace = this;
                    while (trace !== undefined) {
                        stacks.push(cleanStack(trace.stack.split("\n")));
                        trace = trace._parent;
                    }
                    removeCommonRoots(stacks);
                    removeDuplicateOrEmptyJumps(stacks);
                    util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
                    util.notEnumerableProp(error, "__stackCleaned__", true);
                };

                var captureStackTrace = (function stackDetection() {
                    var v8stackFramePattern = /^\s*at\s*/;
                    var v8stackFormatter = function(stack, error) {
                        if (typeof stack === "string") return stack;

                        if (error.name !== undefined &&
                            error.message !== undefined) {
                            return error.toString();
                        }
                        return formatNonError(error);
                    };

                    if (typeof Error.stackTraceLimit === "number" &&
                        typeof Error.captureStackTrace === "function") {
                        Error.stackTraceLimit += 6;
                        stackFramePattern = v8stackFramePattern;
                        formatStack = v8stackFormatter;
                        var captureStackTrace = Error.captureStackTrace;

                        shouldIgnore = function(line) {
                            return bluebirdFramePattern.test(line);
                        };
                        return function(receiver, ignoreUntil) {
                            Error.stackTraceLimit += 6;
                            captureStackTrace(receiver, ignoreUntil);
                            Error.stackTraceLimit -= 6;
                        };
                    }
                    var err = new Error();

                    if (typeof err.stack === "string" &&
                        err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
                        stackFramePattern = /@/;
                        formatStack = v8stackFormatter;
                        indentStackFrames = true;
                        return function captureStackTrace(o) {
                            o.stack = new Error().stack;
                        };
                    }

                    var hasStackAfterThrow;
                    try { throw new Error(); }
                    catch(e) {
                        hasStackAfterThrow = ("stack" in e);
                    }
                    if (!("stack" in err) && hasStackAfterThrow &&
                        typeof Error.stackTraceLimit === "number") {
                        stackFramePattern = v8stackFramePattern;
                        formatStack = v8stackFormatter;
                        return function captureStackTrace(o) {
                            Error.stackTraceLimit += 6;
                            try { throw new Error(); }
                            catch(e) { o.stack = e.stack; }
                            Error.stackTraceLimit -= 6;
                        };
                    }

                    formatStack = function(stack, error) {
                        if (typeof stack === "string") return stack;

                        if ((typeof error === "object" ||
                                typeof error === "function") &&
                            error.name !== undefined &&
                            error.message !== undefined) {
                            return error.toString();
                        }
                        return formatNonError(error);
                    };

                    return null;

                })([]);

                if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
                    printWarning = function (message) {
                        console.warn(message);
                    };
                    if (util.isNode && process.stderr.isTTY) {
                        printWarning = function(message, isSoft) {
                            var color = isSoft ? "\u001b[33m" : "\u001b[31m";
                            console.warn(color + message + "\u001b[0m\n");
                        };
                    } else if (!util.isNode && typeof (new Error().stack) === "string") {
                        printWarning = function(message, isSoft) {
                            console.warn("%c" + message,
                                isSoft ? "color: darkorange" : "color: red");
                        };
                    }
                }

                var config = {
                    warnings: warnings,
                    longStackTraces: false,
                    cancellation: false,
                    monitoring: false
                };

                if (longStackTraces) Promise.longStackTraces();

                return {
                    longStackTraces: function() {
                        return config.longStackTraces;
                    },
                    warnings: function() {
                        return config.warnings;
                    },
                    cancellation: function() {
                        return config.cancellation;
                    },
                    monitoring: function() {
                        return config.monitoring;
                    },
                    propagateFromFunction: function() {
                        return propagateFromFunction;
                    },
                    boundValueFunction: function() {
                        return boundValueFunction;
                    },
                    checkForgottenReturns: checkForgottenReturns,
                    setBounds: setBounds,
                    warn: warn,
                    deprecated: deprecated,
                    CapturedTrace: CapturedTrace,
                    fireDomEvent: fireDomEvent,
                    fireGlobalEvent: fireGlobalEvent
                };
            };

        }).call(this)}).call(this,require('_process'))
    },{"./errors":51,"./util":75,"_process":102}],49:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise) {
            function returner() {
                return this.value;
            }
            function thrower() {
                throw this.reason;
            }

            Promise.prototype["return"] =
                Promise.prototype.thenReturn = function (value) {
                    if (value instanceof Promise) value.suppressUnhandledRejections();
                    return this._then(
                        returner, undefined, undefined, {value: value}, undefined);
                };

            Promise.prototype["throw"] =
                Promise.prototype.thenThrow = function (reason) {
                    return this._then(
                        thrower, undefined, undefined, {reason: reason}, undefined);
                };

            Promise.prototype.catchThrow = function (reason) {
                if (arguments.length <= 1) {
                    return this._then(
                        undefined, thrower, undefined, {reason: reason}, undefined);
                } else {
                    var _reason = arguments[1];
                    var handler = function() {throw _reason;};
                    return this.caught(reason, handler);
                }
            };

            Promise.prototype.catchReturn = function (value) {
                if (arguments.length <= 1) {
                    if (value instanceof Promise) value.suppressUnhandledRejections();
                    return this._then(
                        undefined, returner, undefined, {value: value}, undefined);
                } else {
                    var _value = arguments[1];
                    if (_value instanceof Promise) _value.suppressUnhandledRejections();
                    var handler = function() {return _value;};
                    return this.caught(value, handler);
                }
            };
        };

    },{}],50:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL) {
            var PromiseReduce = Promise.reduce;
            var PromiseAll = Promise.all;

            function promiseAllThis() {
                return PromiseAll(this);
            }

            function PromiseMapSeries(promises, fn) {
                return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
            }

            Promise.prototype.each = function (fn) {
                return PromiseReduce(this, fn, INTERNAL, 0)
                    ._then(promiseAllThis, undefined, undefined, this, undefined);
            };

            Promise.prototype.mapSeries = function (fn) {
                return PromiseReduce(this, fn, INTERNAL, INTERNAL);
            };

            Promise.each = function (promises, fn) {
                return PromiseReduce(promises, fn, INTERNAL, 0)
                    ._then(promiseAllThis, undefined, undefined, promises, undefined);
            };

            Promise.mapSeries = PromiseMapSeries;
        };


    },{}],51:[function(require,module,exports){
        "use strict";
        var es5 = require("./es5");
        var Objectfreeze = es5.freeze;
        var util = require("./util");
        var inherits = util.inherits;
        var notEnumerableProp = util.notEnumerableProp;

        function subError(nameProperty, defaultMessage) {
            function SubError(message) {
                if (!(this instanceof SubError)) return new SubError(message);
                notEnumerableProp(this, "message",
                    typeof message === "string" ? message : defaultMessage);
                notEnumerableProp(this, "name", nameProperty);
                if (Error.captureStackTrace) {
                    Error.captureStackTrace(this, this.constructor);
                } else {
                    Error.call(this);
                }
            }
            inherits(SubError, Error);
            return SubError;
        }

        var _TypeError, _RangeError;
        var Warning = subError("Warning", "warning");
        var CancellationError = subError("CancellationError", "cancellation error");
        var TimeoutError = subError("TimeoutError", "timeout error");
        var AggregateError = subError("AggregateError", "aggregate error");
        try {
            _TypeError = TypeError;
            _RangeError = RangeError;
        } catch(e) {
            _TypeError = subError("TypeError", "type error");
            _RangeError = subError("RangeError", "range error");
        }

        var methods = ("join pop push shift unshift slice filter forEach some " +
            "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");

        for (var i = 0; i < methods.length; ++i) {
            if (typeof Array.prototype[methods[i]] === "function") {
                AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
            }
        }

        es5.defineProperty(AggregateError.prototype, "length", {
            value: 0,
            configurable: false,
            writable: true,
            enumerable: true
        });
        AggregateError.prototype["isOperational"] = true;
        var level = 0;
        AggregateError.prototype.toString = function() {
            var indent = Array(level * 4 + 1).join(" ");
            var ret = "\n" + indent + "AggregateError of:" + "\n";
            level++;
            indent = Array(level * 4 + 1).join(" ");
            for (var i = 0; i < this.length; ++i) {
                var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
                var lines = str.split("\n");
                for (var j = 0; j < lines.length; ++j) {
                    lines[j] = indent + lines[j];
                }
                str = lines.join("\n");
                ret += str + "\n";
            }
            level--;
            return ret;
        };

        function OperationalError(message) {
            if (!(this instanceof OperationalError))
                return new OperationalError(message);
            notEnumerableProp(this, "name", "OperationalError");
            notEnumerableProp(this, "message", message);
            this.cause = message;
            this["isOperational"] = true;

            if (message instanceof Error) {
                notEnumerableProp(this, "message", message.message);
                notEnumerableProp(this, "stack", message.stack);
            } else if (Error.captureStackTrace) {
                Error.captureStackTrace(this, this.constructor);
            }

        }
        inherits(OperationalError, Error);

        var errorTypes = Error["__BluebirdErrorTypes__"];
        if (!errorTypes) {
            errorTypes = Objectfreeze({
                CancellationError: CancellationError,
                TimeoutError: TimeoutError,
                OperationalError: OperationalError,
                RejectionError: OperationalError,
                AggregateError: AggregateError
            });
            es5.defineProperty(Error, "__BluebirdErrorTypes__", {
                value: errorTypes,
                writable: false,
                enumerable: false,
                configurable: false
            });
        }

        module.exports = {
            Error: Error,
            TypeError: _TypeError,
            RangeError: _RangeError,
            CancellationError: errorTypes.CancellationError,
            OperationalError: errorTypes.OperationalError,
            TimeoutError: errorTypes.TimeoutError,
            AggregateError: errorTypes.AggregateError,
            Warning: Warning
        };

    },{"./es5":52,"./util":75}],52:[function(require,module,exports){
        var isES5 = (function(){
            "use strict";
            return this === undefined;
        })();

        if (isES5) {
            module.exports = {
                freeze: Object.freeze,
                defineProperty: Object.defineProperty,
                getDescriptor: Object.getOwnPropertyDescriptor,
                keys: Object.keys,
                names: Object.getOwnPropertyNames,
                getPrototypeOf: Object.getPrototypeOf,
                isArray: Array.isArray,
                isES5: isES5,
                propertyIsWritable: function(obj, prop) {
                    var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
                    return !!(!descriptor || descriptor.writable || descriptor.set);
                }
            };
        } else {
            var has = {}.hasOwnProperty;
            var str = {}.toString;
            var proto = {}.constructor.prototype;

            var ObjectKeys = function (o) {
                var ret = [];
                for (var key in o) {
                    if (has.call(o, key)) {
                        ret.push(key);
                    }
                }
                return ret;
            };

            var ObjectGetDescriptor = function(o, key) {
                return {value: o[key]};
            };

            var ObjectDefineProperty = function (o, key, desc) {
                o[key] = desc.value;
                return o;
            };

            var ObjectFreeze = function (obj) {
                return obj;
            };

            var ObjectGetPrototypeOf = function (obj) {
                try {
                    return Object(obj).constructor.prototype;
                }
                catch (e) {
                    return proto;
                }
            };

            var ArrayIsArray = function (obj) {
                try {
                    return str.call(obj) === "[object Array]";
                }
                catch(e) {
                    return false;
                }
            };

            module.exports = {
                isArray: ArrayIsArray,
                keys: ObjectKeys,
                names: ObjectKeys,
                defineProperty: ObjectDefineProperty,
                getDescriptor: ObjectGetDescriptor,
                freeze: ObjectFreeze,
                getPrototypeOf: ObjectGetPrototypeOf,
                isES5: isES5,
                propertyIsWritable: function() {
                    return true;
                }
            };
        }

    },{}],53:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL) {
            var PromiseMap = Promise.map;

            Promise.prototype.filter = function (fn, options) {
                return PromiseMap(this, fn, options, INTERNAL);
            };

            Promise.filter = function (promises, fn, options) {
                return PromiseMap(promises, fn, options, INTERNAL);
            };
        };

    },{}],54:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, tryConvertToPromise) {
            var util = require("./util");
            var CancellationError = Promise.CancellationError;
            var errorObj = util.errorObj;

            function PassThroughHandlerContext(promise, type, handler) {
                this.promise = promise;
                this.type = type;
                this.handler = handler;
                this.called = false;
                this.cancelPromise = null;
            }

            PassThroughHandlerContext.prototype.isFinallyHandler = function() {
                return this.type === 0;
            };

            function FinallyHandlerCancelReaction(finallyHandler) {
                this.finallyHandler = finallyHandler;
            }

            FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
                checkCancel(this.finallyHandler);
            };

            function checkCancel(ctx, reason) {
                if (ctx.cancelPromise != null) {
                    if (arguments.length > 1) {
                        ctx.cancelPromise._reject(reason);
                    } else {
                        ctx.cancelPromise._cancel();
                    }
                    ctx.cancelPromise = null;
                    return true;
                }
                return false;
            }

            function succeed() {
                return finallyHandler.call(this, this.promise._target()._settledValue());
            }
            function fail(reason) {
                if (checkCancel(this, reason)) return;
                errorObj.e = reason;
                return errorObj;
            }
            function finallyHandler(reasonOrValue) {
                var promise = this.promise;
                var handler = this.handler;

                if (!this.called) {
                    this.called = true;
                    var ret = this.isFinallyHandler()
                        ? handler.call(promise._boundValue())
                        : handler.call(promise._boundValue(), reasonOrValue);
                    if (ret !== undefined) {
                        promise._setReturnedNonUndefined();
                        var maybePromise = tryConvertToPromise(ret, promise);
                        if (maybePromise instanceof Promise) {
                            if (this.cancelPromise != null) {
                                if (maybePromise._isCancelled()) {
                                    var reason =
                                        new CancellationError("late cancellation observer");
                                    promise._attachExtraTrace(reason);
                                    errorObj.e = reason;
                                    return errorObj;
                                } else if (maybePromise.isPending()) {
                                    maybePromise._attachCancellationCallback(
                                        new FinallyHandlerCancelReaction(this));
                                }
                            }
                            return maybePromise._then(
                                succeed, fail, undefined, this, undefined);
                        }
                    }
                }

                if (promise.isRejected()) {
                    checkCancel(this);
                    errorObj.e = reasonOrValue;
                    return errorObj;
                } else {
                    checkCancel(this);
                    return reasonOrValue;
                }
            }

            Promise.prototype._passThrough = function(handler, type, success, fail) {
                if (typeof handler !== "function") return this.then();
                return this._then(success,
                    fail,
                    undefined,
                    new PassThroughHandlerContext(this, type, handler),
                    undefined);
            };

            Promise.prototype.lastly =
                Promise.prototype["finally"] = function (handler) {
                    return this._passThrough(handler,
                        0,
                        finallyHandler,
                        finallyHandler);
                };

            Promise.prototype.tap = function (handler) {
                return this._passThrough(handler, 1, finallyHandler);
            };

            return PassThroughHandlerContext;
        };

    },{"./util":75}],55:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise,
                                  apiRejection,
                                  INTERNAL,
                                  tryConvertToPromise,
                                  Proxyable,
                                  debug) {
            var errors = require("./errors");
            var TypeError = errors.TypeError;
            var util = require("./util");
            var errorObj = util.errorObj;
            var tryCatch = util.tryCatch;
            var yieldHandlers = [];

            function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
                for (var i = 0; i < yieldHandlers.length; ++i) {
                    traceParent._pushContext();
                    var result = tryCatch(yieldHandlers[i])(value);
                    traceParent._popContext();
                    if (result === errorObj) {
                        traceParent._pushContext();
                        var ret = Promise.reject(errorObj.e);
                        traceParent._popContext();
                        return ret;
                    }
                    var maybePromise = tryConvertToPromise(result, traceParent);
                    if (maybePromise instanceof Promise) return maybePromise;
                }
                return null;
            }

            function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
                if (debug.cancellation()) {
                    var internal = new Promise(INTERNAL);
                    var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);
                    this._promise = internal.lastly(function() {
                        return _finallyPromise;
                    });
                    internal._captureStackTrace();
                    internal._setOnCancel(this);
                } else {
                    var promise = this._promise = new Promise(INTERNAL);
                    promise._captureStackTrace();
                }
                this._stack = stack;
                this._generatorFunction = generatorFunction;
                this._receiver = receiver;
                this._generator = undefined;
                this._yieldHandlers = typeof yieldHandler === "function"
                    ? [yieldHandler].concat(yieldHandlers)
                    : yieldHandlers;
                this._yieldedPromise = null;
                this._cancellationPhase = false;
            }
            util.inherits(PromiseSpawn, Proxyable);

            PromiseSpawn.prototype._isResolved = function() {
                return this._promise === null;
            };

            PromiseSpawn.prototype._cleanup = function() {
                this._promise = this._generator = null;
                if (debug.cancellation() && this._finallyPromise !== null) {
                    this._finallyPromise._fulfill();
                    this._finallyPromise = null;
                }
            };

            PromiseSpawn.prototype._promiseCancelled = function() {
                if (this._isResolved()) return;
                var implementsReturn = typeof this._generator["return"] !== "undefined";

                var result;
                if (!implementsReturn) {
                    var reason = new Promise.CancellationError(
                        "generator .return() sentinel");
                    Promise.coroutine.returnSentinel = reason;
                    this._promise._attachExtraTrace(reason);
                    this._promise._pushContext();
                    result = tryCatch(this._generator["throw"]).call(this._generator,
                        reason);
                    this._promise._popContext();
                } else {
                    this._promise._pushContext();
                    result = tryCatch(this._generator["return"]).call(this._generator,
                        undefined);
                    this._promise._popContext();
                }
                this._cancellationPhase = true;
                this._yieldedPromise = null;
                this._continue(result);
            };

            PromiseSpawn.prototype._promiseFulfilled = function(value) {
                this._yieldedPromise = null;
                this._promise._pushContext();
                var result = tryCatch(this._generator.next).call(this._generator, value);
                this._promise._popContext();
                this._continue(result);
            };

            PromiseSpawn.prototype._promiseRejected = function(reason) {
                this._yieldedPromise = null;
                this._promise._attachExtraTrace(reason);
                this._promise._pushContext();
                var result = tryCatch(this._generator["throw"])
                    .call(this._generator, reason);
                this._promise._popContext();
                this._continue(result);
            };

            PromiseSpawn.prototype._resultCancelled = function() {
                if (this._yieldedPromise instanceof Promise) {
                    var promise = this._yieldedPromise;
                    this._yieldedPromise = null;
                    promise.cancel();
                }
            };

            PromiseSpawn.prototype.promise = function () {
                return this._promise;
            };

            PromiseSpawn.prototype._run = function () {
                this._generator = this._generatorFunction.call(this._receiver);
                this._receiver =
                    this._generatorFunction = undefined;
                this._promiseFulfilled(undefined);
            };

            PromiseSpawn.prototype._continue = function (result) {
                var promise = this._promise;
                if (result === errorObj) {
                    this._cleanup();
                    if (this._cancellationPhase) {
                        return promise.cancel();
                    } else {
                        return promise._rejectCallback(result.e, false);
                    }
                }

                var value = result.value;
                if (result.done === true) {
                    this._cleanup();
                    if (this._cancellationPhase) {
                        return promise.cancel();
                    } else {
                        return promise._resolveCallback(value);
                    }
                } else {
                    var maybePromise = tryConvertToPromise(value, this._promise);
                    if (!(maybePromise instanceof Promise)) {
                        maybePromise =
                            promiseFromYieldHandler(maybePromise,
                                this._yieldHandlers,
                                this._promise);
                        if (maybePromise === null) {
                            this._promiseRejected(
                                new TypeError(
                                    "A value %s was yielded that could not be treated as a promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", value) +
                                    "From coroutine:\u000a" +
                                    this._stack.split("\n").slice(1, -7).join("\n")
                                )
                            );
                            return;
                        }
                    }
                    maybePromise = maybePromise._target();
                    var bitField = maybePromise._bitField;
                    ;
                    if (((bitField & 50397184) === 0)) {
                        this._yieldedPromise = maybePromise;
                        maybePromise._proxy(this, null);
                    } else if (((bitField & 33554432) !== 0)) {
                        Promise._async.invoke(
                            this._promiseFulfilled, this, maybePromise._value()
                        );
                    } else if (((bitField & 16777216) !== 0)) {
                        Promise._async.invoke(
                            this._promiseRejected, this, maybePromise._reason()
                        );
                    } else {
                        this._promiseCancelled();
                    }
                }
            };

            Promise.coroutine = function (generatorFunction, options) {
                if (typeof generatorFunction !== "function") {
                    throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                }
                var yieldHandler = Object(options).yieldHandler;
                var PromiseSpawn$ = PromiseSpawn;
                var stack = new Error().stack;
                return function () {
                    var generator = generatorFunction.apply(this, arguments);
                    var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
                        stack);
                    var ret = spawn.promise();
                    spawn._generator = generator;
                    spawn._promiseFulfilled(undefined);
                    return ret;
                };
            };

            Promise.coroutine.addYieldHandler = function(fn) {
                if (typeof fn !== "function") {
                    throw new TypeError("expecting a function but got " + util.classString(fn));
                }
                yieldHandlers.push(fn);
            };

            Promise.spawn = function (generatorFunction) {
                debug.deprecated("Promise.spawn()", "Promise.coroutine()");
                if (typeof generatorFunction !== "function") {
                    return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                }
                var spawn = new PromiseSpawn(generatorFunction, this);
                var ret = spawn.promise();
                spawn._run(Promise.spawn);
                return ret;
            };
        };

    },{"./errors":51,"./util":75}],56:[function(require,module,exports){
        "use strict";
        module.exports =
            function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async,
                     getDomain) {
                var util = require("./util");
                var canEvaluate = util.canEvaluate;
                var tryCatch = util.tryCatch;
                var errorObj = util.errorObj;
                var reject;

                if (true) {
                    if (canEvaluate) {
                        var thenCallback = function(i) {
                            return new Function("value", "holder", "                             \n\
            'use strict';                                                    \n\
            holder.pIndex = value;                                           \n\
            holder.checkFulfillment(this);                                   \n\
            ".replace(/Index/g, i));
                        };

                        var promiseSetter = function(i) {
                            return new Function("promise", "holder", "                           \n\
            'use strict';                                                    \n\
            holder.pIndex = promise;                                         \n\
            ".replace(/Index/g, i));
                        };

                        var generateHolderClass = function(total) {
                            var props = new Array(total);
                            for (var i = 0; i < props.length; ++i) {
                                props[i] = "this.p" + (i+1);
                            }
                            var assignment = props.join(" = ") + " = null;";
                            var cancellationCode= "var promise;\n" + props.map(function(prop) {
                                return "                                                         \n\
                promise = " + prop + ";                                      \n\
                if (promise instanceof Promise) {                            \n\
                    promise.cancel();                                        \n\
                }                                                            \n\
            ";
                            }).join("\n");
                            var passedArguments = props.join(", ");
                            var name = "Holder$" + total;


                            var code = "return function(tryCatch, errorObj, Promise, async) {    \n\
            'use strict';                                                    \n\
            function [TheName](fn) {                                         \n\
                [TheProperties]                                              \n\
                this.fn = fn;                                                \n\
                this.asyncNeeded = true;                                     \n\
                this.now = 0;                                                \n\
            }                                                                \n\
                                                                             \n\
            [TheName].prototype._callFunction = function(promise) {          \n\
                promise._pushContext();                                      \n\
                var ret = tryCatch(this.fn)([ThePassedArguments]);           \n\
                promise._popContext();                                       \n\
                if (ret === errorObj) {                                      \n\
                    promise._rejectCallback(ret.e, false);                   \n\
                } else {                                                     \n\
                    promise._resolveCallback(ret);                           \n\
                }                                                            \n\
            };                                                               \n\
                                                                             \n\
            [TheName].prototype.checkFulfillment = function(promise) {       \n\
                var now = ++this.now;                                        \n\
                if (now === [TheTotal]) {                                    \n\
                    if (this.asyncNeeded) {                                  \n\
                        async.invoke(this._callFunction, this, promise);     \n\
                    } else {                                                 \n\
                        this._callFunction(promise);                         \n\
                    }                                                        \n\
                                                                             \n\
                }                                                            \n\
            };                                                               \n\
                                                                             \n\
            [TheName].prototype._resultCancelled = function() {              \n\
                [CancellationCode]                                           \n\
            };                                                               \n\
                                                                             \n\
            return [TheName];                                                \n\
        }(tryCatch, errorObj, Promise, async);                               \n\
        ";

                            code = code.replace(/\[TheName\]/g, name)
                                .replace(/\[TheTotal\]/g, total)
                                .replace(/\[ThePassedArguments\]/g, passedArguments)
                                .replace(/\[TheProperties\]/g, assignment)
                                .replace(/\[CancellationCode\]/g, cancellationCode);

                            return new Function("tryCatch", "errorObj", "Promise", "async", code)
                            (tryCatch, errorObj, Promise, async);
                        };

                        var holderClasses = [];
                        var thenCallbacks = [];
                        var promiseSetters = [];

                        for (var i = 0; i < 8; ++i) {
                            holderClasses.push(generateHolderClass(i + 1));
                            thenCallbacks.push(thenCallback(i + 1));
                            promiseSetters.push(promiseSetter(i + 1));
                        }

                        reject = function (reason) {
                            this._reject(reason);
                        };
                    }}

                Promise.join = function () {
                    var last = arguments.length - 1;
                    var fn;
                    if (last > 0 && typeof arguments[last] === "function") {
                        fn = arguments[last];
                        if (true) {
                            if (last <= 8 && canEvaluate) {
                                var ret = new Promise(INTERNAL);
                                ret._captureStackTrace();
                                var HolderClass = holderClasses[last - 1];
                                var holder = new HolderClass(fn);
                                var callbacks = thenCallbacks;

                                for (var i = 0; i < last; ++i) {
                                    var maybePromise = tryConvertToPromise(arguments[i], ret);
                                    if (maybePromise instanceof Promise) {
                                        maybePromise = maybePromise._target();
                                        var bitField = maybePromise._bitField;
                                        ;
                                        if (((bitField & 50397184) === 0)) {
                                            maybePromise._then(callbacks[i], reject,
                                                undefined, ret, holder);
                                            promiseSetters[i](maybePromise, holder);
                                            holder.asyncNeeded = false;
                                        } else if (((bitField & 33554432) !== 0)) {
                                            callbacks[i].call(ret,
                                                maybePromise._value(), holder);
                                        } else if (((bitField & 16777216) !== 0)) {
                                            ret._reject(maybePromise._reason());
                                        } else {
                                            ret._cancel();
                                        }
                                    } else {
                                        callbacks[i].call(ret, maybePromise, holder);
                                    }
                                }

                                if (!ret._isFateSealed()) {
                                    if (holder.asyncNeeded) {
                                        var domain = getDomain();
                                        if (domain !== null) {
                                            holder.fn = util.domainBind(domain, holder.fn);
                                        }
                                    }
                                    ret._setAsyncGuaranteed();
                                    ret._setOnCancel(holder);
                                }
                                return ret;
                            }
                        }
                    }
                    var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];};
                    if (fn) args.pop();
                    var ret = new PromiseArray(args).promise();
                    return fn !== undefined ? ret.spread(fn) : ret;
                };

            };

    },{"./util":75}],57:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise,
                                  PromiseArray,
                                  apiRejection,
                                  tryConvertToPromise,
                                  INTERNAL,
                                  debug) {
            var getDomain = Promise._getDomain;
            var util = require("./util");
            var tryCatch = util.tryCatch;
            var errorObj = util.errorObj;
            var async = Promise._async;

            function MappingPromiseArray(promises, fn, limit, _filter) {
                this.constructor$(promises);
                this._promise._captureStackTrace();
                var domain = getDomain();
                this._callback = domain === null ? fn : util.domainBind(domain, fn);
                this._preservedValues = _filter === INTERNAL
                    ? new Array(this.length())
                    : null;
                this._limit = limit;
                this._inFlight = 0;
                this._queue = [];
                async.invoke(this._asyncInit, this, undefined);
            }
            util.inherits(MappingPromiseArray, PromiseArray);

            MappingPromiseArray.prototype._asyncInit = function() {
                this._init$(undefined, -2);
            };

            MappingPromiseArray.prototype._init = function () {};

            MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
                var values = this._values;
                var length = this.length();
                var preservedValues = this._preservedValues;
                var limit = this._limit;

                if (index < 0) {
                    index = (index * -1) - 1;
                    values[index] = value;
                    if (limit >= 1) {
                        this._inFlight--;
                        this._drainQueue();
                        if (this._isResolved()) return true;
                    }
                } else {
                    if (limit >= 1 && this._inFlight >= limit) {
                        values[index] = value;
                        this._queue.push(index);
                        return false;
                    }
                    if (preservedValues !== null) preservedValues[index] = value;

                    var promise = this._promise;
                    var callback = this._callback;
                    var receiver = promise._boundValue();
                    promise._pushContext();
                    var ret = tryCatch(callback).call(receiver, value, index, length);
                    var promiseCreated = promise._popContext();
                    debug.checkForgottenReturns(
                        ret,
                        promiseCreated,
                        preservedValues !== null ? "Promise.filter" : "Promise.map",
                        promise
                    );
                    if (ret === errorObj) {
                        this._reject(ret.e);
                        return true;
                    }

                    var maybePromise = tryConvertToPromise(ret, this._promise);
                    if (maybePromise instanceof Promise) {
                        maybePromise = maybePromise._target();
                        var bitField = maybePromise._bitField;
                        ;
                        if (((bitField & 50397184) === 0)) {
                            if (limit >= 1) this._inFlight++;
                            values[index] = maybePromise;
                            maybePromise._proxy(this, (index + 1) * -1);
                            return false;
                        } else if (((bitField & 33554432) !== 0)) {
                            ret = maybePromise._value();
                        } else if (((bitField & 16777216) !== 0)) {
                            this._reject(maybePromise._reason());
                            return true;
                        } else {
                            this._cancel();
                            return true;
                        }
                    }
                    values[index] = ret;
                }
                var totalResolved = ++this._totalResolved;
                if (totalResolved >= length) {
                    if (preservedValues !== null) {
                        this._filter(values, preservedValues);
                    } else {
                        this._resolve(values);
                    }
                    return true;
                }
                return false;
            };

            MappingPromiseArray.prototype._drainQueue = function () {
                var queue = this._queue;
                var limit = this._limit;
                var values = this._values;
                while (queue.length > 0 && this._inFlight < limit) {
                    if (this._isResolved()) return;
                    var index = queue.pop();
                    this._promiseFulfilled(values[index], index);
                }
            };

            MappingPromiseArray.prototype._filter = function (booleans, values) {
                var len = values.length;
                var ret = new Array(len);
                var j = 0;
                for (var i = 0; i < len; ++i) {
                    if (booleans[i]) ret[j++] = values[i];
                }
                ret.length = j;
                this._resolve(ret);
            };

            MappingPromiseArray.prototype.preservedValues = function () {
                return this._preservedValues;
            };

            function map(promises, fn, options, _filter) {
                if (typeof fn !== "function") {
                    return apiRejection("expecting a function but got " + util.classString(fn));
                }

                var limit = 0;
                if (options !== undefined) {
                    if (typeof options === "object" && options !== null) {
                        if (typeof options.concurrency !== "number") {
                            return Promise.reject(
                                new TypeError("'concurrency' must be a number but it is " +
                                    util.classString(options.concurrency)));
                        }
                        limit = options.concurrency;
                    } else {
                        return Promise.reject(new TypeError(
                            "options argument must be an object but it is " +
                            util.classString(options)));
                    }
                }
                limit = typeof limit === "number" &&
                isFinite(limit) && limit >= 1 ? limit : 0;
                return new MappingPromiseArray(promises, fn, limit, _filter).promise();
            }

            Promise.prototype.map = function (fn, options) {
                return map(this, fn, options, null);
            };

            Promise.map = function (promises, fn, options, _filter) {
                return map(promises, fn, options, _filter);
            };


        };

    },{"./util":75}],58:[function(require,module,exports){
        "use strict";
        module.exports =
            function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
                var util = require("./util");
                var tryCatch = util.tryCatch;

                Promise.method = function (fn) {
                    if (typeof fn !== "function") {
                        throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
                    }
                    return function () {
                        var ret = new Promise(INTERNAL);
                        ret._captureStackTrace();
                        ret._pushContext();
                        var value = tryCatch(fn).apply(this, arguments);
                        var promiseCreated = ret._popContext();
                        debug.checkForgottenReturns(
                            value, promiseCreated, "Promise.method", ret);
                        ret._resolveFromSyncValue(value);
                        return ret;
                    };
                };

                Promise.attempt = Promise["try"] = function (fn) {
                    if (typeof fn !== "function") {
                        return apiRejection("expecting a function but got " + util.classString(fn));
                    }
                    var ret = new Promise(INTERNAL);
                    ret._captureStackTrace();
                    ret._pushContext();
                    var value;
                    if (arguments.length > 1) {
                        debug.deprecated("calling Promise.try with more than 1 argument");
                        var arg = arguments[1];
                        var ctx = arguments[2];
                        value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
                            : tryCatch(fn).call(ctx, arg);
                    } else {
                        value = tryCatch(fn)();
                    }
                    var promiseCreated = ret._popContext();
                    debug.checkForgottenReturns(
                        value, promiseCreated, "Promise.try", ret);
                    ret._resolveFromSyncValue(value);
                    return ret;
                };

                Promise.prototype._resolveFromSyncValue = function (value) {
                    if (value === util.errorObj) {
                        this._rejectCallback(value.e, false);
                    } else {
                        this._resolveCallback(value, true);
                    }
                };
            };

    },{"./util":75}],59:[function(require,module,exports){
        "use strict";
        var util = require("./util");
        var maybeWrapAsError = util.maybeWrapAsError;
        var errors = require("./errors");
        var OperationalError = errors.OperationalError;
        var es5 = require("./es5");

        function isUntypedError(obj) {
            return obj instanceof Error &&
                es5.getPrototypeOf(obj) === Error.prototype;
        }

        var rErrorKey = /^(?:name|message|stack|cause)$/;
        function wrapAsOperationalError(obj) {
            var ret;
            if (isUntypedError(obj)) {
                ret = new OperationalError(obj);
                ret.name = obj.name;
                ret.message = obj.message;
                ret.stack = obj.stack;
                var keys = es5.keys(obj);
                for (var i = 0; i < keys.length; ++i) {
                    var key = keys[i];
                    if (!rErrorKey.test(key)) {
                        ret[key] = obj[key];
                    }
                }
                return ret;
            }
            util.markAsOriginatingFromRejection(obj);
            return obj;
        }

        function nodebackForPromise(promise, multiArgs) {
            return function(err, value) {
                if (promise === null) return;
                if (err) {
                    var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
                    promise._attachExtraTrace(wrapped);
                    promise._reject(wrapped);
                } else if (!multiArgs) {
                    promise._fulfill(value);
                } else {
                    var $_len = arguments.length;var args = new Array(Math.max($_len - 1, 0)); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];};
                    promise._fulfill(args);
                }
                promise = null;
            };
        }

        module.exports = nodebackForPromise;

    },{"./errors":51,"./es5":52,"./util":75}],60:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise) {
            var util = require("./util");
            var async = Promise._async;
            var tryCatch = util.tryCatch;
            var errorObj = util.errorObj;

            function spreadAdapter(val, nodeback) {
                var promise = this;
                if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
                var ret =
                    tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
                if (ret === errorObj) {
                    async.throwLater(ret.e);
                }
            }

            function successAdapter(val, nodeback) {
                var promise = this;
                var receiver = promise._boundValue();
                var ret = val === undefined
                    ? tryCatch(nodeback).call(receiver, null)
                    : tryCatch(nodeback).call(receiver, null, val);
                if (ret === errorObj) {
                    async.throwLater(ret.e);
                }
            }
            function errorAdapter(reason, nodeback) {
                var promise = this;
                if (!reason) {
                    var newReason = new Error(reason + "");
                    newReason.cause = reason;
                    reason = newReason;
                }
                var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
                if (ret === errorObj) {
                    async.throwLater(ret.e);
                }
            }

            Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,
                                                                                 options) {
                if (typeof nodeback == "function") {
                    var adapter = successAdapter;
                    if (options !== undefined && Object(options).spread) {
                        adapter = spreadAdapter;
                    }
                    this._then(
                        adapter,
                        errorAdapter,
                        undefined,
                        this,
                        nodeback
                    );
                }
                return this;
            };
        };

    },{"./util":75}],61:[function(require,module,exports){
        (function (process){(function (){
            "use strict";
            module.exports = function() {
                var makeSelfResolutionError = function () {
                    return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                };
                var reflectHandler = function() {
                    return new Promise.PromiseInspection(this._target());
                };
                var apiRejection = function(msg) {
                    return Promise.reject(new TypeError(msg));
                };
                function Proxyable() {}
                var UNDEFINED_BINDING = {};
                var util = require("./util");

                var getDomain;
                if (util.isNode) {
                    getDomain = function() {
                        var ret = process.domain;
                        if (ret === undefined) ret = null;
                        return ret;
                    };
                } else {
                    getDomain = function() {
                        return null;
                    };
                }
                util.notEnumerableProp(Promise, "_getDomain", getDomain);

                var es5 = require("./es5");
                var Async = require("./async");
                var async = new Async();
                es5.defineProperty(Promise, "_async", {value: async});
                var errors = require("./errors");
                var TypeError = Promise.TypeError = errors.TypeError;
                Promise.RangeError = errors.RangeError;
                var CancellationError = Promise.CancellationError = errors.CancellationError;
                Promise.TimeoutError = errors.TimeoutError;
                Promise.OperationalError = errors.OperationalError;
                Promise.RejectionError = errors.OperationalError;
                Promise.AggregateError = errors.AggregateError;
                var INTERNAL = function(){};
                var APPLY = {};
                var NEXT_FILTER = {};
                var tryConvertToPromise = require("./thenables")(Promise, INTERNAL);
                var PromiseArray =
                    require("./promise_array")(Promise, INTERNAL,
                        tryConvertToPromise, apiRejection, Proxyable);
                var Context = require("./context")(Promise);
                /*jshint unused:false*/
                var createContext = Context.create;
                var debug = require("./debuggability")(Promise, Context);
                var CapturedTrace = debug.CapturedTrace;
                var PassThroughHandlerContext =
                    require("./finally")(Promise, tryConvertToPromise);
                var catchFilter = require("./catch_filter")(NEXT_FILTER);
                var nodebackForPromise = require("./nodeback");
                var errorObj = util.errorObj;
                var tryCatch = util.tryCatch;
                function check(self, executor) {
                    if (typeof executor !== "function") {
                        throw new TypeError("expecting a function but got " + util.classString(executor));
                    }
                    if (self.constructor !== Promise) {
                        throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                    }
                }

                function Promise(executor) {
                    this._bitField = 0;
                    this._fulfillmentHandler0 = undefined;
                    this._rejectionHandler0 = undefined;
                    this._promise0 = undefined;
                    this._receiver0 = undefined;
                    if (executor !== INTERNAL) {
                        check(this, executor);
                        this._resolveFromExecutor(executor);
                    }
                    this._promiseCreated();
                    this._fireEvent("promiseCreated", this);
                }

                Promise.prototype.toString = function () {
                    return "[object Promise]";
                };

                Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
                    var len = arguments.length;
                    if (len > 1) {
                        var catchInstances = new Array(len - 1),
                            j = 0, i;
                        for (i = 0; i < len - 1; ++i) {
                            var item = arguments[i];
                            if (util.isObject(item)) {
                                catchInstances[j++] = item;
                            } else {
                                return apiRejection("expecting an object but got " +
                                    "A catch statement predicate " + util.classString(item));
                            }
                        }
                        catchInstances.length = j;
                        fn = arguments[i];
                        return this.then(undefined, catchFilter(catchInstances, fn, this));
                    }
                    return this.then(undefined, fn);
                };

                Promise.prototype.reflect = function () {
                    return this._then(reflectHandler,
                        reflectHandler, undefined, this, undefined);
                };

                Promise.prototype.then = function (didFulfill, didReject) {
                    if (debug.warnings() && arguments.length > 0 &&
                        typeof didFulfill !== "function" &&
                        typeof didReject !== "function") {
                        var msg = ".then() only accepts functions but was passed: " +
                            util.classString(didFulfill);
                        if (arguments.length > 1) {
                            msg += ", " + util.classString(didReject);
                        }
                        this._warn(msg);
                    }
                    return this._then(didFulfill, didReject, undefined, undefined, undefined);
                };

                Promise.prototype.done = function (didFulfill, didReject) {
                    var promise =
                        this._then(didFulfill, didReject, undefined, undefined, undefined);
                    promise._setIsFinal();
                };

                Promise.prototype.spread = function (fn) {
                    if (typeof fn !== "function") {
                        return apiRejection("expecting a function but got " + util.classString(fn));
                    }
                    return this.all()._then(fn, undefined, undefined, APPLY, undefined);
                };

                Promise.prototype.toJSON = function () {
                    var ret = {
                        isFulfilled: false,
                        isRejected: false,
                        fulfillmentValue: undefined,
                        rejectionReason: undefined
                    };
                    if (this.isFulfilled()) {
                        ret.fulfillmentValue = this.value();
                        ret.isFulfilled = true;
                    } else if (this.isRejected()) {
                        ret.rejectionReason = this.reason();
                        ret.isRejected = true;
                    }
                    return ret;
                };

                Promise.prototype.all = function () {
                    if (arguments.length > 0) {
                        this._warn(".all() was passed arguments but it does not take any");
                    }
                    return new PromiseArray(this).promise();
                };

                Promise.prototype.error = function (fn) {
                    return this.caught(util.originatesFromRejection, fn);
                };

                Promise.getNewLibraryCopy = module.exports;

                Promise.is = function (val) {
                    return val instanceof Promise;
                };

                Promise.fromNode = Promise.fromCallback = function(fn) {
                    var ret = new Promise(INTERNAL);
                    ret._captureStackTrace();
                    var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
                        : false;
                    var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
                    if (result === errorObj) {
                        ret._rejectCallback(result.e, true);
                    }
                    if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
                    return ret;
                };

                Promise.all = function (promises) {
                    return new PromiseArray(promises).promise();
                };

                Promise.cast = function (obj) {
                    var ret = tryConvertToPromise(obj);
                    if (!(ret instanceof Promise)) {
                        ret = new Promise(INTERNAL);
                        ret._captureStackTrace();
                        ret._setFulfilled();
                        ret._rejectionHandler0 = obj;
                    }
                    return ret;
                };

                Promise.resolve = Promise.fulfilled = Promise.cast;

                Promise.reject = Promise.rejected = function (reason) {
                    var ret = new Promise(INTERNAL);
                    ret._captureStackTrace();
                    ret._rejectCallback(reason, true);
                    return ret;
                };

                Promise.setScheduler = function(fn) {
                    if (typeof fn !== "function") {
                        throw new TypeError("expecting a function but got " + util.classString(fn));
                    }
                    return async.setScheduler(fn);
                };

                Promise.prototype._then = function (
                    didFulfill,
                    didReject,
                    _,    receiver,
                    internalData
                ) {
                    var haveInternalData = internalData !== undefined;
                    var promise = haveInternalData ? internalData : new Promise(INTERNAL);
                    var target = this._target();
                    var bitField = target._bitField;

                    if (!haveInternalData) {
                        promise._propagateFrom(this, 3);
                        promise._captureStackTrace();
                        if (receiver === undefined &&
                            ((this._bitField & 2097152) !== 0)) {
                            if (!((bitField & 50397184) === 0)) {
                                receiver = this._boundValue();
                            } else {
                                receiver = target === this ? undefined : this._boundTo;
                            }
                        }
                        this._fireEvent("promiseChained", this, promise);
                    }

                    var domain = getDomain();
                    if (!((bitField & 50397184) === 0)) {
                        var handler, value, settler = target._settlePromiseCtx;
                        if (((bitField & 33554432) !== 0)) {
                            value = target._rejectionHandler0;
                            handler = didFulfill;
                        } else if (((bitField & 16777216) !== 0)) {
                            value = target._fulfillmentHandler0;
                            handler = didReject;
                            target._unsetRejectionIsUnhandled();
                        } else {
                            settler = target._settlePromiseLateCancellationObserver;
                            value = new CancellationError("late cancellation observer");
                            target._attachExtraTrace(value);
                            handler = didReject;
                        }

                        async.invoke(settler, target, {
                            handler: domain === null ? handler
                                : (typeof handler === "function" &&
                                    util.domainBind(domain, handler)),
                            promise: promise,
                            receiver: receiver,
                            value: value
                        });
                    } else {
                        target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
                    }

                    return promise;
                };

                Promise.prototype._length = function () {
                    return this._bitField & 65535;
                };

                Promise.prototype._isFateSealed = function () {
                    return (this._bitField & 117506048) !== 0;
                };

                Promise.prototype._isFollowing = function () {
                    return (this._bitField & 67108864) === 67108864;
                };

                Promise.prototype._setLength = function (len) {
                    this._bitField = (this._bitField & -65536) |
                        (len & 65535);
                };

                Promise.prototype._setFulfilled = function () {
                    this._bitField = this._bitField | 33554432;
                    this._fireEvent("promiseFulfilled", this);
                };

                Promise.prototype._setRejected = function () {
                    this._bitField = this._bitField | 16777216;
                    this._fireEvent("promiseRejected", this);
                };

                Promise.prototype._setFollowing = function () {
                    this._bitField = this._bitField | 67108864;
                    this._fireEvent("promiseResolved", this);
                };

                Promise.prototype._setIsFinal = function () {
                    this._bitField = this._bitField | 4194304;
                };

                Promise.prototype._isFinal = function () {
                    return (this._bitField & 4194304) > 0;
                };

                Promise.prototype._unsetCancelled = function() {
                    this._bitField = this._bitField & (~65536);
                };

                Promise.prototype._setCancelled = function() {
                    this._bitField = this._bitField | 65536;
                    this._fireEvent("promiseCancelled", this);
                };

                Promise.prototype._setWillBeCancelled = function() {
                    this._bitField = this._bitField | 8388608;
                };

                Promise.prototype._setAsyncGuaranteed = function() {
                    if (async.hasCustomScheduler()) return;
                    this._bitField = this._bitField | 134217728;
                };

                Promise.prototype._receiverAt = function (index) {
                    var ret = index === 0 ? this._receiver0 : this[
                    index * 4 - 4 + 3];
                    if (ret === UNDEFINED_BINDING) {
                        return undefined;
                    } else if (ret === undefined && this._isBound()) {
                        return this._boundValue();
                    }
                    return ret;
                };

                Promise.prototype._promiseAt = function (index) {
                    return this[
                    index * 4 - 4 + 2];
                };

                Promise.prototype._fulfillmentHandlerAt = function (index) {
                    return this[
                    index * 4 - 4 + 0];
                };

                Promise.prototype._rejectionHandlerAt = function (index) {
                    return this[
                    index * 4 - 4 + 1];
                };

                Promise.prototype._boundValue = function() {};

                Promise.prototype._migrateCallback0 = function (follower) {
                    var bitField = follower._bitField;
                    var fulfill = follower._fulfillmentHandler0;
                    var reject = follower._rejectionHandler0;
                    var promise = follower._promise0;
                    var receiver = follower._receiverAt(0);
                    if (receiver === undefined) receiver = UNDEFINED_BINDING;
                    this._addCallbacks(fulfill, reject, promise, receiver, null);
                };

                Promise.prototype._migrateCallbackAt = function (follower, index) {
                    var fulfill = follower._fulfillmentHandlerAt(index);
                    var reject = follower._rejectionHandlerAt(index);
                    var promise = follower._promiseAt(index);
                    var receiver = follower._receiverAt(index);
                    if (receiver === undefined) receiver = UNDEFINED_BINDING;
                    this._addCallbacks(fulfill, reject, promise, receiver, null);
                };

                Promise.prototype._addCallbacks = function (
                    fulfill,
                    reject,
                    promise,
                    receiver,
                    domain
                ) {
                    var index = this._length();

                    if (index >= 65535 - 4) {
                        index = 0;
                        this._setLength(0);
                    }

                    if (index === 0) {
                        this._promise0 = promise;
                        this._receiver0 = receiver;
                        if (typeof fulfill === "function") {
                            this._fulfillmentHandler0 =
                                domain === null ? fulfill : util.domainBind(domain, fulfill);
                        }
                        if (typeof reject === "function") {
                            this._rejectionHandler0 =
                                domain === null ? reject : util.domainBind(domain, reject);
                        }
                    } else {
                        var base = index * 4 - 4;
                        this[base + 2] = promise;
                        this[base + 3] = receiver;
                        if (typeof fulfill === "function") {
                            this[base + 0] =
                                domain === null ? fulfill : util.domainBind(domain, fulfill);
                        }
                        if (typeof reject === "function") {
                            this[base + 1] =
                                domain === null ? reject : util.domainBind(domain, reject);
                        }
                    }
                    this._setLength(index + 1);
                    return index;
                };

                Promise.prototype._proxy = function (proxyable, arg) {
                    this._addCallbacks(undefined, undefined, arg, proxyable, null);
                };

                Promise.prototype._resolveCallback = function(value, shouldBind) {
                    if (((this._bitField & 117506048) !== 0)) return;
                    if (value === this)
                        return this._rejectCallback(makeSelfResolutionError(), false);
                    var maybePromise = tryConvertToPromise(value, this);
                    if (!(maybePromise instanceof Promise)) return this._fulfill(value);

                    if (shouldBind) this._propagateFrom(maybePromise, 2);

                    var promise = maybePromise._target();

                    if (promise === this) {
                        this._reject(makeSelfResolutionError());
                        return;
                    }

                    var bitField = promise._bitField;
                    if (((bitField & 50397184) === 0)) {
                        var len = this._length();
                        if (len > 0) promise._migrateCallback0(this);
                        for (var i = 1; i < len; ++i) {
                            promise._migrateCallbackAt(this, i);
                        }
                        this._setFollowing();
                        this._setLength(0);
                        this._setFollowee(promise);
                    } else if (((bitField & 33554432) !== 0)) {
                        this._fulfill(promise._value());
                    } else if (((bitField & 16777216) !== 0)) {
                        this._reject(promise._reason());
                    } else {
                        var reason = new CancellationError("late cancellation observer");
                        promise._attachExtraTrace(reason);
                        this._reject(reason);
                    }
                };

                Promise.prototype._rejectCallback =
                    function(reason, synchronous, ignoreNonErrorWarnings) {
                        var trace = util.ensureErrorObject(reason);
                        var hasStack = trace === reason;
                        if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
                            var message = "a promise was rejected with a non-error: " +
                                util.classString(reason);
                            this._warn(message, true);
                        }
                        this._attachExtraTrace(trace, synchronous ? hasStack : false);
                        this._reject(reason);
                    };

                Promise.prototype._resolveFromExecutor = function (executor) {
                    var promise = this;
                    this._captureStackTrace();
                    this._pushContext();
                    var synchronous = true;
                    var r = this._execute(executor, function(value) {
                        promise._resolveCallback(value);
                    }, function (reason) {
                        promise._rejectCallback(reason, synchronous);
                    });
                    synchronous = false;
                    this._popContext();

                    if (r !== undefined) {
                        promise._rejectCallback(r, true);
                    }
                };

                Promise.prototype._settlePromiseFromHandler = function (
                    handler, receiver, value, promise
                ) {
                    var bitField = promise._bitField;
                    if (((bitField & 65536) !== 0)) return;
                    promise._pushContext();
                    var x;
                    if (receiver === APPLY) {
                        if (!value || typeof value.length !== "number") {
                            x = errorObj;
                            x.e = new TypeError("cannot .spread() a non-array: " +
                                util.classString(value));
                        } else {
                            x = tryCatch(handler).apply(this._boundValue(), value);
                        }
                    } else {
                        x = tryCatch(handler).call(receiver, value);
                    }
                    var promiseCreated = promise._popContext();
                    bitField = promise._bitField;
                    if (((bitField & 65536) !== 0)) return;

                    if (x === NEXT_FILTER) {
                        promise._reject(value);
                    } else if (x === errorObj) {
                        promise._rejectCallback(x.e, false);
                    } else {
                        debug.checkForgottenReturns(x, promiseCreated, "",  promise, this);
                        promise._resolveCallback(x);
                    }
                };

                Promise.prototype._target = function() {
                    var ret = this;
                    while (ret._isFollowing()) ret = ret._followee();
                    return ret;
                };

                Promise.prototype._followee = function() {
                    return this._rejectionHandler0;
                };

                Promise.prototype._setFollowee = function(promise) {
                    this._rejectionHandler0 = promise;
                };

                Promise.prototype._settlePromise = function(promise, handler, receiver, value) {
                    var isPromise = promise instanceof Promise;
                    var bitField = this._bitField;
                    var asyncGuaranteed = ((bitField & 134217728) !== 0);
                    if (((bitField & 65536) !== 0)) {
                        if (isPromise) promise._invokeInternalOnCancel();

                        if (receiver instanceof PassThroughHandlerContext &&
                            receiver.isFinallyHandler()) {
                            receiver.cancelPromise = promise;
                            if (tryCatch(handler).call(receiver, value) === errorObj) {
                                promise._reject(errorObj.e);
                            }
                        } else if (handler === reflectHandler) {
                            promise._fulfill(reflectHandler.call(receiver));
                        } else if (receiver instanceof Proxyable) {
                            receiver._promiseCancelled(promise);
                        } else if (isPromise || promise instanceof PromiseArray) {
                            promise._cancel();
                        } else {
                            receiver.cancel();
                        }
                    } else if (typeof handler === "function") {
                        if (!isPromise) {
                            handler.call(receiver, value, promise);
                        } else {
                            if (asyncGuaranteed) promise._setAsyncGuaranteed();
                            this._settlePromiseFromHandler(handler, receiver, value, promise);
                        }
                    } else if (receiver instanceof Proxyable) {
                        if (!receiver._isResolved()) {
                            if (((bitField & 33554432) !== 0)) {
                                receiver._promiseFulfilled(value, promise);
                            } else {
                                receiver._promiseRejected(value, promise);
                            }
                        }
                    } else if (isPromise) {
                        if (asyncGuaranteed) promise._setAsyncGuaranteed();
                        if (((bitField & 33554432) !== 0)) {
                            promise._fulfill(value);
                        } else {
                            promise._reject(value);
                        }
                    }
                };

                Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) {
                    var handler = ctx.handler;
                    var promise = ctx.promise;
                    var receiver = ctx.receiver;
                    var value = ctx.value;
                    if (typeof handler === "function") {
                        if (!(promise instanceof Promise)) {
                            handler.call(receiver, value, promise);
                        } else {
                            this._settlePromiseFromHandler(handler, receiver, value, promise);
                        }
                    } else if (promise instanceof Promise) {
                        promise._reject(value);
                    }
                };

                Promise.prototype._settlePromiseCtx = function(ctx) {
                    this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
                };

                Promise.prototype._settlePromise0 = function(handler, value, bitField) {
                    var promise = this._promise0;
                    var receiver = this._receiverAt(0);
                    this._promise0 = undefined;
                    this._receiver0 = undefined;
                    this._settlePromise(promise, handler, receiver, value);
                };

                Promise.prototype._clearCallbackDataAtIndex = function(index) {
                    var base = index * 4 - 4;
                    this[base + 2] =
                        this[base + 3] =
                            this[base + 0] =
                                this[base + 1] = undefined;
                };

                Promise.prototype._fulfill = function (value) {
                    var bitField = this._bitField;
                    if (((bitField & 117506048) >>> 16)) return;
                    if (value === this) {
                        var err = makeSelfResolutionError();
                        this._attachExtraTrace(err);
                        return this._reject(err);
                    }
                    this._setFulfilled();
                    this._rejectionHandler0 = value;

                    if ((bitField & 65535) > 0) {
                        if (((bitField & 134217728) !== 0)) {
                            this._settlePromises();
                        } else {
                            async.settlePromises(this);
                        }
                    }
                };

                Promise.prototype._reject = function (reason) {
                    var bitField = this._bitField;
                    if (((bitField & 117506048) >>> 16)) return;
                    this._setRejected();
                    this._fulfillmentHandler0 = reason;

                    if (this._isFinal()) {
                        return async.fatalError(reason, util.isNode);
                    }

                    if ((bitField & 65535) > 0) {
                        async.settlePromises(this);
                    } else {
                        this._ensurePossibleRejectionHandled();
                    }
                };

                Promise.prototype._fulfillPromises = function (len, value) {
                    for (var i = 1; i < len; i++) {
                        var handler = this._fulfillmentHandlerAt(i);
                        var promise = this._promiseAt(i);
                        var receiver = this._receiverAt(i);
                        this._clearCallbackDataAtIndex(i);
                        this._settlePromise(promise, handler, receiver, value);
                    }
                };

                Promise.prototype._rejectPromises = function (len, reason) {
                    for (var i = 1; i < len; i++) {
                        var handler = this._rejectionHandlerAt(i);
                        var promise = this._promiseAt(i);
                        var receiver = this._receiverAt(i);
                        this._clearCallbackDataAtIndex(i);
                        this._settlePromise(promise, handler, receiver, reason);
                    }
                };

                Promise.prototype._settlePromises = function () {
                    var bitField = this._bitField;
                    var len = (bitField & 65535);

                    if (len > 0) {
                        if (((bitField & 16842752) !== 0)) {
                            var reason = this._fulfillmentHandler0;
                            this._settlePromise0(this._rejectionHandler0, reason, bitField);
                            this._rejectPromises(len, reason);
                        } else {
                            var value = this._rejectionHandler0;
                            this._settlePromise0(this._fulfillmentHandler0, value, bitField);
                            this._fulfillPromises(len, value);
                        }
                        this._setLength(0);
                    }
                    this._clearCancellationData();
                };

                Promise.prototype._settledValue = function() {
                    var bitField = this._bitField;
                    if (((bitField & 33554432) !== 0)) {
                        return this._rejectionHandler0;
                    } else if (((bitField & 16777216) !== 0)) {
                        return this._fulfillmentHandler0;
                    }
                };

                function deferResolve(v) {this.promise._resolveCallback(v);}
                function deferReject(v) {this.promise._rejectCallback(v, false);}

                Promise.defer = Promise.pending = function() {
                    debug.deprecated("Promise.defer", "new Promise");
                    var promise = new Promise(INTERNAL);
                    return {
                        promise: promise,
                        resolve: deferResolve,
                        reject: deferReject
                    };
                };

                util.notEnumerableProp(Promise,
                    "_makeSelfResolutionError",
                    makeSelfResolutionError);

                require("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
                    debug);
                require("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
                require("./cancel")(Promise, PromiseArray, apiRejection, debug);
                require("./direct_resolve")(Promise);
                require("./synchronous_inspection")(Promise);
                require("./join")(
                    Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);
                Promise.Promise = Promise;
                Promise.version = "3.4.7";
                require('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
                require('./call_get.js')(Promise);
                require('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);
                require('./timers.js')(Promise, INTERNAL, debug);
                require('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);
                require('./nodeify.js')(Promise);
                require('./promisify.js')(Promise, INTERNAL);
                require('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
                require('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
                require('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
                require('./settle.js')(Promise, PromiseArray, debug);
                require('./some.js')(Promise, PromiseArray, apiRejection);
                require('./filter.js')(Promise, INTERNAL);
                require('./each.js')(Promise, INTERNAL);
                require('./any.js')(Promise);

                util.toFastProperties(Promise);
                util.toFastProperties(Promise.prototype);
                function fillTypes(value) {
                    var p = new Promise(INTERNAL);
                    p._fulfillmentHandler0 = value;
                    p._rejectionHandler0 = value;
                    p._promise0 = value;
                    p._receiver0 = value;
                }
                // Complete slack tracking, opt out of field-type tracking and
                // stabilize map
                fillTypes({a: 1});
                fillTypes({b: 2});
                fillTypes({c: 3});
                fillTypes(1);
                fillTypes(function(){});
                fillTypes(undefined);
                fillTypes(false);
                fillTypes(new Promise(INTERNAL));
                debug.setBounds(Async.firstLineError, util.lastLineError);
                return Promise;

            };

        }).call(this)}).call(this,require('_process'))
    },{"./any.js":41,"./async":42,"./bind":43,"./call_get.js":44,"./cancel":45,"./catch_filter":46,"./context":47,"./debuggability":48,"./direct_resolve":49,"./each.js":50,"./errors":51,"./es5":52,"./filter.js":53,"./finally":54,"./generators.js":55,"./join":56,"./map.js":57,"./method":58,"./nodeback":59,"./nodeify.js":60,"./promise_array":62,"./promisify.js":63,"./props.js":64,"./race.js":66,"./reduce.js":67,"./settle.js":69,"./some.js":70,"./synchronous_inspection":71,"./thenables":72,"./timers.js":73,"./using.js":74,"./util":75,"_process":102}],62:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL, tryConvertToPromise,
                                  apiRejection, Proxyable) {
            var util = require("./util");
            var isArray = util.isArray;

            function toResolutionValue(val) {
                switch(val) {
                    case -2: return [];
                    case -3: return {};
                }
            }

            function PromiseArray(values) {
                var promise = this._promise = new Promise(INTERNAL);
                if (values instanceof Promise) {
                    promise._propagateFrom(values, 3);
                }
                promise._setOnCancel(this);
                this._values = values;
                this._length = 0;
                this._totalResolved = 0;
                this._init(undefined, -2);
            }
            util.inherits(PromiseArray, Proxyable);

            PromiseArray.prototype.length = function () {
                return this._length;
            };

            PromiseArray.prototype.promise = function () {
                return this._promise;
            };

            PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
                var values = tryConvertToPromise(this._values, this._promise);
                if (values instanceof Promise) {
                    values = values._target();
                    var bitField = values._bitField;
                    ;
                    this._values = values;

                    if (((bitField & 50397184) === 0)) {
                        this._promise._setAsyncGuaranteed();
                        return values._then(
                            init,
                            this._reject,
                            undefined,
                            this,
                            resolveValueIfEmpty
                        );
                    } else if (((bitField & 33554432) !== 0)) {
                        values = values._value();
                    } else if (((bitField & 16777216) !== 0)) {
                        return this._reject(values._reason());
                    } else {
                        return this._cancel();
                    }
                }
                values = util.asArray(values);
                if (values === null) {
                    var err = apiRejection(
                        "expecting an array or an iterable object but got " + util.classString(values)).reason();
                    this._promise._rejectCallback(err, false);
                    return;
                }

                if (values.length === 0) {
                    if (resolveValueIfEmpty === -5) {
                        this._resolveEmptyArray();
                    }
                    else {
                        this._resolve(toResolutionValue(resolveValueIfEmpty));
                    }
                    return;
                }
                this._iterate(values);
            };

            PromiseArray.prototype._iterate = function(values) {
                var len = this.getActualLength(values.length);
                this._length = len;
                this._values = this.shouldCopyValues() ? new Array(len) : this._values;
                var result = this._promise;
                var isResolved = false;
                var bitField = null;
                for (var i = 0; i < len; ++i) {
                    var maybePromise = tryConvertToPromise(values[i], result);

                    if (maybePromise instanceof Promise) {
                        maybePromise = maybePromise._target();
                        bitField = maybePromise._bitField;
                    } else {
                        bitField = null;
                    }

                    if (isResolved) {
                        if (bitField !== null) {
                            maybePromise.suppressUnhandledRejections();
                        }
                    } else if (bitField !== null) {
                        if (((bitField & 50397184) === 0)) {
                            maybePromise._proxy(this, i);
                            this._values[i] = maybePromise;
                        } else if (((bitField & 33554432) !== 0)) {
                            isResolved = this._promiseFulfilled(maybePromise._value(), i);
                        } else if (((bitField & 16777216) !== 0)) {
                            isResolved = this._promiseRejected(maybePromise._reason(), i);
                        } else {
                            isResolved = this._promiseCancelled(i);
                        }
                    } else {
                        isResolved = this._promiseFulfilled(maybePromise, i);
                    }
                }
                if (!isResolved) result._setAsyncGuaranteed();
            };

            PromiseArray.prototype._isResolved = function () {
                return this._values === null;
            };

            PromiseArray.prototype._resolve = function (value) {
                this._values = null;
                this._promise._fulfill(value);
            };

            PromiseArray.prototype._cancel = function() {
                if (this._isResolved() || !this._promise._isCancellable()) return;
                this._values = null;
                this._promise._cancel();
            };

            PromiseArray.prototype._reject = function (reason) {
                this._values = null;
                this._promise._rejectCallback(reason, false);
            };

            PromiseArray.prototype._promiseFulfilled = function (value, index) {
                this._values[index] = value;
                var totalResolved = ++this._totalResolved;
                if (totalResolved >= this._length) {
                    this._resolve(this._values);
                    return true;
                }
                return false;
            };

            PromiseArray.prototype._promiseCancelled = function() {
                this._cancel();
                return true;
            };

            PromiseArray.prototype._promiseRejected = function (reason) {
                this._totalResolved++;
                this._reject(reason);
                return true;
            };

            PromiseArray.prototype._resultCancelled = function() {
                if (this._isResolved()) return;
                var values = this._values;
                this._cancel();
                if (values instanceof Promise) {
                    values.cancel();
                } else {
                    for (var i = 0; i < values.length; ++i) {
                        if (values[i] instanceof Promise) {
                            values[i].cancel();
                        }
                    }
                }
            };

            PromiseArray.prototype.shouldCopyValues = function () {
                return true;
            };

            PromiseArray.prototype.getActualLength = function (len) {
                return len;
            };

            return PromiseArray;
        };

    },{"./util":75}],63:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL) {
            var THIS = {};
            var util = require("./util");
            var nodebackForPromise = require("./nodeback");
            var withAppended = util.withAppended;
            var maybeWrapAsError = util.maybeWrapAsError;
            var canEvaluate = util.canEvaluate;
            var TypeError = require("./errors").TypeError;
            var defaultSuffix = "Async";
            var defaultPromisified = {__isPromisified__: true};
            var noCopyProps = [
                "arity",    "length",
                "name",
                "arguments",
                "caller",
                "callee",
                "prototype",
                "__isPromisified__"
            ];
            var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");

            var defaultFilter = function(name) {
                return util.isIdentifier(name) &&
                    name.charAt(0) !== "_" &&
                    name !== "constructor";
            };

            function propsFilter(key) {
                return !noCopyPropsPattern.test(key);
            }

            function isPromisified(fn) {
                try {
                    return fn.__isPromisified__ === true;
                }
                catch (e) {
                    return false;
                }
            }

            function hasPromisified(obj, key, suffix) {
                var val = util.getDataPropertyOrDefault(obj, key + suffix,
                    defaultPromisified);
                return val ? isPromisified(val) : false;
            }
            function checkValid(ret, suffix, suffixRegexp) {
                for (var i = 0; i < ret.length; i += 2) {
                    var key = ret[i];
                    if (suffixRegexp.test(key)) {
                        var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
                        for (var j = 0; j < ret.length; j += 2) {
                            if (ret[j] === keyWithoutAsyncSuffix) {
                                throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/MqrFmX\u000a"
                                    .replace("%s", suffix));
                            }
                        }
                    }
                }
            }

            function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
                var keys = util.inheritedDataKeys(obj);
                var ret = [];
                for (var i = 0; i < keys.length; ++i) {
                    var key = keys[i];
                    var value = obj[key];
                    var passesDefaultFilter = filter === defaultFilter
                        ? true : defaultFilter(key, value, obj);
                    if (typeof value === "function" &&
                        !isPromisified(value) &&
                        !hasPromisified(obj, key, suffix) &&
                        filter(key, value, obj, passesDefaultFilter)) {
                        ret.push(key, value);
                    }
                }
                checkValid(ret, suffix, suffixRegexp);
                return ret;
            }

            var escapeIdentRegex = function(str) {
                return str.replace(/([$])/, "\\$");
            };

            var makeNodePromisifiedEval;
            if (true) {
                var switchCaseArgumentOrder = function(likelyArgumentCount) {
                    var ret = [likelyArgumentCount];
                    var min = Math.max(0, likelyArgumentCount - 1 - 3);
                    for(var i = likelyArgumentCount - 1; i >= min; --i) {
                        ret.push(i);
                    }
                    for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
                        ret.push(i);
                    }
                    return ret;
                };

                var argumentSequence = function(argumentCount) {
                    return util.filledRange(argumentCount, "_arg", "");
                };

                var parameterDeclaration = function(parameterCount) {
                    return util.filledRange(
                        Math.max(parameterCount, 3), "_arg", "");
                };

                var parameterCount = function(fn) {
                    if (typeof fn.length === "number") {
                        return Math.max(Math.min(fn.length, 1023 + 1), 0);
                    }
                    return 0;
                };

                makeNodePromisifiedEval =
                    function(callback, receiver, originalName, fn, _, multiArgs) {
                        var newParameterCount = Math.max(0, parameterCount(fn) - 1);
                        var argumentOrder = switchCaseArgumentOrder(newParameterCount);
                        var shouldProxyThis = typeof callback === "string" || receiver === THIS;

                        function generateCallForArgumentCount(count) {
                            var args = argumentSequence(count).join(", ");
                            var comma = count > 0 ? ", " : "";
                            var ret;
                            if (shouldProxyThis) {
                                ret = "ret = callback.call(this, {{args}}, nodeback); break;\n";
                            } else {
                                ret = receiver === undefined
                                    ? "ret = callback({{args}}, nodeback); break;\n"
                                    : "ret = callback.call(receiver, {{args}}, nodeback); break;\n";
                            }
                            return ret.replace("{{args}}", args).replace(", ", comma);
                        }

                        function generateArgumentSwitchCase() {
                            var ret = "";
                            for (var i = 0; i < argumentOrder.length; ++i) {
                                ret += "case " + argumentOrder[i] +":" +
                                    generateCallForArgumentCount(argumentOrder[i]);
                            }

                            ret += "                                                             \n\
        default:                                                             \n\
            var args = new Array(len + 1);                                   \n\
            var i = 0;                                                       \n\
            for (var i = 0; i < len; ++i) {                                  \n\
               args[i] = arguments[i];                                       \n\
            }                                                                \n\
            args[i] = nodeback;                                              \n\
            [CodeForCall]                                                    \n\
            break;                                                           \n\
        ".replace("[CodeForCall]", (shouldProxyThis
                                ? "ret = callback.apply(this, args);\n"
                                : "ret = callback.apply(receiver, args);\n"));
                            return ret;
                        }

                        var getFunctionCode = typeof callback === "string"
                            ? ("this != null ? this['"+callback+"'] : fn")
                            : "fn";
                        var body = "'use strict';                                                \n\
        var ret = function (Parameters) {                                    \n\
            'use strict';                                                    \n\
            var len = arguments.length;                                      \n\
            var promise = new Promise(INTERNAL);                             \n\
            promise._captureStackTrace();                                    \n\
            var nodeback = nodebackForPromise(promise, " + multiArgs + ");   \n\
            var ret;                                                         \n\
            var callback = tryCatch([GetFunctionCode]);                      \n\
            switch(len) {                                                    \n\
                [CodeForSwitchCase]                                          \n\
            }                                                                \n\
            if (ret === errorObj) {                                          \n\
                promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\
            }                                                                \n\
            if (!promise._isFateSealed()) promise._setAsyncGuaranteed();     \n\
            return promise;                                                  \n\
        };                                                                   \n\
        notEnumerableProp(ret, '__isPromisified__', true);                   \n\
        return ret;                                                          \n\
    ".replace("[CodeForSwitchCase]", generateArgumentSwitchCase())
                            .replace("[GetFunctionCode]", getFunctionCode);
                        body = body.replace("Parameters", parameterDeclaration(newParameterCount));
                        return new Function("Promise",
                            "fn",
                            "receiver",
                            "withAppended",
                            "maybeWrapAsError",
                            "nodebackForPromise",
                            "tryCatch",
                            "errorObj",
                            "notEnumerableProp",
                            "INTERNAL",
                            body)(
                            Promise,
                            fn,
                            receiver,
                            withAppended,
                            maybeWrapAsError,
                            nodebackForPromise,
                            util.tryCatch,
                            util.errorObj,
                            util.notEnumerableProp,
                            INTERNAL);
                    };
            }

            function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {
                var defaultThis = (function() {return this;})();
                var method = callback;
                if (typeof method === "string") {
                    callback = fn;
                }
                function promisified() {
                    var _receiver = receiver;
                    if (receiver === THIS) _receiver = this;
                    var promise = new Promise(INTERNAL);
                    promise._captureStackTrace();
                    var cb = typeof method === "string" && this !== defaultThis
                        ? this[method] : callback;
                    var fn = nodebackForPromise(promise, multiArgs);
                    try {
                        cb.apply(_receiver, withAppended(arguments, fn));
                    } catch(e) {
                        promise._rejectCallback(maybeWrapAsError(e), true, true);
                    }
                    if (!promise._isFateSealed()) promise._setAsyncGuaranteed();
                    return promise;
                }
                util.notEnumerableProp(promisified, "__isPromisified__", true);
                return promisified;
            }

            var makeNodePromisified = canEvaluate
                ? makeNodePromisifiedEval
                : makeNodePromisifiedClosure;

            function promisifyAll(obj, suffix, filter, promisifier, multiArgs) {
                var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
                var methods =
                    promisifiableMethods(obj, suffix, suffixRegexp, filter);

                for (var i = 0, len = methods.length; i < len; i+= 2) {
                    var key = methods[i];
                    var fn = methods[i+1];
                    var promisifiedKey = key + suffix;
                    if (promisifier === makeNodePromisified) {
                        obj[promisifiedKey] =
                            makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);
                    } else {
                        var promisified = promisifier(fn, function() {
                            return makeNodePromisified(key, THIS, key,
                                fn, suffix, multiArgs);
                        });
                        util.notEnumerableProp(promisified, "__isPromisified__", true);
                        obj[promisifiedKey] = promisified;
                    }
                }
                util.toFastProperties(obj);
                return obj;
            }

            function promisify(callback, receiver, multiArgs) {
                return makeNodePromisified(callback, receiver, undefined,
                    callback, null, multiArgs);
            }

            Promise.promisify = function (fn, options) {
                if (typeof fn !== "function") {
                    throw new TypeError("expecting a function but got " + util.classString(fn));
                }
                if (isPromisified(fn)) {
                    return fn;
                }
                options = Object(options);
                var receiver = options.context === undefined ? THIS : options.context;
                var multiArgs = !!options.multiArgs;
                var ret = promisify(fn, receiver, multiArgs);
                util.copyDescriptors(fn, ret, propsFilter);
                return ret;
            };

            Promise.promisifyAll = function (target, options) {
                if (typeof target !== "function" && typeof target !== "object") {
                    throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                }
                options = Object(options);
                var multiArgs = !!options.multiArgs;
                var suffix = options.suffix;
                if (typeof suffix !== "string") suffix = defaultSuffix;
                var filter = options.filter;
                if (typeof filter !== "function") filter = defaultFilter;
                var promisifier = options.promisifier;
                if (typeof promisifier !== "function") promisifier = makeNodePromisified;

                if (!util.isIdentifier(suffix)) {
                    throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                }

                var keys = util.inheritedDataKeys(target);
                for (var i = 0; i < keys.length; ++i) {
                    var value = target[keys[i]];
                    if (keys[i] !== "constructor" &&
                        util.isClass(value)) {
                        promisifyAll(value.prototype, suffix, filter, promisifier,
                            multiArgs);
                        promisifyAll(value, suffix, filter, promisifier, multiArgs);
                    }
                }

                return promisifyAll(target, suffix, filter, promisifier, multiArgs);
            };
        };


    },{"./errors":51,"./nodeback":59,"./util":75}],64:[function(require,module,exports){
        "use strict";
        module.exports = function(
            Promise, PromiseArray, tryConvertToPromise, apiRejection) {
            var util = require("./util");
            var isObject = util.isObject;
            var es5 = require("./es5");
            var Es6Map;
            if (typeof Map === "function") Es6Map = Map;

            var mapToEntries = (function() {
                var index = 0;
                var size = 0;

                function extractEntry(value, key) {
                    this[index] = value;
                    this[index + size] = key;
                    index++;
                }

                return function mapToEntries(map) {
                    size = map.size;
                    index = 0;
                    var ret = new Array(map.size * 2);
                    map.forEach(extractEntry, ret);
                    return ret;
                };
            })();

            var entriesToMap = function(entries) {
                var ret = new Es6Map();
                var length = entries.length / 2 | 0;
                for (var i = 0; i < length; ++i) {
                    var key = entries[length + i];
                    var value = entries[i];
                    ret.set(key, value);
                }
                return ret;
            };

            function PropertiesPromiseArray(obj) {
                var isMap = false;
                var entries;
                if (Es6Map !== undefined && obj instanceof Es6Map) {
                    entries = mapToEntries(obj);
                    isMap = true;
                } else {
                    var keys = es5.keys(obj);
                    var len = keys.length;
                    entries = new Array(len * 2);
                    for (var i = 0; i < len; ++i) {
                        var key = keys[i];
                        entries[i] = obj[key];
                        entries[i + len] = key;
                    }
                }
                this.constructor$(entries);
                this._isMap = isMap;
                this._init$(undefined, -3);
            }
            util.inherits(PropertiesPromiseArray, PromiseArray);

            PropertiesPromiseArray.prototype._init = function () {};

            PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
                this._values[index] = value;
                var totalResolved = ++this._totalResolved;
                if (totalResolved >= this._length) {
                    var val;
                    if (this._isMap) {
                        val = entriesToMap(this._values);
                    } else {
                        val = {};
                        var keyOffset = this.length();
                        for (var i = 0, len = this.length(); i < len; ++i) {
                            val[this._values[i + keyOffset]] = this._values[i];
                        }
                    }
                    this._resolve(val);
                    return true;
                }
                return false;
            };

            PropertiesPromiseArray.prototype.shouldCopyValues = function () {
                return false;
            };

            PropertiesPromiseArray.prototype.getActualLength = function (len) {
                return len >> 1;
            };

            function props(promises) {
                var ret;
                var castValue = tryConvertToPromise(promises);

                if (!isObject(castValue)) {
                    return apiRejection("cannot await properties of a non-object\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                } else if (castValue instanceof Promise) {
                    ret = castValue._then(
                        Promise.props, undefined, undefined, undefined, undefined);
                } else {
                    ret = new PropertiesPromiseArray(castValue).promise();
                }

                if (castValue instanceof Promise) {
                    ret._propagateFrom(castValue, 2);
                }
                return ret;
            }

            Promise.prototype.props = function () {
                return props(this);
            };

            Promise.props = function (promises) {
                return props(promises);
            };
        };

    },{"./es5":52,"./util":75}],65:[function(require,module,exports){
        "use strict";
        function arrayMove(src, srcIndex, dst, dstIndex, len) {
            for (var j = 0; j < len; ++j) {
                dst[j + dstIndex] = src[j + srcIndex];
                src[j + srcIndex] = void 0;
            }
        }

        function Queue(capacity) {
            this._capacity = capacity;
            this._length = 0;
            this._front = 0;
        }

        Queue.prototype._willBeOverCapacity = function (size) {
            return this._capacity < size;
        };

        Queue.prototype._pushOne = function (arg) {
            var length = this.length();
            this._checkCapacity(length + 1);
            var i = (this._front + length) & (this._capacity - 1);
            this[i] = arg;
            this._length = length + 1;
        };

        Queue.prototype.push = function (fn, receiver, arg) {
            var length = this.length() + 3;
            if (this._willBeOverCapacity(length)) {
                this._pushOne(fn);
                this._pushOne(receiver);
                this._pushOne(arg);
                return;
            }
            var j = this._front + length - 3;
            this._checkCapacity(length);
            var wrapMask = this._capacity - 1;
            this[(j + 0) & wrapMask] = fn;
            this[(j + 1) & wrapMask] = receiver;
            this[(j + 2) & wrapMask] = arg;
            this._length = length;
        };

        Queue.prototype.shift = function () {
            var front = this._front,
                ret = this[front];

            this[front] = undefined;
            this._front = (front + 1) & (this._capacity - 1);
            this._length--;
            return ret;
        };

        Queue.prototype.length = function () {
            return this._length;
        };

        Queue.prototype._checkCapacity = function (size) {
            if (this._capacity < size) {
                this._resizeTo(this._capacity << 1);
            }
        };

        Queue.prototype._resizeTo = function (capacity) {
            var oldCapacity = this._capacity;
            this._capacity = capacity;
            var front = this._front;
            var length = this._length;
            var moveItemsCount = (front + length) & (oldCapacity - 1);
            arrayMove(this, 0, this, oldCapacity, moveItemsCount);
        };

        module.exports = Queue;

    },{}],66:[function(require,module,exports){
        "use strict";
        module.exports = function(
            Promise, INTERNAL, tryConvertToPromise, apiRejection) {
            var util = require("./util");

            var raceLater = function (promise) {
                return promise.then(function(array) {
                    return race(array, promise);
                });
            };

            function race(promises, parent) {
                var maybePromise = tryConvertToPromise(promises);

                if (maybePromise instanceof Promise) {
                    return raceLater(maybePromise);
                } else {
                    promises = util.asArray(promises);
                    if (promises === null)
                        return apiRejection("expecting an array or an iterable object but got " + util.classString(promises));
                }

                var ret = new Promise(INTERNAL);
                if (parent !== undefined) {
                    ret._propagateFrom(parent, 3);
                }
                var fulfill = ret._fulfill;
                var reject = ret._reject;
                for (var i = 0, len = promises.length; i < len; ++i) {
                    var val = promises[i];

                    if (val === undefined && !(i in promises)) {
                        continue;
                    }

                    Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
                }
                return ret;
            }

            Promise.race = function (promises) {
                return race(promises, undefined);
            };

            Promise.prototype.race = function () {
                return race(this, undefined);
            };

        };

    },{"./util":75}],67:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise,
                                  PromiseArray,
                                  apiRejection,
                                  tryConvertToPromise,
                                  INTERNAL,
                                  debug) {
            var getDomain = Promise._getDomain;
            var util = require("./util");
            var tryCatch = util.tryCatch;

            function ReductionPromiseArray(promises, fn, initialValue, _each) {
                this.constructor$(promises);
                var domain = getDomain();
                this._fn = domain === null ? fn : util.domainBind(domain, fn);
                if (initialValue !== undefined) {
                    initialValue = Promise.resolve(initialValue);
                    initialValue._attachCancellationCallback(this);
                }
                this._initialValue = initialValue;
                this._currentCancellable = null;
                if(_each === INTERNAL) {
                    this._eachValues = Array(this._length);
                } else if (_each === 0) {
                    this._eachValues = null;
                } else {
                    this._eachValues = undefined;
                }
                this._promise._captureStackTrace();
                this._init$(undefined, -5);
            }
            util.inherits(ReductionPromiseArray, PromiseArray);

            ReductionPromiseArray.prototype._gotAccum = function(accum) {
                if (this._eachValues !== undefined &&
                    this._eachValues !== null &&
                    accum !== INTERNAL) {
                    this._eachValues.push(accum);
                }
            };

            ReductionPromiseArray.prototype._eachComplete = function(value) {
                if (this._eachValues !== null) {
                    this._eachValues.push(value);
                }
                return this._eachValues;
            };

            ReductionPromiseArray.prototype._init = function() {};

            ReductionPromiseArray.prototype._resolveEmptyArray = function() {
                this._resolve(this._eachValues !== undefined ? this._eachValues
                    : this._initialValue);
            };

            ReductionPromiseArray.prototype.shouldCopyValues = function () {
                return false;
            };

            ReductionPromiseArray.prototype._resolve = function(value) {
                this._promise._resolveCallback(value);
                this._values = null;
            };

            ReductionPromiseArray.prototype._resultCancelled = function(sender) {
                if (sender === this._initialValue) return this._cancel();
                if (this._isResolved()) return;
                this._resultCancelled$();
                if (this._currentCancellable instanceof Promise) {
                    this._currentCancellable.cancel();
                }
                if (this._initialValue instanceof Promise) {
                    this._initialValue.cancel();
                }
            };

            ReductionPromiseArray.prototype._iterate = function (values) {
                this._values = values;
                var value;
                var i;
                var length = values.length;
                if (this._initialValue !== undefined) {
                    value = this._initialValue;
                    i = 0;
                } else {
                    value = Promise.resolve(values[0]);
                    i = 1;
                }

                this._currentCancellable = value;

                if (!value.isRejected()) {
                    for (; i < length; ++i) {
                        var ctx = {
                            accum: null,
                            value: values[i],
                            index: i,
                            length: length,
                            array: this
                        };
                        value = value._then(gotAccum, undefined, undefined, ctx, undefined);
                    }
                }

                if (this._eachValues !== undefined) {
                    value = value
                        ._then(this._eachComplete, undefined, undefined, this, undefined);
                }
                value._then(completed, completed, undefined, value, this);
            };

            Promise.prototype.reduce = function (fn, initialValue) {
                return reduce(this, fn, initialValue, null);
            };

            Promise.reduce = function (promises, fn, initialValue, _each) {
                return reduce(promises, fn, initialValue, _each);
            };

            function completed(valueOrReason, array) {
                if (this.isFulfilled()) {
                    array._resolve(valueOrReason);
                } else {
                    array._reject(valueOrReason);
                }
            }

            function reduce(promises, fn, initialValue, _each) {
                if (typeof fn !== "function") {
                    return apiRejection("expecting a function but got " + util.classString(fn));
                }
                var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
                return array.promise();
            }

            function gotAccum(accum) {
                this.accum = accum;
                this.array._gotAccum(accum);
                var value = tryConvertToPromise(this.value, this.array._promise);
                if (value instanceof Promise) {
                    this.array._currentCancellable = value;
                    return value._then(gotValue, undefined, undefined, this, undefined);
                } else {
                    return gotValue.call(this, value);
                }
            }

            function gotValue(value) {
                var array = this.array;
                var promise = array._promise;
                var fn = tryCatch(array._fn);
                promise._pushContext();
                var ret;
                if (array._eachValues !== undefined) {
                    ret = fn.call(promise._boundValue(), value, this.index, this.length);
                } else {
                    ret = fn.call(promise._boundValue(),
                        this.accum, value, this.index, this.length);
                }
                if (ret instanceof Promise) {
                    array._currentCancellable = ret;
                }
                var promiseCreated = promise._popContext();
                debug.checkForgottenReturns(
                    ret,
                    promiseCreated,
                    array._eachValues !== undefined ? "Promise.each" : "Promise.reduce",
                    promise
                );
                return ret;
            }
        };

    },{"./util":75}],68:[function(require,module,exports){
        (function (process,global,setImmediate){(function (){
            "use strict";
            var util = require("./util");
            var schedule;
            var noAsyncScheduler = function() {
                throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
            };
            var NativePromise = util.getNativePromise();
            if (util.isNode && typeof MutationObserver === "undefined") {
                var GlobalSetImmediate = global.setImmediate;
                var ProcessNextTick = process.nextTick;
                schedule = util.isRecentNode
                    ? function(fn) { GlobalSetImmediate.call(global, fn); }
                    : function(fn) { ProcessNextTick.call(process, fn); };
            } else if (typeof NativePromise === "function" &&
                typeof NativePromise.resolve === "function") {
                var nativePromise = NativePromise.resolve();
                schedule = function(fn) {
                    nativePromise.then(fn);
                };
            } else if ((typeof MutationObserver !== "undefined") &&
                !(typeof window !== "undefined" &&
                    window.navigator &&
                    (window.navigator.standalone || window.cordova))) {
                schedule = (function() {
                    var div = document.createElement("div");
                    var opts = {attributes: true};
                    var toggleScheduled = false;
                    var div2 = document.createElement("div");
                    var o2 = new MutationObserver(function() {
                        div.classList.toggle("foo");
                        toggleScheduled = false;
                    });
                    o2.observe(div2, opts);

                    var scheduleToggle = function() {
                        if (toggleScheduled) return;
                        toggleScheduled = true;
                        div2.classList.toggle("foo");
                    };

                    return function schedule(fn) {
                        var o = new MutationObserver(function() {
                            o.disconnect();
                            fn();
                        });
                        o.observe(div, opts);
                        scheduleToggle();
                    };
                })();
            } else if (typeof setImmediate !== "undefined") {
                schedule = function (fn) {
                    setImmediate(fn);
                };
            } else if (typeof setTimeout !== "undefined") {
                schedule = function (fn) {
                    setTimeout(fn, 0);
                };
            } else {
                schedule = noAsyncScheduler;
            }
            module.exports = schedule;

        }).call(this)}).call(this,require('_process'),typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
    },{"./util":75,"_process":102,"timers":121}],69:[function(require,module,exports){
        "use strict";
        module.exports =
            function(Promise, PromiseArray, debug) {
                var PromiseInspection = Promise.PromiseInspection;
                var util = require("./util");

                function SettledPromiseArray(values) {
                    this.constructor$(values);
                }
                util.inherits(SettledPromiseArray, PromiseArray);

                SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
                    this._values[index] = inspection;
                    var totalResolved = ++this._totalResolved;
                    if (totalResolved >= this._length) {
                        this._resolve(this._values);
                        return true;
                    }
                    return false;
                };

                SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
                    var ret = new PromiseInspection();
                    ret._bitField = 33554432;
                    ret._settledValueField = value;
                    return this._promiseResolved(index, ret);
                };
                SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
                    var ret = new PromiseInspection();
                    ret._bitField = 16777216;
                    ret._settledValueField = reason;
                    return this._promiseResolved(index, ret);
                };

                Promise.settle = function (promises) {
                    debug.deprecated(".settle()", ".reflect()");
                    return new SettledPromiseArray(promises).promise();
                };

                Promise.prototype.settle = function () {
                    return Promise.settle(this);
                };
            };

    },{"./util":75}],70:[function(require,module,exports){
        "use strict";
        module.exports =
            function(Promise, PromiseArray, apiRejection) {
                var util = require("./util");
                var RangeError = require("./errors").RangeError;
                var AggregateError = require("./errors").AggregateError;
                var isArray = util.isArray;
                var CANCELLATION = {};


                function SomePromiseArray(values) {
                    this.constructor$(values);
                    this._howMany = 0;
                    this._unwrap = false;
                    this._initialized = false;
                }
                util.inherits(SomePromiseArray, PromiseArray);

                SomePromiseArray.prototype._init = function () {
                    if (!this._initialized) {
                        return;
                    }
                    if (this._howMany === 0) {
                        this._resolve([]);
                        return;
                    }
                    this._init$(undefined, -5);
                    var isArrayResolved = isArray(this._values);
                    if (!this._isResolved() &&
                        isArrayResolved &&
                        this._howMany > this._canPossiblyFulfill()) {
                        this._reject(this._getRangeError(this.length()));
                    }
                };

                SomePromiseArray.prototype.init = function () {
                    this._initialized = true;
                    this._init();
                };

                SomePromiseArray.prototype.setUnwrap = function () {
                    this._unwrap = true;
                };

                SomePromiseArray.prototype.howMany = function () {
                    return this._howMany;
                };

                SomePromiseArray.prototype.setHowMany = function (count) {
                    this._howMany = count;
                };

                SomePromiseArray.prototype._promiseFulfilled = function (value) {
                    this._addFulfilled(value);
                    if (this._fulfilled() === this.howMany()) {
                        this._values.length = this.howMany();
                        if (this.howMany() === 1 && this._unwrap) {
                            this._resolve(this._values[0]);
                        } else {
                            this._resolve(this._values);
                        }
                        return true;
                    }
                    return false;

                };
                SomePromiseArray.prototype._promiseRejected = function (reason) {
                    this._addRejected(reason);
                    return this._checkOutcome();
                };

                SomePromiseArray.prototype._promiseCancelled = function () {
                    if (this._values instanceof Promise || this._values == null) {
                        return this._cancel();
                    }
                    this._addRejected(CANCELLATION);
                    return this._checkOutcome();
                };

                SomePromiseArray.prototype._checkOutcome = function() {
                    if (this.howMany() > this._canPossiblyFulfill()) {
                        var e = new AggregateError();
                        for (var i = this.length(); i < this._values.length; ++i) {
                            if (this._values[i] !== CANCELLATION) {
                                e.push(this._values[i]);
                            }
                        }
                        if (e.length > 0) {
                            this._reject(e);
                        } else {
                            this._cancel();
                        }
                        return true;
                    }
                    return false;
                };

                SomePromiseArray.prototype._fulfilled = function () {
                    return this._totalResolved;
                };

                SomePromiseArray.prototype._rejected = function () {
                    return this._values.length - this.length();
                };

                SomePromiseArray.prototype._addRejected = function (reason) {
                    this._values.push(reason);
                };

                SomePromiseArray.prototype._addFulfilled = function (value) {
                    this._values[this._totalResolved++] = value;
                };

                SomePromiseArray.prototype._canPossiblyFulfill = function () {
                    return this.length() - this._rejected();
                };

                SomePromiseArray.prototype._getRangeError = function (count) {
                    var message = "Input array must contain at least " +
                        this._howMany + " items but contains only " + count + " items";
                    return new RangeError(message);
                };

                SomePromiseArray.prototype._resolveEmptyArray = function () {
                    this._reject(this._getRangeError(0));
                };

                function some(promises, howMany) {
                    if ((howMany | 0) !== howMany || howMany < 0) {
                        return apiRejection("expecting a positive integer\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                    }
                    var ret = new SomePromiseArray(promises);
                    var promise = ret.promise();
                    ret.setHowMany(howMany);
                    ret.init();
                    return promise;
                }

                Promise.some = function (promises, howMany) {
                    return some(promises, howMany);
                };

                Promise.prototype.some = function (howMany) {
                    return some(this, howMany);
                };

                Promise._SomePromiseArray = SomePromiseArray;
            };

    },{"./errors":51,"./util":75}],71:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise) {
            function PromiseInspection(promise) {
                if (promise !== undefined) {
                    promise = promise._target();
                    this._bitField = promise._bitField;
                    this._settledValueField = promise._isFateSealed()
                        ? promise._settledValue() : undefined;
                }
                else {
                    this._bitField = 0;
                    this._settledValueField = undefined;
                }
            }

            PromiseInspection.prototype._settledValue = function() {
                return this._settledValueField;
            };

            var value = PromiseInspection.prototype.value = function () {
                if (!this.isFulfilled()) {
                    throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                }
                return this._settledValue();
            };

            var reason = PromiseInspection.prototype.error =
                PromiseInspection.prototype.reason = function () {
                    if (!this.isRejected()) {
                        throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
                    }
                    return this._settledValue();
                };

            var isFulfilled = PromiseInspection.prototype.isFulfilled = function() {
                return (this._bitField & 33554432) !== 0;
            };

            var isRejected = PromiseInspection.prototype.isRejected = function () {
                return (this._bitField & 16777216) !== 0;
            };

            var isPending = PromiseInspection.prototype.isPending = function () {
                return (this._bitField & 50397184) === 0;
            };

            var isResolved = PromiseInspection.prototype.isResolved = function () {
                return (this._bitField & 50331648) !== 0;
            };

            PromiseInspection.prototype.isCancelled = function() {
                return (this._bitField & 8454144) !== 0;
            };

            Promise.prototype.__isCancelled = function() {
                return (this._bitField & 65536) === 65536;
            };

            Promise.prototype._isCancelled = function() {
                return this._target().__isCancelled();
            };

            Promise.prototype.isCancelled = function() {
                return (this._target()._bitField & 8454144) !== 0;
            };

            Promise.prototype.isPending = function() {
                return isPending.call(this._target());
            };

            Promise.prototype.isRejected = function() {
                return isRejected.call(this._target());
            };

            Promise.prototype.isFulfilled = function() {
                return isFulfilled.call(this._target());
            };

            Promise.prototype.isResolved = function() {
                return isResolved.call(this._target());
            };

            Promise.prototype.value = function() {
                return value.call(this._target());
            };

            Promise.prototype.reason = function() {
                var target = this._target();
                target._unsetRejectionIsUnhandled();
                return reason.call(target);
            };

            Promise.prototype._value = function() {
                return this._settledValue();
            };

            Promise.prototype._reason = function() {
                this._unsetRejectionIsUnhandled();
                return this._settledValue();
            };

            Promise.PromiseInspection = PromiseInspection;
        };

    },{}],72:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL) {
            var util = require("./util");
            var errorObj = util.errorObj;
            var isObject = util.isObject;

            function tryConvertToPromise(obj, context) {
                if (isObject(obj)) {
                    if (obj instanceof Promise) return obj;
                    var then = getThen(obj);
                    if (then === errorObj) {
                        if (context) context._pushContext();
                        var ret = Promise.reject(then.e);
                        if (context) context._popContext();
                        return ret;
                    } else if (typeof then === "function") {
                        if (isAnyBluebirdPromise(obj)) {
                            var ret = new Promise(INTERNAL);
                            obj._then(
                                ret._fulfill,
                                ret._reject,
                                undefined,
                                ret,
                                null
                            );
                            return ret;
                        }
                        return doThenable(obj, then, context);
                    }
                }
                return obj;
            }

            function doGetThen(obj) {
                return obj.then;
            }

            function getThen(obj) {
                try {
                    return doGetThen(obj);
                } catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }

            var hasProp = {}.hasOwnProperty;
            function isAnyBluebirdPromise(obj) {
                try {
                    return hasProp.call(obj, "_promise0");
                } catch (e) {
                    return false;
                }
            }

            function doThenable(x, then, context) {
                var promise = new Promise(INTERNAL);
                var ret = promise;
                if (context) context._pushContext();
                promise._captureStackTrace();
                if (context) context._popContext();
                var synchronous = true;
                var result = util.tryCatch(then).call(x, resolve, reject);
                synchronous = false;

                if (promise && result === errorObj) {
                    promise._rejectCallback(result.e, true, true);
                    promise = null;
                }

                function resolve(value) {
                    if (!promise) return;
                    promise._resolveCallback(value);
                    promise = null;
                }

                function reject(reason) {
                    if (!promise) return;
                    promise._rejectCallback(reason, synchronous, true);
                    promise = null;
                }
                return ret;
            }

            return tryConvertToPromise;
        };

    },{"./util":75}],73:[function(require,module,exports){
        "use strict";
        module.exports = function(Promise, INTERNAL, debug) {
            var util = require("./util");
            var TimeoutError = Promise.TimeoutError;

            function HandleWrapper(handle)  {
                this.handle = handle;
            }

            HandleWrapper.prototype._resultCancelled = function() {
                clearTimeout(this.handle);
            };

            var afterValue = function(value) { return delay(+this).thenReturn(value); };
            var delay = Promise.delay = function (ms, value) {
                var ret;
                var handle;
                if (value !== undefined) {
                    ret = Promise.resolve(value)
                        ._then(afterValue, null, null, ms, undefined);
                    if (debug.cancellation() && value instanceof Promise) {
                        ret._setOnCancel(value);
                    }
                } else {
                    ret = new Promise(INTERNAL);
                    handle = setTimeout(function() { ret._fulfill(); }, +ms);
                    if (debug.cancellation()) {
                        ret._setOnCancel(new HandleWrapper(handle));
                    }
                    ret._captureStackTrace();
                }
                ret._setAsyncGuaranteed();
                return ret;
            };

            Promise.prototype.delay = function (ms) {
                return delay(ms, this);
            };

            var afterTimeout = function (promise, message, parent) {
                var err;
                if (typeof message !== "string") {
                    if (message instanceof Error) {
                        err = message;
                    } else {
                        err = new TimeoutError("operation timed out");
                    }
                } else {
                    err = new TimeoutError(message);
                }
                util.markAsOriginatingFromRejection(err);
                promise._attachExtraTrace(err);
                promise._reject(err);

                if (parent != null) {
                    parent.cancel();
                }
            };

            function successClear(value) {
                clearTimeout(this.handle);
                return value;
            }

            function failureClear(reason) {
                clearTimeout(this.handle);
                throw reason;
            }

            Promise.prototype.timeout = function (ms, message) {
                ms = +ms;
                var ret, parent;

                var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {
                    if (ret.isPending()) {
                        afterTimeout(ret, message, parent);
                    }
                }, ms));

                if (debug.cancellation()) {
                    parent = this.then();
                    ret = parent._then(successClear, failureClear,
                        undefined, handleWrapper, undefined);
                    ret._setOnCancel(handleWrapper);
                } else {
                    ret = this._then(successClear, failureClear,
                        undefined, handleWrapper, undefined);
                }

                return ret;
            };

        };

    },{"./util":75}],74:[function(require,module,exports){
        "use strict";
        module.exports = function (Promise, apiRejection, tryConvertToPromise,
                                   createContext, INTERNAL, debug) {
            var util = require("./util");
            var TypeError = require("./errors").TypeError;
            var inherits = require("./util").inherits;
            var errorObj = util.errorObj;
            var tryCatch = util.tryCatch;
            var NULL = {};

            function thrower(e) {
                setTimeout(function(){throw e;}, 0);
            }

            function castPreservingDisposable(thenable) {
                var maybePromise = tryConvertToPromise(thenable);
                if (maybePromise !== thenable &&
                    typeof thenable._isDisposable === "function" &&
                    typeof thenable._getDisposer === "function" &&
                    thenable._isDisposable()) {
                    maybePromise._setDisposable(thenable._getDisposer());
                }
                return maybePromise;
            }
            function dispose(resources, inspection) {
                var i = 0;
                var len = resources.length;
                var ret = new Promise(INTERNAL);
                function iterator() {
                    if (i >= len) return ret._fulfill();
                    var maybePromise = castPreservingDisposable(resources[i++]);
                    if (maybePromise instanceof Promise &&
                        maybePromise._isDisposable()) {
                        try {
                            maybePromise = tryConvertToPromise(
                                maybePromise._getDisposer().tryDispose(inspection),
                                resources.promise);
                        } catch (e) {
                            return thrower(e);
                        }
                        if (maybePromise instanceof Promise) {
                            return maybePromise._then(iterator, thrower,
                                null, null, null);
                        }
                    }
                    iterator();
                }
                iterator();
                return ret;
            }

            function Disposer(data, promise, context) {
                this._data = data;
                this._promise = promise;
                this._context = context;
            }

            Disposer.prototype.data = function () {
                return this._data;
            };

            Disposer.prototype.promise = function () {
                return this._promise;
            };

            Disposer.prototype.resource = function () {
                if (this.promise().isFulfilled()) {
                    return this.promise().value();
                }
                return NULL;
            };

            Disposer.prototype.tryDispose = function(inspection) {
                var resource = this.resource();
                var context = this._context;
                if (context !== undefined) context._pushContext();
                var ret = resource !== NULL
                    ? this.doDispose(resource, inspection) : null;
                if (context !== undefined) context._popContext();
                this._promise._unsetDisposable();
                this._data = null;
                return ret;
            };

            Disposer.isDisposer = function (d) {
                return (d != null &&
                    typeof d.resource === "function" &&
                    typeof d.tryDispose === "function");
            };

            function FunctionDisposer(fn, promise, context) {
                this.constructor$(fn, promise, context);
            }
            inherits(FunctionDisposer, Disposer);

            FunctionDisposer.prototype.doDispose = function (resource, inspection) {
                var fn = this.data();
                return fn.call(resource, resource, inspection);
            };

            function maybeUnwrapDisposer(value) {
                if (Disposer.isDisposer(value)) {
                    this.resources[this.index]._setDisposable(value);
                    return value.promise();
                }
                return value;
            }

            function ResourceList(length) {
                this.length = length;
                this.promise = null;
                this[length-1] = null;
            }

            ResourceList.prototype._resultCancelled = function() {
                var len = this.length;
                for (var i = 0; i < len; ++i) {
                    var item = this[i];
                    if (item instanceof Promise) {
                        item.cancel();
                    }
                }
            };

            Promise.using = function () {
                var len = arguments.length;
                if (len < 2) return apiRejection(
                    "you must pass at least 2 arguments to Promise.using");
                var fn = arguments[len - 1];
                if (typeof fn !== "function") {
                    return apiRejection("expecting a function but got " + util.classString(fn));
                }
                var input;
                var spreadArgs = true;
                if (len === 2 && Array.isArray(arguments[0])) {
                    input = arguments[0];
                    len = input.length;
                    spreadArgs = false;
                } else {
                    input = arguments;
                    len--;
                }
                var resources = new ResourceList(len);
                for (var i = 0; i < len; ++i) {
                    var resource = input[i];
                    if (Disposer.isDisposer(resource)) {
                        var disposer = resource;
                        resource = resource.promise();
                        resource._setDisposable(disposer);
                    } else {
                        var maybePromise = tryConvertToPromise(resource);
                        if (maybePromise instanceof Promise) {
                            resource =
                                maybePromise._then(maybeUnwrapDisposer, null, null, {
                                    resources: resources,
                                    index: i
                                }, undefined);
                        }
                    }
                    resources[i] = resource;
                }

                var reflectedResources = new Array(resources.length);
                for (var i = 0; i < reflectedResources.length; ++i) {
                    reflectedResources[i] = Promise.resolve(resources[i]).reflect();
                }

                var resultPromise = Promise.all(reflectedResources)
                    .then(function(inspections) {
                        for (var i = 0; i < inspections.length; ++i) {
                            var inspection = inspections[i];
                            if (inspection.isRejected()) {
                                errorObj.e = inspection.error();
                                return errorObj;
                            } else if (!inspection.isFulfilled()) {
                                resultPromise.cancel();
                                return;
                            }
                            inspections[i] = inspection.value();
                        }
                        promise._pushContext();

                        fn = tryCatch(fn);
                        var ret = spreadArgs
                            ? fn.apply(undefined, inspections) : fn(inspections);
                        var promiseCreated = promise._popContext();
                        debug.checkForgottenReturns(
                            ret, promiseCreated, "Promise.using", promise);
                        return ret;
                    });

                var promise = resultPromise.lastly(function() {
                    var inspection = new Promise.PromiseInspection(resultPromise);
                    return dispose(resources, inspection);
                });
                resources.promise = promise;
                promise._setOnCancel(resources);
                return promise;
            };

            Promise.prototype._setDisposable = function (disposer) {
                this._bitField = this._bitField | 131072;
                this._disposer = disposer;
            };

            Promise.prototype._isDisposable = function () {
                return (this._bitField & 131072) > 0;
            };

            Promise.prototype._getDisposer = function () {
                return this._disposer;
            };

            Promise.prototype._unsetDisposable = function () {
                this._bitField = this._bitField & (~131072);
                this._disposer = undefined;
            };

            Promise.prototype.disposer = function (fn) {
                if (typeof fn === "function") {
                    return new FunctionDisposer(fn, this, createContext());
                }
                throw new TypeError();
            };

        };

    },{"./errors":51,"./util":75}],75:[function(require,module,exports){
        (function (process,global){(function (){
            "use strict";
            var es5 = require("./es5");
            var canEvaluate = typeof navigator == "undefined";

            var errorObj = {e: {}};
            var tryCatchTarget;
            var globalObject = typeof self !== "undefined" ? self :
                typeof window !== "undefined" ? window :
                    typeof global !== "undefined" ? global :
                        this !== undefined ? this : null;

            function tryCatcher() {
                try {
                    var target = tryCatchTarget;
                    tryCatchTarget = null;
                    return target.apply(this, arguments);
                } catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }
            function tryCatch(fn) {
                tryCatchTarget = fn;
                return tryCatcher;
            }

            var inherits = function(Child, Parent) {
                var hasProp = {}.hasOwnProperty;

                function T() {
                    this.constructor = Child;
                    this.constructor$ = Parent;
                    for (var propertyName in Parent.prototype) {
                        if (hasProp.call(Parent.prototype, propertyName) &&
                            propertyName.charAt(propertyName.length-1) !== "$"
                        ) {
                            this[propertyName + "$"] = Parent.prototype[propertyName];
                        }
                    }
                }
                T.prototype = Parent.prototype;
                Child.prototype = new T();
                return Child.prototype;
            };


            function isPrimitive(val) {
                return val == null || val === true || val === false ||
                    typeof val === "string" || typeof val === "number";

            }

            function isObject(value) {
                return typeof value === "function" ||
                    typeof value === "object" && value !== null;
            }

            function maybeWrapAsError(maybeError) {
                if (!isPrimitive(maybeError)) return maybeError;

                return new Error(safeToString(maybeError));
            }

            function withAppended(target, appendee) {
                var len = target.length;
                var ret = new Array(len + 1);
                var i;
                for (i = 0; i < len; ++i) {
                    ret[i] = target[i];
                }
                ret[i] = appendee;
                return ret;
            }

            function getDataPropertyOrDefault(obj, key, defaultValue) {
                if (es5.isES5) {
                    var desc = Object.getOwnPropertyDescriptor(obj, key);

                    if (desc != null) {
                        return desc.get == null && desc.set == null
                            ? desc.value
                            : defaultValue;
                    }
                } else {
                    return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
                }
            }

            function notEnumerableProp(obj, name, value) {
                if (isPrimitive(obj)) return obj;
                var descriptor = {
                    value: value,
                    configurable: true,
                    enumerable: false,
                    writable: true
                };
                es5.defineProperty(obj, name, descriptor);
                return obj;
            }

            function thrower(r) {
                throw r;
            }

            var inheritedDataKeys = (function() {
                var excludedPrototypes = [
                    Array.prototype,
                    Object.prototype,
                    Function.prototype
                ];

                var isExcludedProto = function(val) {
                    for (var i = 0; i < excludedPrototypes.length; ++i) {
                        if (excludedPrototypes[i] === val) {
                            return true;
                        }
                    }
                    return false;
                };

                if (es5.isES5) {
                    var getKeys = Object.getOwnPropertyNames;
                    return function(obj) {
                        var ret = [];
                        var visitedKeys = Object.create(null);
                        while (obj != null && !isExcludedProto(obj)) {
                            var keys;
                            try {
                                keys = getKeys(obj);
                            } catch (e) {
                                return ret;
                            }
                            for (var i = 0; i < keys.length; ++i) {
                                var key = keys[i];
                                if (visitedKeys[key]) continue;
                                visitedKeys[key] = true;
                                var desc = Object.getOwnPropertyDescriptor(obj, key);
                                if (desc != null && desc.get == null && desc.set == null) {
                                    ret.push(key);
                                }
                            }
                            obj = es5.getPrototypeOf(obj);
                        }
                        return ret;
                    };
                } else {
                    var hasProp = {}.hasOwnProperty;
                    return function(obj) {
                        if (isExcludedProto(obj)) return [];
                        var ret = [];

                        /*jshint forin:false */
                        enumeration: for (var key in obj) {
                            if (hasProp.call(obj, key)) {
                                ret.push(key);
                            } else {
                                for (var i = 0; i < excludedPrototypes.length; ++i) {
                                    if (hasProp.call(excludedPrototypes[i], key)) {
                                        continue enumeration;
                                    }
                                }
                                ret.push(key);
                            }
                        }
                        return ret;
                    };
                }

            })();

            var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
            function isClass(fn) {
                try {
                    if (typeof fn === "function") {
                        var keys = es5.names(fn.prototype);

                        var hasMethods = es5.isES5 && keys.length > 1;
                        var hasMethodsOtherThanConstructor = keys.length > 0 &&
                            !(keys.length === 1 && keys[0] === "constructor");
                        var hasThisAssignmentAndStaticMethods =
                            thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;

                        if (hasMethods || hasMethodsOtherThanConstructor ||
                            hasThisAssignmentAndStaticMethods) {
                            return true;
                        }
                    }
                    return false;
                } catch (e) {
                    return false;
                }
            }

            function toFastProperties(obj) {
                /*jshint -W027,-W055,-W031*/
                function FakeConstructor() {}
                FakeConstructor.prototype = obj;
                var l = 8;
                while (l--) new FakeConstructor();
                return obj;
                eval(obj);
            }

            var rident = /^[a-z$_][a-z$_0-9]*$/i;
            function isIdentifier(str) {
                return rident.test(str);
            }

            function filledRange(count, prefix, suffix) {
                var ret = new Array(count);
                for(var i = 0; i < count; ++i) {
                    ret[i] = prefix + i + suffix;
                }
                return ret;
            }

            function safeToString(obj) {
                try {
                    return obj + "";
                } catch (e) {
                    return "[no string representation]";
                }
            }

            function isError(obj) {
                return obj !== null &&
                    typeof obj === "object" &&
                    typeof obj.message === "string" &&
                    typeof obj.name === "string";
            }

            function markAsOriginatingFromRejection(e) {
                try {
                    notEnumerableProp(e, "isOperational", true);
                }
                catch(ignore) {}
            }

            function originatesFromRejection(e) {
                if (e == null) return false;
                return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
                    e["isOperational"] === true);
            }

            function canAttachTrace(obj) {
                return isError(obj) && es5.propertyIsWritable(obj, "stack");
            }

            var ensureErrorObject = (function() {
                if (!("stack" in new Error())) {
                    return function(value) {
                        if (canAttachTrace(value)) return value;
                        try {throw new Error(safeToString(value));}
                        catch(err) {return err;}
                    };
                } else {
                    return function(value) {
                        if (canAttachTrace(value)) return value;
                        return new Error(safeToString(value));
                    };
                }
            })();

            function classString(obj) {
                return {}.toString.call(obj);
            }

            function copyDescriptors(from, to, filter) {
                var keys = es5.names(from);
                for (var i = 0; i < keys.length; ++i) {
                    var key = keys[i];
                    if (filter(key)) {
                        try {
                            es5.defineProperty(to, key, es5.getDescriptor(from, key));
                        } catch (ignore) {}
                    }
                }
            }

            var asArray = function(v) {
                if (es5.isArray(v)) {
                    return v;
                }
                return null;
            };

            if (typeof Symbol !== "undefined" && Symbol.iterator) {
                var ArrayFrom = typeof Array.from === "function" ? function(v) {
                    return Array.from(v);
                } : function(v) {
                    var ret = [];
                    var it = v[Symbol.iterator]();
                    var itResult;
                    while (!((itResult = it.next()).done)) {
                        ret.push(itResult.value);
                    }
                    return ret;
                };

                asArray = function(v) {
                    if (es5.isArray(v)) {
                        return v;
                    } else if (v != null && typeof v[Symbol.iterator] === "function") {
                        return ArrayFrom(v);
                    }
                    return null;
                };
            }

            var isNode = typeof process !== "undefined" &&
                classString(process).toLowerCase() === "[object process]";

            var hasEnvVariables = typeof process !== "undefined" &&
                typeof process.env !== "undefined";

            function env(key) {
                return hasEnvVariables ? process.env[key] : undefined;
            }

            function getNativePromise() {
                if (typeof Promise === "function") {
                    try {
                        var promise = new Promise(function(){});
                        if ({}.toString.call(promise) === "[object Promise]") {
                            return Promise;
                        }
                    } catch (e) {}
                }
            }

            function domainBind(self, cb) {
                return self.bind(cb);
            }

            var ret = {
                isClass: isClass,
                isIdentifier: isIdentifier,
                inheritedDataKeys: inheritedDataKeys,
                getDataPropertyOrDefault: getDataPropertyOrDefault,
                thrower: thrower,
                isArray: es5.isArray,
                asArray: asArray,
                notEnumerableProp: notEnumerableProp,
                isPrimitive: isPrimitive,
                isObject: isObject,
                isError: isError,
                canEvaluate: canEvaluate,
                errorObj: errorObj,
                tryCatch: tryCatch,
                inherits: inherits,
                withAppended: withAppended,
                maybeWrapAsError: maybeWrapAsError,
                toFastProperties: toFastProperties,
                filledRange: filledRange,
                toString: safeToString,
                canAttachTrace: canAttachTrace,
                ensureErrorObject: ensureErrorObject,
                originatesFromRejection: originatesFromRejection,
                markAsOriginatingFromRejection: markAsOriginatingFromRejection,
                classString: classString,
                copyDescriptors: copyDescriptors,
                hasDevTools: typeof chrome !== "undefined" && chrome &&
                    typeof chrome.loadTimes === "function",
                isNode: isNode,
                hasEnvVariables: hasEnvVariables,
                env: env,
                global: globalObject,
                getNativePromise: getNativePromise,
                domainBind: domainBind
            };
            ret.isRecentNode = ret.isNode && (function() {
                var version = process.versions.node.split(".").map(Number);
                return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
            })();

            if (ret.isNode) ret.toFastProperties(process);

            try {throw new Error(); } catch (e) {ret.lastLineError = e;}
            module.exports = ret;

        }).call(this)}).call(this,require('_process'),typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./es5":52,"_process":102}],76:[function(require,module,exports){

    },{}],77:[function(require,module,exports){
        (function (global,Buffer){(function (){
            /*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <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

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

            /*
 * Export kMaxLength after typed array support is determined.
 */
            exports.kMaxLength = kMaxLength()

            function typedArraySupport () {
                try {
                    var arr = new Uint8Array(1)
                    arr.__proto__ = {__proto__: Uint8Array.prototype, 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
            }

            function createBuffer (that, length) {
                if (kMaxLength() < length) {
                    throw new RangeError('Invalid typed array 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
                    if (that === null) {
                        that = new Buffer(length)
                    }
                    that.length = length
                }

                return that
            }

            /**
             * 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, encodingOrOffset, length) {
                if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
                    return new Buffer(arg, encodingOrOffset, length)
                }

                // Common case.
                if (typeof arg === 'number') {
                    if (typeof encodingOrOffset === 'string') {
                        throw new Error(
                            'If encoding is specified then the first argument must be a string'
                        )
                    }
                    return allocUnsafe(this, arg)
                }
                return from(this, arg, encodingOrOffset, length)
            }

            Buffer.poolSize = 8192 // not used by this implementation

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

            function from (that, value, encodingOrOffset, length) {
                if (typeof value === 'number') {
                    throw new TypeError('"value" argument must not be a number')
                }

                if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
                    return fromArrayBuffer(that, value, encodingOrOffset, length)
                }

                if (typeof value === 'string') {
                    return fromString(that, value, encodingOrOffset)
                }

                return fromObject(that, value)
            }

            /**
             * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
             * if value is a number.
             * Buffer.from(str[, encoding])
             * Buffer.from(array)
             * Buffer.from(buffer)
             * Buffer.from(arrayBuffer[, byteOffset[, length]])
             **/
            Buffer.from = function (value, encodingOrOffset, length) {
                return from(null, value, encodingOrOffset, length)
            }

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

            function assertSize (size) {
                if (typeof size !== 'number') {
                    throw new TypeError('"size" argument must be a number')
                } else if (size < 0) {
                    throw new RangeError('"size" argument must not be negative')
                }
            }

            function alloc (that, size, fill, encoding) {
                assertSize(size)
                if (size <= 0) {
                    return createBuffer(that, size)
                }
                if (fill !== undefined) {
                    // Only pay attention to encoding if it's a string. This
                    // prevents accidentally sending in a number that would
                    // be interpretted as a start offset.
                    return typeof encoding === 'string'
                        ? createBuffer(that, size).fill(fill, encoding)
                        : createBuffer(that, size).fill(fill)
                }
                return createBuffer(that, size)
            }

            /**
             * Creates a new filled Buffer instance.
             * alloc(size[, fill[, encoding]])
             **/
            Buffer.alloc = function (size, fill, encoding) {
                return alloc(null, size, fill, encoding)
            }

            function allocUnsafe (that, size) {
                assertSize(size)
                that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
                if (!Buffer.TYPED_ARRAY_SUPPORT) {
                    for (var i = 0; i < size; ++i) {
                        that[i] = 0
                    }
                }
                return that
            }

            /**
             * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
             * */
            Buffer.allocUnsafe = function (size) {
                return allocUnsafe(null, size)
            }
            /**
             * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
             */
            Buffer.allocUnsafeSlow = function (size) {
                return allocUnsafe(null, size)
            }

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

                if (!Buffer.isEncoding(encoding)) {
                    throw new TypeError('"encoding" must be a valid string encoding')
                }

                var length = byteLength(string, encoding) | 0
                that = createBuffer(that, length)

                var actual = that.write(string, encoding)

                if (actual !== length) {
                    // Writing a hex string, for example, that contains invalid characters will
                    // cause everything after the first invalid character to be ignored. (e.g.
                    // 'abxxcd' will be treated as 'ab')
                    that = that.slice(0, actual)
                }

                return that
            }

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

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

                if (byteOffset < 0 || array.byteLength < byteOffset) {
                    throw new RangeError('\'offset\' is out of bounds')
                }

                if (array.byteLength < byteOffset + (length || 0)) {
                    throw new RangeError('\'length\' is out of bounds')
                }

                if (byteOffset === undefined && length === undefined) {
                    array = new Uint8Array(array)
                } else if (length === undefined) {
                    array = new Uint8Array(array, byteOffset)
                } else {
                    array = new Uint8Array(array, byteOffset, length)
                }

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

            function fromObject (that, obj) {
                if (Buffer.isBuffer(obj)) {
                    var len = checked(obj.length) | 0
                    that = createBuffer(that, len)

                    if (that.length === 0) {
                        return that
                    }

                    obj.copy(that, 0, 0, len)
                    return that
                }

                if (obj) {
                    if ((typeof ArrayBuffer !== 'undefined' &&
                        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
                        if (typeof obj.length !== 'number' || isnan(obj.length)) {
                            return createBuffer(that, 0)
                        }
                        return fromArrayLike(that, obj)
                    }

                    if (obj.type === 'Buffer' && isArray(obj.data)) {
                        return fromArrayLike(that, obj.data)
                    }
                }

                throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
            }

            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 (length) {
                if (+length != length) { // eslint-disable-line eqeqeq
                    length = 0
                }
                return Buffer.alloc(+length)
            }

            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 'latin1':
                    case 'binary':
                    case 'base64':
                    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 Buffer.alloc(0)
                }

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

                var buffer = Buffer.allocUnsafe(length)
                var pos = 0
                for (i = 0; i < list.length; ++i) {
                    var buf = list[i]
                    if (!Buffer.isBuffer(buf)) {
                        throw new TypeError('"list" argument must be an Array of Buffers')
                    }
                    buf.copy(buffer, pos)
                    pos += buf.length
                }
                return buffer
            }

            function byteLength (string, encoding) {
                if (Buffer.isBuffer(string)) {
                    return string.length
                }
                if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
                    (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
                    return string.byteLength
                }
                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 'latin1':
                        case 'binary':
                            return len
                        case 'utf8':
                        case 'utf-8':
                        case undefined:
                            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

                // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
                // property of a typed array.

                // This behaves neither like String nor Uint8Array in that we set start/end
                // to their upper/lower bounds if the value passed is out of range.
                // undefined is handled specially as per ECMA-262 6th Edition,
                // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
                if (start === undefined || start < 0) {
                    start = 0
                }
                // Return early if start > this.length. Done here to prevent potential uint32
                // coercion fail below.
                if (start > this.length) {
                    return ''
                }

                if (end === undefined || end > this.length) {
                    end = this.length
                }

                if (end <= 0) {
                    return ''
                }

                // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
                end >>>= 0
                start >>>= 0

                if (end <= start) {
                    return ''
                }

                if (!encoding) encoding = 'utf8'

                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 'latin1':
                        case 'binary':
                            return latin1Slice(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

            function swap (b, n, m) {
                var i = b[n]
                b[n] = b[m]
                b[m] = i
            }

            Buffer.prototype.swap16 = function swap16 () {
                var len = this.length
                if (len % 2 !== 0) {
                    throw new RangeError('Buffer size must be a multiple of 16-bits')
                }
                for (var i = 0; i < len; i += 2) {
                    swap(this, i, i + 1)
                }
                return this
            }

            Buffer.prototype.swap32 = function swap32 () {
                var len = this.length
                if (len % 4 !== 0) {
                    throw new RangeError('Buffer size must be a multiple of 32-bits')
                }
                for (var i = 0; i < len; i += 4) {
                    swap(this, i, i + 3)
                    swap(this, i + 1, i + 2)
                }
                return this
            }

            Buffer.prototype.swap64 = function swap64 () {
                var len = this.length
                if (len % 8 !== 0) {
                    throw new RangeError('Buffer size must be a multiple of 64-bits')
                }
                for (var i = 0; i < len; i += 8) {
                    swap(this, i, i + 7)
                    swap(this, i + 1, i + 6)
                    swap(this, i + 2, i + 5)
                    swap(this, i + 3, i + 4)
                }
                return this
            }

            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 (target, start, end, thisStart, thisEnd) {
                if (!Buffer.isBuffer(target)) {
                    throw new TypeError('Argument must be a Buffer')
                }

                if (start === undefined) {
                    start = 0
                }
                if (end === undefined) {
                    end = target ? target.length : 0
                }
                if (thisStart === undefined) {
                    thisStart = 0
                }
                if (thisEnd === undefined) {
                    thisEnd = this.length
                }

                if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
                    throw new RangeError('out of range index')
                }

                if (thisStart >= thisEnd && start >= end) {
                    return 0
                }
                if (thisStart >= thisEnd) {
                    return -1
                }
                if (start >= end) {
                    return 1
                }

                start >>>= 0
                end >>>= 0
                thisStart >>>= 0
                thisEnd >>>= 0

                if (this === target) return 0

                var x = thisEnd - thisStart
                var y = end - start
                var len = Math.min(x, y)

                var thisCopy = this.slice(thisStart, thisEnd)
                var targetCopy = target.slice(start, end)

                for (var i = 0; i < len; ++i) {
                    if (thisCopy[i] !== targetCopy[i]) {
                        x = thisCopy[i]
                        y = targetCopy[i]
                        break
                    }
                }

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

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
            function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
                // Empty buffer means no match
                if (buffer.length === 0) return -1

                // Normalize byteOffset
                if (typeof byteOffset === 'string') {
                    encoding = byteOffset
                    byteOffset = 0
                } else if (byteOffset > 0x7fffffff) {
                    byteOffset = 0x7fffffff
                } else if (byteOffset < -0x80000000) {
                    byteOffset = -0x80000000
                }
                byteOffset = +byteOffset  // Coerce to Number.
                if (isNaN(byteOffset)) {
                    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
                    byteOffset = dir ? 0 : (buffer.length - 1)
                }

                // Normalize byteOffset: negative offsets start from the end of the buffer
                if (byteOffset < 0) byteOffset = buffer.length + byteOffset
                if (byteOffset >= buffer.length) {
                    if (dir) return -1
                    else byteOffset = buffer.length - 1
                } else if (byteOffset < 0) {
                    if (dir) byteOffset = 0
                    else return -1
                }

                // Normalize val
                if (typeof val === 'string') {
                    val = Buffer.from(val, encoding)
                }

                // Finally, search either indexOf (if dir is true) or lastIndexOf
                if (Buffer.isBuffer(val)) {
                    // Special case: looking for empty string/buffer always fails
                    if (val.length === 0) {
                        return -1
                    }
                    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
                } else if (typeof val === 'number') {
                    val = val & 0xFF // Search for a byte value [0-255]
                    if (Buffer.TYPED_ARRAY_SUPPORT &&
                        typeof Uint8Array.prototype.indexOf === 'function') {
                        if (dir) {
                            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
                        } else {
                            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
                        }
                    }
                    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
                }

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

            function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
                var indexSize = 1
                var arrLength = arr.length
                var valLength = val.length

                if (encoding !== undefined) {
                    encoding = String(encoding).toLowerCase()
                    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
                        encoding === 'utf16le' || encoding === 'utf-16le') {
                        if (arr.length < 2 || val.length < 2) {
                            return -1
                        }
                        indexSize = 2
                        arrLength /= 2
                        valLength /= 2
                        byteOffset /= 2
                    }
                }

                function read (buf, i) {
                    if (indexSize === 1) {
                        return buf[i]
                    } else {
                        return buf.readUInt16BE(i * indexSize)
                    }
                }

                var i
                if (dir) {
                    var foundIndex = -1
                    for (i = byteOffset; i < arrLength; i++) {
                        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
                            if (foundIndex === -1) foundIndex = i
                            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
                        } else {
                            if (foundIndex !== -1) i -= i - foundIndex
                            foundIndex = -1
                        }
                    }
                } else {
                    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
                    for (i = byteOffset; i >= 0; i--) {
                        var found = true
                        for (var j = 0; j < valLength; j++) {
                            if (read(arr, i + j) !== read(val, j)) {
                                found = false
                                break
                            }
                        }
                        if (found) return i
                    }
                }

                return -1
            }

            Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
                return this.indexOf(val, byteOffset, encoding) !== -1
            }

            Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
                return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
            }

            Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
                return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
            }

            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 TypeError('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)) return i
                    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 latin1Write (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 {
                    throw new Error(
                        'Buffer.write(string, encoding, offset[, length]) is no longer supported'
                    )
                }

                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 'latin1':
                        case 'binary':
                            return latin1Write(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 latin1Slice (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]
                    }
                }

                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" argument must be a Buffer instance')
                if (value > max || value < min) throw new RangeError('"value" argument 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) {
                    var maxBytes = Math.pow(2, 8 * byteLength) - 1
                    checkInt(this, value, offset, byteLength, maxBytes, 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) {
                    var maxBytes = Math.pow(2, 8 * byteLength) - 1
                    checkInt(this, value, offset, byteLength, maxBytes, 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 = 0
                this[offset] = value & 0xFF
                while (++i < byteLength && (mul *= 0x100)) {
                    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
                        sub = 1
                    }
                    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 = 0
                this[offset + i] = value & 0xFF
                while (--i >= 0 && (mul *= 0x100)) {
                    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
                        sub = 1
                    }
                    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
            }

// Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
            Buffer.prototype.fill = function fill (val, start, end, encoding) {
                // Handle string cases:
                if (typeof val === 'string') {
                    if (typeof start === 'string') {
                        encoding = start
                        start = 0
                        end = this.length
                    } else if (typeof end === 'string') {
                        encoding = end
                        end = this.length
                    }
                    if (val.length === 1) {
                        var code = val.charCodeAt(0)
                        if (code < 256) {
                            val = code
                        }
                    }
                    if (encoding !== undefined && typeof encoding !== 'string') {
                        throw new TypeError('encoding must be a string')
                    }
                    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
                        throw new TypeError('Unknown encoding: ' + encoding)
                    }
                } else if (typeof val === 'number') {
                    val = val & 255
                }

                // Invalid ranges are not set to a default, so can range check early.
                if (start < 0 || this.length < start || this.length < end) {
                    throw new RangeError('Out of range index')
                }

                if (end <= start) {
                    return this
                }

                start = start >>> 0
                end = end === undefined ? this.length : end >>> 0

                if (!val) val = 0

                var i
                if (typeof val === 'number') {
                    for (i = start; i < end; ++i) {
                        this[i] = val
                    }
                } else {
                    var bytes = Buffer.isBuffer(val)
                        ? val
                        : utf8ToBytes(new Buffer(val, encoding).toString())
                    var len = bytes.length
                    for (i = 0; i < end - start; ++i) {
                        this[i + start] = 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
            }

            function isnan (val) {
                return val !== val // eslint-disable-line no-self-compare
            }

        }).call(this)}).call(this,typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
    },{"base64-js":40,"buffer":77,"ieee754":82,"isarray":85}],78:[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.

// 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 = require('buffer').Buffer.isBuffer;

        function objectToString(o) {
            return Object.prototype.toString.call(o);
        }

    },{"buffer":77}],79:[function(require,module,exports){
        "use strict";
        Object.defineProperty(exports, "__esModule", { value: true });
        var dingbats = [
            { "Typeface name": "Symbol", "Dingbat dec": "32", "Dingbat hex": "20", "Unicode dec": "32", "Unicode hex": "20" },
            { "Typeface name": "Symbol", "Dingbat dec": "33", "Dingbat hex": "21", "Unicode dec": "33", "Unicode hex": "21" },
            { "Typeface name": "Symbol", "Dingbat dec": "34", "Dingbat hex": "22", "Unicode dec": "8704", "Unicode hex": "2200" },
            { "Typeface name": "Symbol", "Dingbat dec": "35", "Dingbat hex": "23", "Unicode dec": "35", "Unicode hex": "23" },
            { "Typeface name": "Symbol", "Dingbat dec": "36", "Dingbat hex": "24", "Unicode dec": "8707", "Unicode hex": "2203" },
            { "Typeface name": "Symbol", "Dingbat dec": "37", "Dingbat hex": "25", "Unicode dec": "37", "Unicode hex": "25" },
            { "Typeface name": "Symbol", "Dingbat dec": "38", "Dingbat hex": "26", "Unicode dec": "38", "Unicode hex": "26" },
            { "Typeface name": "Symbol", "Dingbat dec": "39", "Dingbat hex": "27", "Unicode dec": "8717", "Unicode hex": "220D" },
            { "Typeface name": "Symbol", "Dingbat dec": "40", "Dingbat hex": "28", "Unicode dec": "40", "Unicode hex": "28" },
            { "Typeface name": "Symbol", "Dingbat dec": "41", "Dingbat hex": "29", "Unicode dec": "41", "Unicode hex": "29" },
            { "Typeface name": "Symbol", "Dingbat dec": "42", "Dingbat hex": "2A", "Unicode dec": "42", "Unicode hex": "2A" },
            { "Typeface name": "Symbol", "Dingbat dec": "43", "Dingbat hex": "2B", "Unicode dec": "43", "Unicode hex": "2B" },
            { "Typeface name": "Symbol", "Dingbat dec": "44", "Dingbat hex": "2C", "Unicode dec": "44", "Unicode hex": "2C" },
            { "Typeface name": "Symbol", "Dingbat dec": "45", "Dingbat hex": "2D", "Unicode dec": "8722", "Unicode hex": "2212" },
            { "Typeface name": "Symbol", "Dingbat dec": "46", "Dingbat hex": "2E", "Unicode dec": "46", "Unicode hex": "2E" },
            { "Typeface name": "Symbol", "Dingbat dec": "47", "Dingbat hex": "2F", "Unicode dec": "47", "Unicode hex": "2F" },
            { "Typeface name": "Symbol", "Dingbat dec": "48", "Dingbat hex": "30", "Unicode dec": "48", "Unicode hex": "30" },
            { "Typeface name": "Symbol", "Dingbat dec": "49", "Dingbat hex": "31", "Unicode dec": "49", "Unicode hex": "31" },
            { "Typeface name": "Symbol", "Dingbat dec": "50", "Dingbat hex": "32", "Unicode dec": "50", "Unicode hex": "32" },
            { "Typeface name": "Symbol", "Dingbat dec": "51", "Dingbat hex": "33", "Unicode dec": "51", "Unicode hex": "33" },
            { "Typeface name": "Symbol", "Dingbat dec": "52", "Dingbat hex": "34", "Unicode dec": "52", "Unicode hex": "34" },
            { "Typeface name": "Symbol", "Dingbat dec": "53", "Dingbat hex": "35", "Unicode dec": "53", "Unicode hex": "35" },
            { "Typeface name": "Symbol", "Dingbat dec": "54", "Dingbat hex": "36", "Unicode dec": "54", "Unicode hex": "36" },
            { "Typeface name": "Symbol", "Dingbat dec": "55", "Dingbat hex": "37", "Unicode dec": "55", "Unicode hex": "37" },
            { "Typeface name": "Symbol", "Dingbat dec": "56", "Dingbat hex": "38", "Unicode dec": "56", "Unicode hex": "38" },
            { "Typeface name": "Symbol", "Dingbat dec": "57", "Dingbat hex": "39", "Unicode dec": "57", "Unicode hex": "39" },
            { "Typeface name": "Symbol", "Dingbat dec": "58", "Dingbat hex": "3A", "Unicode dec": "58", "Unicode hex": "3A" },
            { "Typeface name": "Symbol", "Dingbat dec": "59", "Dingbat hex": "3B", "Unicode dec": "59", "Unicode hex": "3B" },
            { "Typeface name": "Symbol", "Dingbat dec": "60", "Dingbat hex": "3C", "Unicode dec": "60", "Unicode hex": "3C" },
            { "Typeface name": "Symbol", "Dingbat dec": "61", "Dingbat hex": "3D", "Unicode dec": "61", "Unicode hex": "3D" },
            { "Typeface name": "Symbol", "Dingbat dec": "62", "Dingbat hex": "3E", "Unicode dec": "62", "Unicode hex": "3E" },
            { "Typeface name": "Symbol", "Dingbat dec": "63", "Dingbat hex": "3F", "Unicode dec": "63", "Unicode hex": "3F" },
            { "Typeface name": "Symbol", "Dingbat dec": "64", "Dingbat hex": "40", "Unicode dec": "8773", "Unicode hex": "2245" },
            { "Typeface name": "Symbol", "Dingbat dec": "65", "Dingbat hex": "41", "Unicode dec": "913", "Unicode hex": "391" },
            { "Typeface name": "Symbol", "Dingbat dec": "66", "Dingbat hex": "42", "Unicode dec": "914", "Unicode hex": "392" },
            { "Typeface name": "Symbol", "Dingbat dec": "67", "Dingbat hex": "43", "Unicode dec": "935", "Unicode hex": "3A7" },
            { "Typeface name": "Symbol", "Dingbat dec": "68", "Dingbat hex": "44", "Unicode dec": "916", "Unicode hex": "394" },
            { "Typeface name": "Symbol", "Dingbat dec": "69", "Dingbat hex": "45", "Unicode dec": "917", "Unicode hex": "395" },
            { "Typeface name": "Symbol", "Dingbat dec": "70", "Dingbat hex": "46", "Unicode dec": "934", "Unicode hex": "3A6" },
            { "Typeface name": "Symbol", "Dingbat dec": "71", "Dingbat hex": "47", "Unicode dec": "915", "Unicode hex": "393" },
            { "Typeface name": "Symbol", "Dingbat dec": "72", "Dingbat hex": "48", "Unicode dec": "919", "Unicode hex": "397" },
            { "Typeface name": "Symbol", "Dingbat dec": "73", "Dingbat hex": "49", "Unicode dec": "921", "Unicode hex": "399" },
            { "Typeface name": "Symbol", "Dingbat dec": "74", "Dingbat hex": "4A", "Unicode dec": "977", "Unicode hex": "3D1" },
            { "Typeface name": "Symbol", "Dingbat dec": "75", "Dingbat hex": "4B", "Unicode dec": "922", "Unicode hex": "39A" },
            { "Typeface name": "Symbol", "Dingbat dec": "76", "Dingbat hex": "4C", "Unicode dec": "923", "Unicode hex": "39B" },
            { "Typeface name": "Symbol", "Dingbat dec": "77", "Dingbat hex": "4D", "Unicode dec": "924", "Unicode hex": "39C" },
            { "Typeface name": "Symbol", "Dingbat dec": "78", "Dingbat hex": "4E", "Unicode dec": "925", "Unicode hex": "39D" },
            { "Typeface name": "Symbol", "Dingbat dec": "79", "Dingbat hex": "4F", "Unicode dec": "927", "Unicode hex": "39F" },
            { "Typeface name": "Symbol", "Dingbat dec": "80", "Dingbat hex": "50", "Unicode dec": "928", "Unicode hex": "3A0" },
            { "Typeface name": "Symbol", "Dingbat dec": "81", "Dingbat hex": "51", "Unicode dec": "920", "Unicode hex": "398" },
            { "Typeface name": "Symbol", "Dingbat dec": "82", "Dingbat hex": "52", "Unicode dec": "929", "Unicode hex": "3A1" },
            { "Typeface name": "Symbol", "Dingbat dec": "83", "Dingbat hex": "53", "Unicode dec": "931", "Unicode hex": "3A3" },
            { "Typeface name": "Symbol", "Dingbat dec": "84", "Dingbat hex": "54", "Unicode dec": "932", "Unicode hex": "3A4" },
            { "Typeface name": "Symbol", "Dingbat dec": "85", "Dingbat hex": "55", "Unicode dec": "933", "Unicode hex": "3A5" },
            { "Typeface name": "Symbol", "Dingbat dec": "86", "Dingbat hex": "56", "Unicode dec": "962", "Unicode hex": "3C2" },
            { "Typeface name": "Symbol", "Dingbat dec": "87", "Dingbat hex": "57", "Unicode dec": "937", "Unicode hex": "3A9" },
            { "Typeface name": "Symbol", "Dingbat dec": "88", "Dingbat hex": "58", "Unicode dec": "926", "Unicode hex": "39E" },
            { "Typeface name": "Symbol", "Dingbat dec": "89", "Dingbat hex": "59", "Unicode dec": "936", "Unicode hex": "3A8" },
            { "Typeface name": "Symbol", "Dingbat dec": "90", "Dingbat hex": "5A", "Unicode dec": "918", "Unicode hex": "396" },
            { "Typeface name": "Symbol", "Dingbat dec": "91", "Dingbat hex": "5B", "Unicode dec": "91", "Unicode hex": "5B" },
            { "Typeface name": "Symbol", "Dingbat dec": "92", "Dingbat hex": "5C", "Unicode dec": "8756", "Unicode hex": "2234" },
            { "Typeface name": "Symbol", "Dingbat dec": "93", "Dingbat hex": "5D", "Unicode dec": "93", "Unicode hex": "5D" },
            { "Typeface name": "Symbol", "Dingbat dec": "94", "Dingbat hex": "5E", "Unicode dec": "8869", "Unicode hex": "22A5" },
            { "Typeface name": "Symbol", "Dingbat dec": "95", "Dingbat hex": "5F", "Unicode dec": "95", "Unicode hex": "5F" },
            { "Typeface name": "Symbol", "Dingbat dec": "96", "Dingbat hex": "60", "Unicode dec": "8254", "Unicode hex": "203E" },
            { "Typeface name": "Symbol", "Dingbat dec": "97", "Dingbat hex": "61", "Unicode dec": "945", "Unicode hex": "3B1" },
            { "Typeface name": "Symbol", "Dingbat dec": "98", "Dingbat hex": "62", "Unicode dec": "946", "Unicode hex": "3B2" },
            { "Typeface name": "Symbol", "Dingbat dec": "99", "Dingbat hex": "63", "Unicode dec": "967", "Unicode hex": "3C7" },
            { "Typeface name": "Symbol", "Dingbat dec": "100", "Dingbat hex": "64", "Unicode dec": "948", "Unicode hex": "3B4" },
            { "Typeface name": "Symbol", "Dingbat dec": "101", "Dingbat hex": "65", "Unicode dec": "949", "Unicode hex": "3B5" },
            { "Typeface name": "Symbol", "Dingbat dec": "102", "Dingbat hex": "66", "Unicode dec": "966", "Unicode hex": "3C6" },
            { "Typeface name": "Symbol", "Dingbat dec": "103", "Dingbat hex": "67", "Unicode dec": "947", "Unicode hex": "3B3" },
            { "Typeface name": "Symbol", "Dingbat dec": "104", "Dingbat hex": "68", "Unicode dec": "951", "Unicode hex": "3B7" },
            { "Typeface name": "Symbol", "Dingbat dec": "105", "Dingbat hex": "69", "Unicode dec": "953", "Unicode hex": "3B9" },
            { "Typeface name": "Symbol", "Dingbat dec": "106", "Dingbat hex": "6A", "Unicode dec": "981", "Unicode hex": "3D5" },
            { "Typeface name": "Symbol", "Dingbat dec": "107", "Dingbat hex": "6B", "Unicode dec": "954", "Unicode hex": "3BA" },
            { "Typeface name": "Symbol", "Dingbat dec": "108", "Dingbat hex": "6C", "Unicode dec": "955", "Unicode hex": "3BB" },
            { "Typeface name": "Symbol", "Dingbat dec": "109", "Dingbat hex": "6D", "Unicode dec": "956", "Unicode hex": "3BC" },
            { "Typeface name": "Symbol", "Dingbat dec": "110", "Dingbat hex": "6E", "Unicode dec": "957", "Unicode hex": "3BD" },
            { "Typeface name": "Symbol", "Dingbat dec": "111", "Dingbat hex": "6F", "Unicode dec": "959", "Unicode hex": "3BF" },
            { "Typeface name": "Symbol", "Dingbat dec": "112", "Dingbat hex": "70", "Unicode dec": "960", "Unicode hex": "3C0" },
            { "Typeface name": "Symbol", "Dingbat dec": "113", "Dingbat hex": "71", "Unicode dec": "952", "Unicode hex": "3B8" },
            { "Typeface name": "Symbol", "Dingbat dec": "114", "Dingbat hex": "72", "Unicode dec": "961", "Unicode hex": "3C1" },
            { "Typeface name": "Symbol", "Dingbat dec": "115", "Dingbat hex": "73", "Unicode dec": "963", "Unicode hex": "3C3" },
            { "Typeface name": "Symbol", "Dingbat dec": "116", "Dingbat hex": "74", "Unicode dec": "964", "Unicode hex": "3C4" },
            { "Typeface name": "Symbol", "Dingbat dec": "117", "Dingbat hex": "75", "Unicode dec": "965", "Unicode hex": "3C5" },
            { "Typeface name": "Symbol", "Dingbat dec": "118", "Dingbat hex": "76", "Unicode dec": "982", "Unicode hex": "3D6" },
            { "Typeface name": "Symbol", "Dingbat dec": "119", "Dingbat hex": "77", "Unicode dec": "969", "Unicode hex": "3C9" },
            { "Typeface name": "Symbol", "Dingbat dec": "120", "Dingbat hex": "78", "Unicode dec": "958", "Unicode hex": "3BE" },
            { "Typeface name": "Symbol", "Dingbat dec": "121", "Dingbat hex": "79", "Unicode dec": "968", "Unicode hex": "3C8" },
            { "Typeface name": "Symbol", "Dingbat dec": "122", "Dingbat hex": "7A", "Unicode dec": "950", "Unicode hex": "3B6" },
            { "Typeface name": "Symbol", "Dingbat dec": "123", "Dingbat hex": "7B", "Unicode dec": "123", "Unicode hex": "7B" },
            { "Typeface name": "Symbol", "Dingbat dec": "124", "Dingbat hex": "7C", "Unicode dec": "124", "Unicode hex": "7C" },
            { "Typeface name": "Symbol", "Dingbat dec": "125", "Dingbat hex": "7D", "Unicode dec": "125", "Unicode hex": "7D" },
            { "Typeface name": "Symbol", "Dingbat dec": "126", "Dingbat hex": "7E", "Unicode dec": "126", "Unicode hex": "7E" },
            { "Typeface name": "Symbol", "Dingbat dec": "160", "Dingbat hex": "A0", "Unicode dec": "8364", "Unicode hex": "20AC" },
            { "Typeface name": "Symbol", "Dingbat dec": "161", "Dingbat hex": "A1", "Unicode dec": "978", "Unicode hex": "3D2" },
            { "Typeface name": "Symbol", "Dingbat dec": "162", "Dingbat hex": "A2", "Unicode dec": "8242", "Unicode hex": "2032" },
            { "Typeface name": "Symbol", "Dingbat dec": "163", "Dingbat hex": "A3", "Unicode dec": "8804", "Unicode hex": "2264" },
            { "Typeface name": "Symbol", "Dingbat dec": "164", "Dingbat hex": "A4", "Unicode dec": "8260", "Unicode hex": "2044" },
            { "Typeface name": "Symbol", "Dingbat dec": "165", "Dingbat hex": "A5", "Unicode dec": "8734", "Unicode hex": "221E" },
            { "Typeface name": "Symbol", "Dingbat dec": "166", "Dingbat hex": "A6", "Unicode dec": "402", "Unicode hex": "192" },
            { "Typeface name": "Symbol", "Dingbat dec": "167", "Dingbat hex": "A7", "Unicode dec": "9827", "Unicode hex": "2663" },
            { "Typeface name": "Symbol", "Dingbat dec": "168", "Dingbat hex": "A8", "Unicode dec": "9830", "Unicode hex": "2666" },
            { "Typeface name": "Symbol", "Dingbat dec": "169", "Dingbat hex": "A9", "Unicode dec": "9829", "Unicode hex": "2665" },
            { "Typeface name": "Symbol", "Dingbat dec": "170", "Dingbat hex": "AA", "Unicode dec": "9824", "Unicode hex": "2660" },
            { "Typeface name": "Symbol", "Dingbat dec": "171", "Dingbat hex": "AB", "Unicode dec": "8596", "Unicode hex": "2194" },
            { "Typeface name": "Symbol", "Dingbat dec": "172", "Dingbat hex": "AC", "Unicode dec": "8592", "Unicode hex": "2190" },
            { "Typeface name": "Symbol", "Dingbat dec": "173", "Dingbat hex": "AD", "Unicode dec": "8593", "Unicode hex": "2191" },
            { "Typeface name": "Symbol", "Dingbat dec": "174", "Dingbat hex": "AE", "Unicode dec": "8594", "Unicode hex": "2192" },
            { "Typeface name": "Symbol", "Dingbat dec": "175", "Dingbat hex": "AF", "Unicode dec": "8595", "Unicode hex": "2193" },
            { "Typeface name": "Symbol", "Dingbat dec": "176", "Dingbat hex": "B0", "Unicode dec": "176", "Unicode hex": "B0" },
            { "Typeface name": "Symbol", "Dingbat dec": "177", "Dingbat hex": "B1", "Unicode dec": "177", "Unicode hex": "B1" },
            { "Typeface name": "Symbol", "Dingbat dec": "178", "Dingbat hex": "B2", "Unicode dec": "8243", "Unicode hex": "2033" },
            { "Typeface name": "Symbol", "Dingbat dec": "179", "Dingbat hex": "B3", "Unicode dec": "8805", "Unicode hex": "2265" },
            { "Typeface name": "Symbol", "Dingbat dec": "180", "Dingbat hex": "B4", "Unicode dec": "215", "Unicode hex": "D7" },
            { "Typeface name": "Symbol", "Dingbat dec": "181", "Dingbat hex": "B5", "Unicode dec": "8733", "Unicode hex": "221D" },
            { "Typeface name": "Symbol", "Dingbat dec": "182", "Dingbat hex": "B6", "Unicode dec": "8706", "Unicode hex": "2202" },
            { "Typeface name": "Symbol", "Dingbat dec": "183", "Dingbat hex": "B7", "Unicode dec": "8226", "Unicode hex": "2022" },
            { "Typeface name": "Symbol", "Dingbat dec": "184", "Dingbat hex": "B8", "Unicode dec": "247", "Unicode hex": "F7" },
            { "Typeface name": "Symbol", "Dingbat dec": "185", "Dingbat hex": "B9", "Unicode dec": "8800", "Unicode hex": "2260" },
            { "Typeface name": "Symbol", "Dingbat dec": "186", "Dingbat hex": "BA", "Unicode dec": "8801", "Unicode hex": "2261" },
            { "Typeface name": "Symbol", "Dingbat dec": "187", "Dingbat hex": "BB", "Unicode dec": "8776", "Unicode hex": "2248" },
            { "Typeface name": "Symbol", "Dingbat dec": "188", "Dingbat hex": "BC", "Unicode dec": "8230", "Unicode hex": "2026" },
            { "Typeface name": "Symbol", "Dingbat dec": "189", "Dingbat hex": "BD", "Unicode dec": "9168", "Unicode hex": "23D0" },
            { "Typeface name": "Symbol", "Dingbat dec": "190", "Dingbat hex": "BE", "Unicode dec": "9135", "Unicode hex": "23AF" },
            { "Typeface name": "Symbol", "Dingbat dec": "191", "Dingbat hex": "BF", "Unicode dec": "8629", "Unicode hex": "21B5" },
            { "Typeface name": "Symbol", "Dingbat dec": "192", "Dingbat hex": "C0", "Unicode dec": "8501", "Unicode hex": "2135" },
            { "Typeface name": "Symbol", "Dingbat dec": "193", "Dingbat hex": "C1", "Unicode dec": "8465", "Unicode hex": "2111" },
            { "Typeface name": "Symbol", "Dingbat dec": "194", "Dingbat hex": "C2", "Unicode dec": "8476", "Unicode hex": "211C" },
            { "Typeface name": "Symbol", "Dingbat dec": "195", "Dingbat hex": "C3", "Unicode dec": "8472", "Unicode hex": "2118" },
            { "Typeface name": "Symbol", "Dingbat dec": "196", "Dingbat hex": "C4", "Unicode dec": "8855", "Unicode hex": "2297" },
            { "Typeface name": "Symbol", "Dingbat dec": "197", "Dingbat hex": "C5", "Unicode dec": "8853", "Unicode hex": "2295" },
            { "Typeface name": "Symbol", "Dingbat dec": "198", "Dingbat hex": "C6", "Unicode dec": "8709", "Unicode hex": "2205" },
            { "Typeface name": "Symbol", "Dingbat dec": "199", "Dingbat hex": "C7", "Unicode dec": "8745", "Unicode hex": "2229" },
            { "Typeface name": "Symbol", "Dingbat dec": "200", "Dingbat hex": "C8", "Unicode dec": "8746", "Unicode hex": "222A" },
            { "Typeface name": "Symbol", "Dingbat dec": "201", "Dingbat hex": "C9", "Unicode dec": "8835", "Unicode hex": "2283" },
            { "Typeface name": "Symbol", "Dingbat dec": "202", "Dingbat hex": "CA", "Unicode dec": "8839", "Unicode hex": "2287" },
            { "Typeface name": "Symbol", "Dingbat dec": "203", "Dingbat hex": "CB", "Unicode dec": "8836", "Unicode hex": "2284" },
            { "Typeface name": "Symbol", "Dingbat dec": "204", "Dingbat hex": "CC", "Unicode dec": "8834", "Unicode hex": "2282" },
            { "Typeface name": "Symbol", "Dingbat dec": "205", "Dingbat hex": "CD", "Unicode dec": "8838", "Unicode hex": "2286" },
            { "Typeface name": "Symbol", "Dingbat dec": "206", "Dingbat hex": "CE", "Unicode dec": "8712", "Unicode hex": "2208" },
            { "Typeface name": "Symbol", "Dingbat dec": "207", "Dingbat hex": "CF", "Unicode dec": "8713", "Unicode hex": "2209" },
            { "Typeface name": "Symbol", "Dingbat dec": "208", "Dingbat hex": "D0", "Unicode dec": "8736", "Unicode hex": "2220" },
            { "Typeface name": "Symbol", "Dingbat dec": "209", "Dingbat hex": "D1", "Unicode dec": "8711", "Unicode hex": "2207" },
            { "Typeface name": "Symbol", "Dingbat dec": "210", "Dingbat hex": "D2", "Unicode dec": "174", "Unicode hex": "AE" },
            { "Typeface name": "Symbol", "Dingbat dec": "211", "Dingbat hex": "D3", "Unicode dec": "169", "Unicode hex": "A9" },
            { "Typeface name": "Symbol", "Dingbat dec": "212", "Dingbat hex": "D4", "Unicode dec": "8482", "Unicode hex": "2122" },
            { "Typeface name": "Symbol", "Dingbat dec": "213", "Dingbat hex": "D5", "Unicode dec": "8719", "Unicode hex": "220F" },
            { "Typeface name": "Symbol", "Dingbat dec": "214", "Dingbat hex": "D6", "Unicode dec": "8730", "Unicode hex": "221A" },
            { "Typeface name": "Symbol", "Dingbat dec": "215", "Dingbat hex": "D7", "Unicode dec": "8901", "Unicode hex": "22C5" },
            { "Typeface name": "Symbol", "Dingbat dec": "216", "Dingbat hex": "D8", "Unicode dec": "172", "Unicode hex": "AC" },
            { "Typeface name": "Symbol", "Dingbat dec": "217", "Dingbat hex": "D9", "Unicode dec": "8743", "Unicode hex": "2227" },
            { "Typeface name": "Symbol", "Dingbat dec": "218", "Dingbat hex": "DA", "Unicode dec": "8744", "Unicode hex": "2228" },
            { "Typeface name": "Symbol", "Dingbat dec": "219", "Dingbat hex": "DB", "Unicode dec": "8660", "Unicode hex": "21D4" },
            { "Typeface name": "Symbol", "Dingbat dec": "220", "Dingbat hex": "DC", "Unicode dec": "8656", "Unicode hex": "21D0" },
            { "Typeface name": "Symbol", "Dingbat dec": "221", "Dingbat hex": "DD", "Unicode dec": "8657", "Unicode hex": "21D1" },
            { "Typeface name": "Symbol", "Dingbat dec": "222", "Dingbat hex": "DE", "Unicode dec": "8658", "Unicode hex": "21D2" },
            { "Typeface name": "Symbol", "Dingbat dec": "223", "Dingbat hex": "DF", "Unicode dec": "8659", "Unicode hex": "21D3" },
            { "Typeface name": "Symbol", "Dingbat dec": "224", "Dingbat hex": "E0", "Unicode dec": "9674", "Unicode hex": "25CA" },
            { "Typeface name": "Symbol", "Dingbat dec": "225", "Dingbat hex": "E1", "Unicode dec": "12296", "Unicode hex": "3008" },
            { "Typeface name": "Symbol", "Dingbat dec": "226", "Dingbat hex": "E2", "Unicode dec": "174", "Unicode hex": "AE" },
            { "Typeface name": "Symbol", "Dingbat dec": "227", "Dingbat hex": "E3", "Unicode dec": "169", "Unicode hex": "A9" },
            { "Typeface name": "Symbol", "Dingbat dec": "228", "Dingbat hex": "E4", "Unicode dec": "8482", "Unicode hex": "2122" },
            { "Typeface name": "Symbol", "Dingbat dec": "229", "Dingbat hex": "E5", "Unicode dec": "8721", "Unicode hex": "2211" },
            { "Typeface name": "Symbol", "Dingbat dec": "230", "Dingbat hex": "E6", "Unicode dec": "9115", "Unicode hex": "239B" },
            { "Typeface name": "Symbol", "Dingbat dec": "231", "Dingbat hex": "E7", "Unicode dec": "9116", "Unicode hex": "239C" },
            { "Typeface name": "Symbol", "Dingbat dec": "232", "Dingbat hex": "E8", "Unicode dec": "9117", "Unicode hex": "239D" },
            { "Typeface name": "Symbol", "Dingbat dec": "233", "Dingbat hex": "E9", "Unicode dec": "9121", "Unicode hex": "23A1" },
            { "Typeface name": "Symbol", "Dingbat dec": "234", "Dingbat hex": "EA", "Unicode dec": "9122", "Unicode hex": "23A2" },
            { "Typeface name": "Symbol", "Dingbat dec": "235", "Dingbat hex": "EB", "Unicode dec": "9123", "Unicode hex": "23A3" },
            { "Typeface name": "Symbol", "Dingbat dec": "236", "Dingbat hex": "EC", "Unicode dec": "9127", "Unicode hex": "23A7" },
            { "Typeface name": "Symbol", "Dingbat dec": "237", "Dingbat hex": "ED", "Unicode dec": "9128", "Unicode hex": "23A8" },
            { "Typeface name": "Symbol", "Dingbat dec": "238", "Dingbat hex": "EE", "Unicode dec": "9129", "Unicode hex": "23A9" },
            { "Typeface name": "Symbol", "Dingbat dec": "239", "Dingbat hex": "EF", "Unicode dec": "9130", "Unicode hex": "23AA" },
            { "Typeface name": "Symbol", "Dingbat dec": "240", "Dingbat hex": "F0", "Unicode dec": "63743", "Unicode hex": "F8FF" },
            { "Typeface name": "Symbol", "Dingbat dec": "241", "Dingbat hex": "F1", "Unicode dec": "12297", "Unicode hex": "3009" },
            { "Typeface name": "Symbol", "Dingbat dec": "242", "Dingbat hex": "F2", "Unicode dec": "8747", "Unicode hex": "222B" },
            { "Typeface name": "Symbol", "Dingbat dec": "243", "Dingbat hex": "F3", "Unicode dec": "8992", "Unicode hex": "2320" },
            { "Typeface name": "Symbol", "Dingbat dec": "244", "Dingbat hex": "F4", "Unicode dec": "9134", "Unicode hex": "23AE" },
            { "Typeface name": "Symbol", "Dingbat dec": "245", "Dingbat hex": "F5", "Unicode dec": "8993", "Unicode hex": "2321" },
            { "Typeface name": "Symbol", "Dingbat dec": "246", "Dingbat hex": "F6", "Unicode dec": "9118", "Unicode hex": "239E" },
            { "Typeface name": "Symbol", "Dingbat dec": "247", "Dingbat hex": "F7", "Unicode dec": "9119", "Unicode hex": "239F" },
            { "Typeface name": "Symbol", "Dingbat dec": "248", "Dingbat hex": "F8", "Unicode dec": "9120", "Unicode hex": "23A0" },
            { "Typeface name": "Symbol", "Dingbat dec": "249", "Dingbat hex": "F9", "Unicode dec": "9124", "Unicode hex": "23A4" },
            { "Typeface name": "Symbol", "Dingbat dec": "250", "Dingbat hex": "FA", "Unicode dec": "9125", "Unicode hex": "23A5" },
            { "Typeface name": "Symbol", "Dingbat dec": "251", "Dingbat hex": "FB", "Unicode dec": "9126", "Unicode hex": "23A6" },
            { "Typeface name": "Symbol", "Dingbat dec": "252", "Dingbat hex": "FC", "Unicode dec": "9131", "Unicode hex": "23AB" },
            { "Typeface name": "Symbol", "Dingbat dec": "253", "Dingbat hex": "FD", "Unicode dec": "9132", "Unicode hex": "23AC" },
            { "Typeface name": "Symbol", "Dingbat dec": "254", "Dingbat hex": "FE", "Unicode dec": "9133", "Unicode hex": "23AD" },
            { "Typeface name": "Webdings", "Dingbat dec": "32", "Dingbat hex": "20", "Unicode dec": "32", "Unicode hex": "20" },
            { "Typeface name": "Webdings", "Dingbat dec": "33", "Dingbat hex": "21", "Unicode dec": "128375", "Unicode hex": "1F577" },
            { "Typeface name": "Webdings", "Dingbat dec": "34", "Dingbat hex": "22", "Unicode dec": "128376", "Unicode hex": "1F578" },
            { "Typeface name": "Webdings", "Dingbat dec": "35", "Dingbat hex": "23", "Unicode dec": "128370", "Unicode hex": "1F572" },
            { "Typeface name": "Webdings", "Dingbat dec": "36", "Dingbat hex": "24", "Unicode dec": "128374", "Unicode hex": "1F576" },
            { "Typeface name": "Webdings", "Dingbat dec": "37", "Dingbat hex": "25", "Unicode dec": "127942", "Unicode hex": "1F3C6" },
            { "Typeface name": "Webdings", "Dingbat dec": "38", "Dingbat hex": "26", "Unicode dec": "127894", "Unicode hex": "1F396" },
            { "Typeface name": "Webdings", "Dingbat dec": "39", "Dingbat hex": "27", "Unicode dec": "128391", "Unicode hex": "1F587" },
            { "Typeface name": "Webdings", "Dingbat dec": "40", "Dingbat hex": "28", "Unicode dec": "128488", "Unicode hex": "1F5E8" },
            { "Typeface name": "Webdings", "Dingbat dec": "41", "Dingbat hex": "29", "Unicode dec": "128489", "Unicode hex": "1F5E9" },
            { "Typeface name": "Webdings", "Dingbat dec": "42", "Dingbat hex": "2A", "Unicode dec": "128496", "Unicode hex": "1F5F0" },
            { "Typeface name": "Webdings", "Dingbat dec": "43", "Dingbat hex": "2B", "Unicode dec": "128497", "Unicode hex": "1F5F1" },
            { "Typeface name": "Webdings", "Dingbat dec": "44", "Dingbat hex": "2C", "Unicode dec": "127798", "Unicode hex": "1F336" },
            { "Typeface name": "Webdings", "Dingbat dec": "45", "Dingbat hex": "2D", "Unicode dec": "127895", "Unicode hex": "1F397" },
            { "Typeface name": "Webdings", "Dingbat dec": "46", "Dingbat hex": "2E", "Unicode dec": "128638", "Unicode hex": "1F67E" },
            { "Typeface name": "Webdings", "Dingbat dec": "47", "Dingbat hex": "2F", "Unicode dec": "128636", "Unicode hex": "1F67C" },
            { "Typeface name": "Webdings", "Dingbat dec": "48", "Dingbat hex": "30", "Unicode dec": "128469", "Unicode hex": "1F5D5" },
            { "Typeface name": "Webdings", "Dingbat dec": "49", "Dingbat hex": "31", "Unicode dec": "128470", "Unicode hex": "1F5D6" },
            { "Typeface name": "Webdings", "Dingbat dec": "50", "Dingbat hex": "32", "Unicode dec": "128471", "Unicode hex": "1F5D7" },
            { "Typeface name": "Webdings", "Dingbat dec": "51", "Dingbat hex": "33", "Unicode dec": "9204", "Unicode hex": "23F4" },
            { "Typeface name": "Webdings", "Dingbat dec": "52", "Dingbat hex": "34", "Unicode dec": "9205", "Unicode hex": "23F5" },
            { "Typeface name": "Webdings", "Dingbat dec": "53", "Dingbat hex": "35", "Unicode dec": "9206", "Unicode hex": "23F6" },
            { "Typeface name": "Webdings", "Dingbat dec": "54", "Dingbat hex": "36", "Unicode dec": "9207", "Unicode hex": "23F7" },
            { "Typeface name": "Webdings", "Dingbat dec": "55", "Dingbat hex": "37", "Unicode dec": "9194", "Unicode hex": "23EA" },
            { "Typeface name": "Webdings", "Dingbat dec": "56", "Dingbat hex": "38", "Unicode dec": "9193", "Unicode hex": "23E9" },
            { "Typeface name": "Webdings", "Dingbat dec": "57", "Dingbat hex": "39", "Unicode dec": "9198", "Unicode hex": "23EE" },
            { "Typeface name": "Webdings", "Dingbat dec": "58", "Dingbat hex": "3A", "Unicode dec": "9197", "Unicode hex": "23ED" },
            { "Typeface name": "Webdings", "Dingbat dec": "59", "Dingbat hex": "3B", "Unicode dec": "9208", "Unicode hex": "23F8" },
            { "Typeface name": "Webdings", "Dingbat dec": "60", "Dingbat hex": "3C", "Unicode dec": "9209", "Unicode hex": "23F9" },
            { "Typeface name": "Webdings", "Dingbat dec": "61", "Dingbat hex": "3D", "Unicode dec": "9210", "Unicode hex": "23FA" },
            { "Typeface name": "Webdings", "Dingbat dec": "62", "Dingbat hex": "3E", "Unicode dec": "128474", "Unicode hex": "1F5DA" },
            { "Typeface name": "Webdings", "Dingbat dec": "63", "Dingbat hex": "3F", "Unicode dec": "128499", "Unicode hex": "1F5F3" },
            { "Typeface name": "Webdings", "Dingbat dec": "64", "Dingbat hex": "40", "Unicode dec": "128736", "Unicode hex": "1F6E0" },
            { "Typeface name": "Webdings", "Dingbat dec": "65", "Dingbat hex": "41", "Unicode dec": "127959", "Unicode hex": "1F3D7" },
            { "Typeface name": "Webdings", "Dingbat dec": "66", "Dingbat hex": "42", "Unicode dec": "127960", "Unicode hex": "1F3D8" },
            { "Typeface name": "Webdings", "Dingbat dec": "67", "Dingbat hex": "43", "Unicode dec": "127961", "Unicode hex": "1F3D9" },
            { "Typeface name": "Webdings", "Dingbat dec": "68", "Dingbat hex": "44", "Unicode dec": "127962", "Unicode hex": "1F3DA" },
            { "Typeface name": "Webdings", "Dingbat dec": "69", "Dingbat hex": "45", "Unicode dec": "127964", "Unicode hex": "1F3DC" },
            { "Typeface name": "Webdings", "Dingbat dec": "70", "Dingbat hex": "46", "Unicode dec": "127981", "Unicode hex": "1F3ED" },
            { "Typeface name": "Webdings", "Dingbat dec": "71", "Dingbat hex": "47", "Unicode dec": "127963", "Unicode hex": "1F3DB" },
            { "Typeface name": "Webdings", "Dingbat dec": "72", "Dingbat hex": "48", "Unicode dec": "127968", "Unicode hex": "1F3E0" },
            { "Typeface name": "Webdings", "Dingbat dec": "73", "Dingbat hex": "49", "Unicode dec": "127958", "Unicode hex": "1F3D6" },
            { "Typeface name": "Webdings", "Dingbat dec": "74", "Dingbat hex": "4A", "Unicode dec": "127965", "Unicode hex": "1F3DD" },
            { "Typeface name": "Webdings", "Dingbat dec": "75", "Dingbat hex": "4B", "Unicode dec": "128739", "Unicode hex": "1F6E3" },
            { "Typeface name": "Webdings", "Dingbat dec": "76", "Dingbat hex": "4C", "Unicode dec": "128269", "Unicode hex": "1F50D" },
            { "Typeface name": "Webdings", "Dingbat dec": "77", "Dingbat hex": "4D", "Unicode dec": "127956", "Unicode hex": "1F3D4" },
            { "Typeface name": "Webdings", "Dingbat dec": "78", "Dingbat hex": "4E", "Unicode dec": "128065", "Unicode hex": "1F441" },
            { "Typeface name": "Webdings", "Dingbat dec": "79", "Dingbat hex": "4F", "Unicode dec": "128066", "Unicode hex": "1F442" },
            { "Typeface name": "Webdings", "Dingbat dec": "80", "Dingbat hex": "50", "Unicode dec": "127966", "Unicode hex": "1F3DE" },
            { "Typeface name": "Webdings", "Dingbat dec": "81", "Dingbat hex": "51", "Unicode dec": "127957", "Unicode hex": "1F3D5" },
            { "Typeface name": "Webdings", "Dingbat dec": "82", "Dingbat hex": "52", "Unicode dec": "128740", "Unicode hex": "1F6E4" },
            { "Typeface name": "Webdings", "Dingbat dec": "83", "Dingbat hex": "53", "Unicode dec": "127967", "Unicode hex": "1F3DF" },
            { "Typeface name": "Webdings", "Dingbat dec": "84", "Dingbat hex": "54", "Unicode dec": "128755", "Unicode hex": "1F6F3" },
            { "Typeface name": "Webdings", "Dingbat dec": "85", "Dingbat hex": "55", "Unicode dec": "128364", "Unicode hex": "1F56C" },
            { "Typeface name": "Webdings", "Dingbat dec": "86", "Dingbat hex": "56", "Unicode dec": "128363", "Unicode hex": "1F56B" },
            { "Typeface name": "Webdings", "Dingbat dec": "87", "Dingbat hex": "57", "Unicode dec": "128360", "Unicode hex": "1F568" },
            { "Typeface name": "Webdings", "Dingbat dec": "88", "Dingbat hex": "58", "Unicode dec": "128264", "Unicode hex": "1F508" },
            { "Typeface name": "Webdings", "Dingbat dec": "89", "Dingbat hex": "59", "Unicode dec": "127892", "Unicode hex": "1F394" },
            { "Typeface name": "Webdings", "Dingbat dec": "90", "Dingbat hex": "5A", "Unicode dec": "127893", "Unicode hex": "1F395" },
            { "Typeface name": "Webdings", "Dingbat dec": "91", "Dingbat hex": "5B", "Unicode dec": "128492", "Unicode hex": "1F5EC" },
            { "Typeface name": "Webdings", "Dingbat dec": "92", "Dingbat hex": "5C", "Unicode dec": "128637", "Unicode hex": "1F67D" },
            { "Typeface name": "Webdings", "Dingbat dec": "93", "Dingbat hex": "5D", "Unicode dec": "128493", "Unicode hex": "1F5ED" },
            { "Typeface name": "Webdings", "Dingbat dec": "94", "Dingbat hex": "5E", "Unicode dec": "128490", "Unicode hex": "1F5EA" },
            { "Typeface name": "Webdings", "Dingbat dec": "95", "Dingbat hex": "5F", "Unicode dec": "128491", "Unicode hex": "1F5EB" },
            { "Typeface name": "Webdings", "Dingbat dec": "96", "Dingbat hex": "60", "Unicode dec": "11156", "Unicode hex": "2B94" },
            { "Typeface name": "Webdings", "Dingbat dec": "97", "Dingbat hex": "61", "Unicode dec": "10004", "Unicode hex": "2714" },
            { "Typeface name": "Webdings", "Dingbat dec": "98", "Dingbat hex": "62", "Unicode dec": "128690", "Unicode hex": "1F6B2" },
            { "Typeface name": "Webdings", "Dingbat dec": "99", "Dingbat hex": "63", "Unicode dec": "11036", "Unicode hex": "2B1C" },
            { "Typeface name": "Webdings", "Dingbat dec": "100", "Dingbat hex": "64", "Unicode dec": "128737", "Unicode hex": "1F6E1" },
            { "Typeface name": "Webdings", "Dingbat dec": "101", "Dingbat hex": "65", "Unicode dec": "128230", "Unicode hex": "1F4E6" },
            { "Typeface name": "Webdings", "Dingbat dec": "102", "Dingbat hex": "66", "Unicode dec": "128753", "Unicode hex": "1F6F1" },
            { "Typeface name": "Webdings", "Dingbat dec": "103", "Dingbat hex": "67", "Unicode dec": "11035", "Unicode hex": "2B1B" },
            { "Typeface name": "Webdings", "Dingbat dec": "104", "Dingbat hex": "68", "Unicode dec": "128657", "Unicode hex": "1F691" },
            { "Typeface name": "Webdings", "Dingbat dec": "105", "Dingbat hex": "69", "Unicode dec": "128712", "Unicode hex": "1F6C8" },
            { "Typeface name": "Webdings", "Dingbat dec": "106", "Dingbat hex": "6A", "Unicode dec": "128745", "Unicode hex": "1F6E9" },
            { "Typeface name": "Webdings", "Dingbat dec": "107", "Dingbat hex": "6B", "Unicode dec": "128752", "Unicode hex": "1F6F0" },
            { "Typeface name": "Webdings", "Dingbat dec": "108", "Dingbat hex": "6C", "Unicode dec": "128968", "Unicode hex": "1F7C8" },
            { "Typeface name": "Webdings", "Dingbat dec": "109", "Dingbat hex": "6D", "Unicode dec": "128372", "Unicode hex": "1F574" },
            { "Typeface name": "Webdings", "Dingbat dec": "110", "Dingbat hex": "6E", "Unicode dec": "11044", "Unicode hex": "2B24" },
            { "Typeface name": "Webdings", "Dingbat dec": "111", "Dingbat hex": "6F", "Unicode dec": "128741", "Unicode hex": "1F6E5" },
            { "Typeface name": "Webdings", "Dingbat dec": "112", "Dingbat hex": "70", "Unicode dec": "128660", "Unicode hex": "1F694" },
            { "Typeface name": "Webdings", "Dingbat dec": "113", "Dingbat hex": "71", "Unicode dec": "128472", "Unicode hex": "1F5D8" },
            { "Typeface name": "Webdings", "Dingbat dec": "114", "Dingbat hex": "72", "Unicode dec": "128473", "Unicode hex": "1F5D9" },
            { "Typeface name": "Webdings", "Dingbat dec": "115", "Dingbat hex": "73", "Unicode dec": "10067", "Unicode hex": "2753" },
            { "Typeface name": "Webdings", "Dingbat dec": "116", "Dingbat hex": "74", "Unicode dec": "128754", "Unicode hex": "1F6F2" },
            { "Typeface name": "Webdings", "Dingbat dec": "117", "Dingbat hex": "75", "Unicode dec": "128647", "Unicode hex": "1F687" },
            { "Typeface name": "Webdings", "Dingbat dec": "118", "Dingbat hex": "76", "Unicode dec": "128653", "Unicode hex": "1F68D" },
            { "Typeface name": "Webdings", "Dingbat dec": "119", "Dingbat hex": "77", "Unicode dec": "9971", "Unicode hex": "26F3" },
            { "Typeface name": "Webdings", "Dingbat dec": "120", "Dingbat hex": "78", "Unicode dec": "10680", "Unicode hex": "29B8" },
            { "Typeface name": "Webdings", "Dingbat dec": "121", "Dingbat hex": "79", "Unicode dec": "8854", "Unicode hex": "2296" },
            { "Typeface name": "Webdings", "Dingbat dec": "122", "Dingbat hex": "7A", "Unicode dec": "128685", "Unicode hex": "1F6AD" },
            { "Typeface name": "Webdings", "Dingbat dec": "123", "Dingbat hex": "7B", "Unicode dec": "128494", "Unicode hex": "1F5EE" },
            { "Typeface name": "Webdings", "Dingbat dec": "124", "Dingbat hex": "7C", "Unicode dec": "9168", "Unicode hex": "23D0" },
            { "Typeface name": "Webdings", "Dingbat dec": "125", "Dingbat hex": "7D", "Unicode dec": "128495", "Unicode hex": "1F5EF" },
            { "Typeface name": "Webdings", "Dingbat dec": "126", "Dingbat hex": "7E", "Unicode dec": "128498", "Unicode hex": "1F5F2" },
            { "Typeface name": "Webdings", "Dingbat dec": "128", "Dingbat hex": "80", "Unicode dec": "128697", "Unicode hex": "1F6B9" },
            { "Typeface name": "Webdings", "Dingbat dec": "129", "Dingbat hex": "81", "Unicode dec": "128698", "Unicode hex": "1F6BA" },
            { "Typeface name": "Webdings", "Dingbat dec": "130", "Dingbat hex": "82", "Unicode dec": "128713", "Unicode hex": "1F6C9" },
            { "Typeface name": "Webdings", "Dingbat dec": "131", "Dingbat hex": "83", "Unicode dec": "128714", "Unicode hex": "1F6CA" },
            { "Typeface name": "Webdings", "Dingbat dec": "132", "Dingbat hex": "84", "Unicode dec": "128700", "Unicode hex": "1F6BC" },
            { "Typeface name": "Webdings", "Dingbat dec": "133", "Dingbat hex": "85", "Unicode dec": "128125", "Unicode hex": "1F47D" },
            { "Typeface name": "Webdings", "Dingbat dec": "134", "Dingbat hex": "86", "Unicode dec": "127947", "Unicode hex": "1F3CB" },
            { "Typeface name": "Webdings", "Dingbat dec": "135", "Dingbat hex": "87", "Unicode dec": "9975", "Unicode hex": "26F7" },
            { "Typeface name": "Webdings", "Dingbat dec": "136", "Dingbat hex": "88", "Unicode dec": "127938", "Unicode hex": "1F3C2" },
            { "Typeface name": "Webdings", "Dingbat dec": "137", "Dingbat hex": "89", "Unicode dec": "127948", "Unicode hex": "1F3CC" },
            { "Typeface name": "Webdings", "Dingbat dec": "138", "Dingbat hex": "8A", "Unicode dec": "127946", "Unicode hex": "1F3CA" },
            { "Typeface name": "Webdings", "Dingbat dec": "139", "Dingbat hex": "8B", "Unicode dec": "127940", "Unicode hex": "1F3C4" },
            { "Typeface name": "Webdings", "Dingbat dec": "140", "Dingbat hex": "8C", "Unicode dec": "127949", "Unicode hex": "1F3CD" },
            { "Typeface name": "Webdings", "Dingbat dec": "141", "Dingbat hex": "8D", "Unicode dec": "127950", "Unicode hex": "1F3CE" },
            { "Typeface name": "Webdings", "Dingbat dec": "142", "Dingbat hex": "8E", "Unicode dec": "128664", "Unicode hex": "1F698" },
            { "Typeface name": "Webdings", "Dingbat dec": "143", "Dingbat hex": "8F", "Unicode dec": "128480", "Unicode hex": "1F5E0" },
            { "Typeface name": "Webdings", "Dingbat dec": "144", "Dingbat hex": "90", "Unicode dec": "128738", "Unicode hex": "1F6E2" },
            { "Typeface name": "Webdings", "Dingbat dec": "145", "Dingbat hex": "91", "Unicode dec": "128176", "Unicode hex": "1F4B0" },
            { "Typeface name": "Webdings", "Dingbat dec": "146", "Dingbat hex": "92", "Unicode dec": "127991", "Unicode hex": "1F3F7" },
            { "Typeface name": "Webdings", "Dingbat dec": "147", "Dingbat hex": "93", "Unicode dec": "128179", "Unicode hex": "1F4B3" },
            { "Typeface name": "Webdings", "Dingbat dec": "148", "Dingbat hex": "94", "Unicode dec": "128106", "Unicode hex": "1F46A" },
            { "Typeface name": "Webdings", "Dingbat dec": "149", "Dingbat hex": "95", "Unicode dec": "128481", "Unicode hex": "1F5E1" },
            { "Typeface name": "Webdings", "Dingbat dec": "150", "Dingbat hex": "96", "Unicode dec": "128482", "Unicode hex": "1F5E2" },
            { "Typeface name": "Webdings", "Dingbat dec": "151", "Dingbat hex": "97", "Unicode dec": "128483", "Unicode hex": "1F5E3" },
            { "Typeface name": "Webdings", "Dingbat dec": "152", "Dingbat hex": "98", "Unicode dec": "10031", "Unicode hex": "272F" },
            { "Typeface name": "Webdings", "Dingbat dec": "153", "Dingbat hex": "99", "Unicode dec": "128388", "Unicode hex": "1F584" },
            { "Typeface name": "Webdings", "Dingbat dec": "154", "Dingbat hex": "9A", "Unicode dec": "128389", "Unicode hex": "1F585" },
            { "Typeface name": "Webdings", "Dingbat dec": "155", "Dingbat hex": "9B", "Unicode dec": "128387", "Unicode hex": "1F583" },
            { "Typeface name": "Webdings", "Dingbat dec": "156", "Dingbat hex": "9C", "Unicode dec": "128390", "Unicode hex": "1F586" },
            { "Typeface name": "Webdings", "Dingbat dec": "157", "Dingbat hex": "9D", "Unicode dec": "128441", "Unicode hex": "1F5B9" },
            { "Typeface name": "Webdings", "Dingbat dec": "158", "Dingbat hex": "9E", "Unicode dec": "128442", "Unicode hex": "1F5BA" },
            { "Typeface name": "Webdings", "Dingbat dec": "159", "Dingbat hex": "9F", "Unicode dec": "128443", "Unicode hex": "1F5BB" },
            { "Typeface name": "Webdings", "Dingbat dec": "160", "Dingbat hex": "A0", "Unicode dec": "128373", "Unicode hex": "1F575" },
            { "Typeface name": "Webdings", "Dingbat dec": "161", "Dingbat hex": "A1", "Unicode dec": "128368", "Unicode hex": "1F570" },
            { "Typeface name": "Webdings", "Dingbat dec": "162", "Dingbat hex": "A2", "Unicode dec": "128445", "Unicode hex": "1F5BD" },
            { "Typeface name": "Webdings", "Dingbat dec": "163", "Dingbat hex": "A3", "Unicode dec": "128446", "Unicode hex": "1F5BE" },
            { "Typeface name": "Webdings", "Dingbat dec": "164", "Dingbat hex": "A4", "Unicode dec": "128203", "Unicode hex": "1F4CB" },
            { "Typeface name": "Webdings", "Dingbat dec": "165", "Dingbat hex": "A5", "Unicode dec": "128466", "Unicode hex": "1F5D2" },
            { "Typeface name": "Webdings", "Dingbat dec": "166", "Dingbat hex": "A6", "Unicode dec": "128467", "Unicode hex": "1F5D3" },
            { "Typeface name": "Webdings", "Dingbat dec": "167", "Dingbat hex": "A7", "Unicode dec": "128366", "Unicode hex": "1F56E" },
            { "Typeface name": "Webdings", "Dingbat dec": "168", "Dingbat hex": "A8", "Unicode dec": "128218", "Unicode hex": "1F4DA" },
            { "Typeface name": "Webdings", "Dingbat dec": "169", "Dingbat hex": "A9", "Unicode dec": "128478", "Unicode hex": "1F5DE" },
            { "Typeface name": "Webdings", "Dingbat dec": "170", "Dingbat hex": "AA", "Unicode dec": "128479", "Unicode hex": "1F5DF" },
            { "Typeface name": "Webdings", "Dingbat dec": "171", "Dingbat hex": "AB", "Unicode dec": "128451", "Unicode hex": "1F5C3" },
            { "Typeface name": "Webdings", "Dingbat dec": "172", "Dingbat hex": "AC", "Unicode dec": "128450", "Unicode hex": "1F5C2" },
            { "Typeface name": "Webdings", "Dingbat dec": "173", "Dingbat hex": "AD", "Unicode dec": "128444", "Unicode hex": "1F5BC" },
            { "Typeface name": "Webdings", "Dingbat dec": "174", "Dingbat hex": "AE", "Unicode dec": "127917", "Unicode hex": "1F3AD" },
            { "Typeface name": "Webdings", "Dingbat dec": "175", "Dingbat hex": "AF", "Unicode dec": "127900", "Unicode hex": "1F39C" },
            { "Typeface name": "Webdings", "Dingbat dec": "176", "Dingbat hex": "B0", "Unicode dec": "127896", "Unicode hex": "1F398" },
            { "Typeface name": "Webdings", "Dingbat dec": "177", "Dingbat hex": "B1", "Unicode dec": "127897", "Unicode hex": "1F399" },
            { "Typeface name": "Webdings", "Dingbat dec": "178", "Dingbat hex": "B2", "Unicode dec": "127911", "Unicode hex": "1F3A7" },
            { "Typeface name": "Webdings", "Dingbat dec": "179", "Dingbat hex": "B3", "Unicode dec": "128191", "Unicode hex": "1F4BF" },
            { "Typeface name": "Webdings", "Dingbat dec": "180", "Dingbat hex": "B4", "Unicode dec": "127902", "Unicode hex": "1F39E" },
            { "Typeface name": "Webdings", "Dingbat dec": "181", "Dingbat hex": "B5", "Unicode dec": "128247", "Unicode hex": "1F4F7" },
            { "Typeface name": "Webdings", "Dingbat dec": "182", "Dingbat hex": "B6", "Unicode dec": "127903", "Unicode hex": "1F39F" },
            { "Typeface name": "Webdings", "Dingbat dec": "183", "Dingbat hex": "B7", "Unicode dec": "127916", "Unicode hex": "1F3AC" },
            { "Typeface name": "Webdings", "Dingbat dec": "184", "Dingbat hex": "B8", "Unicode dec": "128253", "Unicode hex": "1F4FD" },
            { "Typeface name": "Webdings", "Dingbat dec": "185", "Dingbat hex": "B9", "Unicode dec": "128249", "Unicode hex": "1F4F9" },
            { "Typeface name": "Webdings", "Dingbat dec": "186", "Dingbat hex": "BA", "Unicode dec": "128254", "Unicode hex": "1F4FE" },
            { "Typeface name": "Webdings", "Dingbat dec": "187", "Dingbat hex": "BB", "Unicode dec": "128251", "Unicode hex": "1F4FB" },
            { "Typeface name": "Webdings", "Dingbat dec": "188", "Dingbat hex": "BC", "Unicode dec": "127898", "Unicode hex": "1F39A" },
            { "Typeface name": "Webdings", "Dingbat dec": "189", "Dingbat hex": "BD", "Unicode dec": "127899", "Unicode hex": "1F39B" },
            { "Typeface name": "Webdings", "Dingbat dec": "190", "Dingbat hex": "BE", "Unicode dec": "128250", "Unicode hex": "1F4FA" },
            { "Typeface name": "Webdings", "Dingbat dec": "191", "Dingbat hex": "BF", "Unicode dec": "128187", "Unicode hex": "1F4BB" },
            { "Typeface name": "Webdings", "Dingbat dec": "192", "Dingbat hex": "C0", "Unicode dec": "128421", "Unicode hex": "1F5A5" },
            { "Typeface name": "Webdings", "Dingbat dec": "193", "Dingbat hex": "C1", "Unicode dec": "128422", "Unicode hex": "1F5A6" },
            { "Typeface name": "Webdings", "Dingbat dec": "194", "Dingbat hex": "C2", "Unicode dec": "128423", "Unicode hex": "1F5A7" },
            { "Typeface name": "Webdings", "Dingbat dec": "195", "Dingbat hex": "C3", "Unicode dec": "128377", "Unicode hex": "1F579" },
            { "Typeface name": "Webdings", "Dingbat dec": "196", "Dingbat hex": "C4", "Unicode dec": "127918", "Unicode hex": "1F3AE" },
            { "Typeface name": "Webdings", "Dingbat dec": "197", "Dingbat hex": "C5", "Unicode dec": "128379", "Unicode hex": "1F57B" },
            { "Typeface name": "Webdings", "Dingbat dec": "198", "Dingbat hex": "C6", "Unicode dec": "128380", "Unicode hex": "1F57C" },
            { "Typeface name": "Webdings", "Dingbat dec": "199", "Dingbat hex": "C7", "Unicode dec": "128223", "Unicode hex": "1F4DF" },
            { "Typeface name": "Webdings", "Dingbat dec": "200", "Dingbat hex": "C8", "Unicode dec": "128385", "Unicode hex": "1F581" },
            { "Typeface name": "Webdings", "Dingbat dec": "201", "Dingbat hex": "C9", "Unicode dec": "128384", "Unicode hex": "1F580" },
            { "Typeface name": "Webdings", "Dingbat dec": "202", "Dingbat hex": "CA", "Unicode dec": "128424", "Unicode hex": "1F5A8" },
            { "Typeface name": "Webdings", "Dingbat dec": "203", "Dingbat hex": "CB", "Unicode dec": "128425", "Unicode hex": "1F5A9" },
            { "Typeface name": "Webdings", "Dingbat dec": "204", "Dingbat hex": "CC", "Unicode dec": "128447", "Unicode hex": "1F5BF" },
            { "Typeface name": "Webdings", "Dingbat dec": "205", "Dingbat hex": "CD", "Unicode dec": "128426", "Unicode hex": "1F5AA" },
            { "Typeface name": "Webdings", "Dingbat dec": "206", "Dingbat hex": "CE", "Unicode dec": "128476", "Unicode hex": "1F5DC" },
            { "Typeface name": "Webdings", "Dingbat dec": "207", "Dingbat hex": "CF", "Unicode dec": "128274", "Unicode hex": "1F512" },
            { "Typeface name": "Webdings", "Dingbat dec": "208", "Dingbat hex": "D0", "Unicode dec": "128275", "Unicode hex": "1F513" },
            { "Typeface name": "Webdings", "Dingbat dec": "209", "Dingbat hex": "D1", "Unicode dec": "128477", "Unicode hex": "1F5DD" },
            { "Typeface name": "Webdings", "Dingbat dec": "210", "Dingbat hex": "D2", "Unicode dec": "128229", "Unicode hex": "1F4E5" },
            { "Typeface name": "Webdings", "Dingbat dec": "211", "Dingbat hex": "D3", "Unicode dec": "128228", "Unicode hex": "1F4E4" },
            { "Typeface name": "Webdings", "Dingbat dec": "212", "Dingbat hex": "D4", "Unicode dec": "128371", "Unicode hex": "1F573" },
            { "Typeface name": "Webdings", "Dingbat dec": "213", "Dingbat hex": "D5", "Unicode dec": "127779", "Unicode hex": "1F323" },
            { "Typeface name": "Webdings", "Dingbat dec": "214", "Dingbat hex": "D6", "Unicode dec": "127780", "Unicode hex": "1F324" },
            { "Typeface name": "Webdings", "Dingbat dec": "215", "Dingbat hex": "D7", "Unicode dec": "127781", "Unicode hex": "1F325" },
            { "Typeface name": "Webdings", "Dingbat dec": "216", "Dingbat hex": "D8", "Unicode dec": "127782", "Unicode hex": "1F326" },
            { "Typeface name": "Webdings", "Dingbat dec": "217", "Dingbat hex": "D9", "Unicode dec": "9729", "Unicode hex": "2601" },
            { "Typeface name": "Webdings", "Dingbat dec": "218", "Dingbat hex": "DA", "Unicode dec": "127784", "Unicode hex": "1F328" },
            { "Typeface name": "Webdings", "Dingbat dec": "219", "Dingbat hex": "DB", "Unicode dec": "127783", "Unicode hex": "1F327" },
            { "Typeface name": "Webdings", "Dingbat dec": "220", "Dingbat hex": "DC", "Unicode dec": "127785", "Unicode hex": "1F329" },
            { "Typeface name": "Webdings", "Dingbat dec": "221", "Dingbat hex": "DD", "Unicode dec": "127786", "Unicode hex": "1F32A" },
            { "Typeface name": "Webdings", "Dingbat dec": "222", "Dingbat hex": "DE", "Unicode dec": "127788", "Unicode hex": "1F32C" },
            { "Typeface name": "Webdings", "Dingbat dec": "223", "Dingbat hex": "DF", "Unicode dec": "127787", "Unicode hex": "1F32B" },
            { "Typeface name": "Webdings", "Dingbat dec": "224", "Dingbat hex": "E0", "Unicode dec": "127772", "Unicode hex": "1F31C" },
            { "Typeface name": "Webdings", "Dingbat dec": "225", "Dingbat hex": "E1", "Unicode dec": "127777", "Unicode hex": "1F321" },
            { "Typeface name": "Webdings", "Dingbat dec": "226", "Dingbat hex": "E2", "Unicode dec": "128715", "Unicode hex": "1F6CB" },
            { "Typeface name": "Webdings", "Dingbat dec": "227", "Dingbat hex": "E3", "Unicode dec": "128719", "Unicode hex": "1F6CF" },
            { "Typeface name": "Webdings", "Dingbat dec": "228", "Dingbat hex": "E4", "Unicode dec": "127869", "Unicode hex": "1F37D" },
            { "Typeface name": "Webdings", "Dingbat dec": "229", "Dingbat hex": "E5", "Unicode dec": "127864", "Unicode hex": "1F378" },
            { "Typeface name": "Webdings", "Dingbat dec": "230", "Dingbat hex": "E6", "Unicode dec": "128718", "Unicode hex": "1F6CE" },
            { "Typeface name": "Webdings", "Dingbat dec": "231", "Dingbat hex": "E7", "Unicode dec": "128717", "Unicode hex": "1F6CD" },
            { "Typeface name": "Webdings", "Dingbat dec": "232", "Dingbat hex": "E8", "Unicode dec": "9413", "Unicode hex": "24C5" },
            { "Typeface name": "Webdings", "Dingbat dec": "233", "Dingbat hex": "E9", "Unicode dec": "9855", "Unicode hex": "267F" },
            { "Typeface name": "Webdings", "Dingbat dec": "234", "Dingbat hex": "EA", "Unicode dec": "128710", "Unicode hex": "1F6C6" },
            { "Typeface name": "Webdings", "Dingbat dec": "235", "Dingbat hex": "EB", "Unicode dec": "128392", "Unicode hex": "1F588" },
            { "Typeface name": "Webdings", "Dingbat dec": "236", "Dingbat hex": "EC", "Unicode dec": "127891", "Unicode hex": "1F393" },
            { "Typeface name": "Webdings", "Dingbat dec": "237", "Dingbat hex": "ED", "Unicode dec": "128484", "Unicode hex": "1F5E4" },
            { "Typeface name": "Webdings", "Dingbat dec": "238", "Dingbat hex": "EE", "Unicode dec": "128485", "Unicode hex": "1F5E5" },
            { "Typeface name": "Webdings", "Dingbat dec": "239", "Dingbat hex": "EF", "Unicode dec": "128486", "Unicode hex": "1F5E6" },
            { "Typeface name": "Webdings", "Dingbat dec": "240", "Dingbat hex": "F0", "Unicode dec": "128487", "Unicode hex": "1F5E7" },
            { "Typeface name": "Webdings", "Dingbat dec": "241", "Dingbat hex": "F1", "Unicode dec": "128746", "Unicode hex": "1F6EA" },
            { "Typeface name": "Webdings", "Dingbat dec": "242", "Dingbat hex": "F2", "Unicode dec": "128063", "Unicode hex": "1F43F" },
            { "Typeface name": "Webdings", "Dingbat dec": "243", "Dingbat hex": "F3", "Unicode dec": "128038", "Unicode hex": "1F426" },
            { "Typeface name": "Webdings", "Dingbat dec": "244", "Dingbat hex": "F4", "Unicode dec": "128031", "Unicode hex": "1F41F" },
            { "Typeface name": "Webdings", "Dingbat dec": "245", "Dingbat hex": "F5", "Unicode dec": "128021", "Unicode hex": "1F415" },
            { "Typeface name": "Webdings", "Dingbat dec": "246", "Dingbat hex": "F6", "Unicode dec": "128008", "Unicode hex": "1F408" },
            { "Typeface name": "Webdings", "Dingbat dec": "247", "Dingbat hex": "F7", "Unicode dec": "128620", "Unicode hex": "1F66C" },
            { "Typeface name": "Webdings", "Dingbat dec": "248", "Dingbat hex": "F8", "Unicode dec": "128622", "Unicode hex": "1F66E" },
            { "Typeface name": "Webdings", "Dingbat dec": "249", "Dingbat hex": "F9", "Unicode dec": "128621", "Unicode hex": "1F66D" },
            { "Typeface name": "Webdings", "Dingbat dec": "250", "Dingbat hex": "FA", "Unicode dec": "128623", "Unicode hex": "1F66F" },
            { "Typeface name": "Webdings", "Dingbat dec": "251", "Dingbat hex": "FB", "Unicode dec": "128506", "Unicode hex": "1F5FA" },
            { "Typeface name": "Webdings", "Dingbat dec": "252", "Dingbat hex": "FC", "Unicode dec": "127757", "Unicode hex": "1F30D" },
            { "Typeface name": "Webdings", "Dingbat dec": "253", "Dingbat hex": "FD", "Unicode dec": "127759", "Unicode hex": "1F30F" },
            { "Typeface name": "Webdings", "Dingbat dec": "254", "Dingbat hex": "FE", "Unicode dec": "127758", "Unicode hex": "1F30E" },
            { "Typeface name": "Webdings", "Dingbat dec": "255", "Dingbat hex": "FF", "Unicode dec": "128330", "Unicode hex": "1F54A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "32", "Dingbat hex": "20", "Unicode dec": "32", "Unicode hex": "20" },
            { "Typeface name": "Wingdings", "Dingbat dec": "33", "Dingbat hex": "21", "Unicode dec": "128393", "Unicode hex": "1F589" },
            { "Typeface name": "Wingdings", "Dingbat dec": "34", "Dingbat hex": "22", "Unicode dec": "9986", "Unicode hex": "2702" },
            { "Typeface name": "Wingdings", "Dingbat dec": "35", "Dingbat hex": "23", "Unicode dec": "9985", "Unicode hex": "2701" },
            { "Typeface name": "Wingdings", "Dingbat dec": "36", "Dingbat hex": "24", "Unicode dec": "128083", "Unicode hex": "1F453" },
            { "Typeface name": "Wingdings", "Dingbat dec": "37", "Dingbat hex": "25", "Unicode dec": "128365", "Unicode hex": "1F56D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "38", "Dingbat hex": "26", "Unicode dec": "128366", "Unicode hex": "1F56E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "39", "Dingbat hex": "27", "Unicode dec": "128367", "Unicode hex": "1F56F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "40", "Dingbat hex": "28", "Unicode dec": "128383", "Unicode hex": "1F57F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "41", "Dingbat hex": "29", "Unicode dec": "9990", "Unicode hex": "2706" },
            { "Typeface name": "Wingdings", "Dingbat dec": "42", "Dingbat hex": "2A", "Unicode dec": "128386", "Unicode hex": "1F582" },
            { "Typeface name": "Wingdings", "Dingbat dec": "43", "Dingbat hex": "2B", "Unicode dec": "128387", "Unicode hex": "1F583" },
            { "Typeface name": "Wingdings", "Dingbat dec": "44", "Dingbat hex": "2C", "Unicode dec": "128234", "Unicode hex": "1F4EA" },
            { "Typeface name": "Wingdings", "Dingbat dec": "45", "Dingbat hex": "2D", "Unicode dec": "128235", "Unicode hex": "1F4EB" },
            { "Typeface name": "Wingdings", "Dingbat dec": "46", "Dingbat hex": "2E", "Unicode dec": "128236", "Unicode hex": "1F4EC" },
            { "Typeface name": "Wingdings", "Dingbat dec": "47", "Dingbat hex": "2F", "Unicode dec": "128237", "Unicode hex": "1F4ED" },
            { "Typeface name": "Wingdings", "Dingbat dec": "48", "Dingbat hex": "30", "Unicode dec": "128448", "Unicode hex": "1F5C0" },
            { "Typeface name": "Wingdings", "Dingbat dec": "49", "Dingbat hex": "31", "Unicode dec": "128449", "Unicode hex": "1F5C1" },
            { "Typeface name": "Wingdings", "Dingbat dec": "50", "Dingbat hex": "32", "Unicode dec": "128462", "Unicode hex": "1F5CE" },
            { "Typeface name": "Wingdings", "Dingbat dec": "51", "Dingbat hex": "33", "Unicode dec": "128463", "Unicode hex": "1F5CF" },
            { "Typeface name": "Wingdings", "Dingbat dec": "52", "Dingbat hex": "34", "Unicode dec": "128464", "Unicode hex": "1F5D0" },
            { "Typeface name": "Wingdings", "Dingbat dec": "53", "Dingbat hex": "35", "Unicode dec": "128452", "Unicode hex": "1F5C4" },
            { "Typeface name": "Wingdings", "Dingbat dec": "54", "Dingbat hex": "36", "Unicode dec": "8987", "Unicode hex": "231B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "55", "Dingbat hex": "37", "Unicode dec": "128430", "Unicode hex": "1F5AE" },
            { "Typeface name": "Wingdings", "Dingbat dec": "56", "Dingbat hex": "38", "Unicode dec": "128432", "Unicode hex": "1F5B0" },
            { "Typeface name": "Wingdings", "Dingbat dec": "57", "Dingbat hex": "39", "Unicode dec": "128434", "Unicode hex": "1F5B2" },
            { "Typeface name": "Wingdings", "Dingbat dec": "58", "Dingbat hex": "3A", "Unicode dec": "128435", "Unicode hex": "1F5B3" },
            { "Typeface name": "Wingdings", "Dingbat dec": "59", "Dingbat hex": "3B", "Unicode dec": "128436", "Unicode hex": "1F5B4" },
            { "Typeface name": "Wingdings", "Dingbat dec": "60", "Dingbat hex": "3C", "Unicode dec": "128427", "Unicode hex": "1F5AB" },
            { "Typeface name": "Wingdings", "Dingbat dec": "61", "Dingbat hex": "3D", "Unicode dec": "128428", "Unicode hex": "1F5AC" },
            { "Typeface name": "Wingdings", "Dingbat dec": "62", "Dingbat hex": "3E", "Unicode dec": "9991", "Unicode hex": "2707" },
            { "Typeface name": "Wingdings", "Dingbat dec": "63", "Dingbat hex": "3F", "Unicode dec": "9997", "Unicode hex": "270D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "64", "Dingbat hex": "40", "Unicode dec": "128398", "Unicode hex": "1F58E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "65", "Dingbat hex": "41", "Unicode dec": "9996", "Unicode hex": "270C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "66", "Dingbat hex": "42", "Unicode dec": "128399", "Unicode hex": "1F58F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "67", "Dingbat hex": "43", "Unicode dec": "128077", "Unicode hex": "1F44D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "68", "Dingbat hex": "44", "Unicode dec": "128078", "Unicode hex": "1F44E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "69", "Dingbat hex": "45", "Unicode dec": "9756", "Unicode hex": "261C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "70", "Dingbat hex": "46", "Unicode dec": "9758", "Unicode hex": "261E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "71", "Dingbat hex": "47", "Unicode dec": "9757", "Unicode hex": "261D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "72", "Dingbat hex": "48", "Unicode dec": "9759", "Unicode hex": "261F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "73", "Dingbat hex": "49", "Unicode dec": "128400", "Unicode hex": "1F590" },
            { "Typeface name": "Wingdings", "Dingbat dec": "74", "Dingbat hex": "4A", "Unicode dec": "9786", "Unicode hex": "263A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "75", "Dingbat hex": "4B", "Unicode dec": "128528", "Unicode hex": "1F610" },
            { "Typeface name": "Wingdings", "Dingbat dec": "76", "Dingbat hex": "4C", "Unicode dec": "9785", "Unicode hex": "2639" },
            { "Typeface name": "Wingdings", "Dingbat dec": "77", "Dingbat hex": "4D", "Unicode dec": "128163", "Unicode hex": "1F4A3" },
            { "Typeface name": "Wingdings", "Dingbat dec": "78", "Dingbat hex": "4E", "Unicode dec": "128369", "Unicode hex": "1F571" },
            { "Typeface name": "Wingdings", "Dingbat dec": "79", "Dingbat hex": "4F", "Unicode dec": "127987", "Unicode hex": "1F3F3" },
            { "Typeface name": "Wingdings", "Dingbat dec": "80", "Dingbat hex": "50", "Unicode dec": "127985", "Unicode hex": "1F3F1" },
            { "Typeface name": "Wingdings", "Dingbat dec": "81", "Dingbat hex": "51", "Unicode dec": "9992", "Unicode hex": "2708" },
            { "Typeface name": "Wingdings", "Dingbat dec": "82", "Dingbat hex": "52", "Unicode dec": "9788", "Unicode hex": "263C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "83", "Dingbat hex": "53", "Unicode dec": "127778", "Unicode hex": "1F322" },
            { "Typeface name": "Wingdings", "Dingbat dec": "84", "Dingbat hex": "54", "Unicode dec": "10052", "Unicode hex": "2744" },
            { "Typeface name": "Wingdings", "Dingbat dec": "85", "Dingbat hex": "55", "Unicode dec": "128326", "Unicode hex": "1F546" },
            { "Typeface name": "Wingdings", "Dingbat dec": "86", "Dingbat hex": "56", "Unicode dec": "10014", "Unicode hex": "271E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "87", "Dingbat hex": "57", "Unicode dec": "128328", "Unicode hex": "1F548" },
            { "Typeface name": "Wingdings", "Dingbat dec": "88", "Dingbat hex": "58", "Unicode dec": "10016", "Unicode hex": "2720" },
            { "Typeface name": "Wingdings", "Dingbat dec": "89", "Dingbat hex": "59", "Unicode dec": "10017", "Unicode hex": "2721" },
            { "Typeface name": "Wingdings", "Dingbat dec": "90", "Dingbat hex": "5A", "Unicode dec": "9770", "Unicode hex": "262A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "91", "Dingbat hex": "5B", "Unicode dec": "9775", "Unicode hex": "262F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "92", "Dingbat hex": "5C", "Unicode dec": "128329", "Unicode hex": "1F549" },
            { "Typeface name": "Wingdings", "Dingbat dec": "93", "Dingbat hex": "5D", "Unicode dec": "9784", "Unicode hex": "2638" },
            { "Typeface name": "Wingdings", "Dingbat dec": "94", "Dingbat hex": "5E", "Unicode dec": "9800", "Unicode hex": "2648" },
            { "Typeface name": "Wingdings", "Dingbat dec": "95", "Dingbat hex": "5F", "Unicode dec": "9801", "Unicode hex": "2649" },
            { "Typeface name": "Wingdings", "Dingbat dec": "96", "Dingbat hex": "60", "Unicode dec": "9802", "Unicode hex": "264A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "97", "Dingbat hex": "61", "Unicode dec": "9803", "Unicode hex": "264B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "98", "Dingbat hex": "62", "Unicode dec": "9804", "Unicode hex": "264C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "99", "Dingbat hex": "63", "Unicode dec": "9805", "Unicode hex": "264D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "100", "Dingbat hex": "64", "Unicode dec": "9806", "Unicode hex": "264E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "101", "Dingbat hex": "65", "Unicode dec": "9807", "Unicode hex": "264F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "102", "Dingbat hex": "66", "Unicode dec": "9808", "Unicode hex": "2650" },
            { "Typeface name": "Wingdings", "Dingbat dec": "103", "Dingbat hex": "67", "Unicode dec": "9809", "Unicode hex": "2651" },
            { "Typeface name": "Wingdings", "Dingbat dec": "104", "Dingbat hex": "68", "Unicode dec": "9810", "Unicode hex": "2652" },
            { "Typeface name": "Wingdings", "Dingbat dec": "105", "Dingbat hex": "69", "Unicode dec": "9811", "Unicode hex": "2653" },
            { "Typeface name": "Wingdings", "Dingbat dec": "106", "Dingbat hex": "6A", "Unicode dec": "128624", "Unicode hex": "1F670" },
            { "Typeface name": "Wingdings", "Dingbat dec": "107", "Dingbat hex": "6B", "Unicode dec": "128629", "Unicode hex": "1F675" },
            { "Typeface name": "Wingdings", "Dingbat dec": "108", "Dingbat hex": "6C", "Unicode dec": "9899", "Unicode hex": "26AB" },
            { "Typeface name": "Wingdings", "Dingbat dec": "109", "Dingbat hex": "6D", "Unicode dec": "128318", "Unicode hex": "1F53E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "110", "Dingbat hex": "6E", "Unicode dec": "9724", "Unicode hex": "25FC" },
            { "Typeface name": "Wingdings", "Dingbat dec": "111", "Dingbat hex": "6F", "Unicode dec": "128911", "Unicode hex": "1F78F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "112", "Dingbat hex": "70", "Unicode dec": "128912", "Unicode hex": "1F790" },
            { "Typeface name": "Wingdings", "Dingbat dec": "113", "Dingbat hex": "71", "Unicode dec": "10065", "Unicode hex": "2751" },
            { "Typeface name": "Wingdings", "Dingbat dec": "114", "Dingbat hex": "72", "Unicode dec": "10066", "Unicode hex": "2752" },
            { "Typeface name": "Wingdings", "Dingbat dec": "115", "Dingbat hex": "73", "Unicode dec": "128927", "Unicode hex": "1F79F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "116", "Dingbat hex": "74", "Unicode dec": "10731", "Unicode hex": "29EB" },
            { "Typeface name": "Wingdings", "Dingbat dec": "117", "Dingbat hex": "75", "Unicode dec": "9670", "Unicode hex": "25C6" },
            { "Typeface name": "Wingdings", "Dingbat dec": "118", "Dingbat hex": "76", "Unicode dec": "10070", "Unicode hex": "2756" },
            { "Typeface name": "Wingdings", "Dingbat dec": "119", "Dingbat hex": "77", "Unicode dec": "11049", "Unicode hex": "2B29" },
            { "Typeface name": "Wingdings", "Dingbat dec": "120", "Dingbat hex": "78", "Unicode dec": "8999", "Unicode hex": "2327" },
            { "Typeface name": "Wingdings", "Dingbat dec": "121", "Dingbat hex": "79", "Unicode dec": "11193", "Unicode hex": "2BB9" },
            { "Typeface name": "Wingdings", "Dingbat dec": "122", "Dingbat hex": "7A", "Unicode dec": "8984", "Unicode hex": "2318" },
            { "Typeface name": "Wingdings", "Dingbat dec": "123", "Dingbat hex": "7B", "Unicode dec": "127989", "Unicode hex": "1F3F5" },
            { "Typeface name": "Wingdings", "Dingbat dec": "124", "Dingbat hex": "7C", "Unicode dec": "127990", "Unicode hex": "1F3F6" },
            { "Typeface name": "Wingdings", "Dingbat dec": "125", "Dingbat hex": "7D", "Unicode dec": "128630", "Unicode hex": "1F676" },
            { "Typeface name": "Wingdings", "Dingbat dec": "126", "Dingbat hex": "7E", "Unicode dec": "128631", "Unicode hex": "1F677" },
            { "Typeface name": "Wingdings", "Dingbat dec": "127", "Dingbat hex": "7F", "Unicode dec": "9647", "Unicode hex": "25AF" },
            { "Typeface name": "Wingdings", "Dingbat dec": "128", "Dingbat hex": "80", "Unicode dec": "127243", "Unicode hex": "1F10B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "129", "Dingbat hex": "81", "Unicode dec": "10112", "Unicode hex": "2780" },
            { "Typeface name": "Wingdings", "Dingbat dec": "130", "Dingbat hex": "82", "Unicode dec": "10113", "Unicode hex": "2781" },
            { "Typeface name": "Wingdings", "Dingbat dec": "131", "Dingbat hex": "83", "Unicode dec": "10114", "Unicode hex": "2782" },
            { "Typeface name": "Wingdings", "Dingbat dec": "132", "Dingbat hex": "84", "Unicode dec": "10115", "Unicode hex": "2783" },
            { "Typeface name": "Wingdings", "Dingbat dec": "133", "Dingbat hex": "85", "Unicode dec": "10116", "Unicode hex": "2784" },
            { "Typeface name": "Wingdings", "Dingbat dec": "134", "Dingbat hex": "86", "Unicode dec": "10117", "Unicode hex": "2785" },
            { "Typeface name": "Wingdings", "Dingbat dec": "135", "Dingbat hex": "87", "Unicode dec": "10118", "Unicode hex": "2786" },
            { "Typeface name": "Wingdings", "Dingbat dec": "136", "Dingbat hex": "88", "Unicode dec": "10119", "Unicode hex": "2787" },
            { "Typeface name": "Wingdings", "Dingbat dec": "137", "Dingbat hex": "89", "Unicode dec": "10120", "Unicode hex": "2788" },
            { "Typeface name": "Wingdings", "Dingbat dec": "138", "Dingbat hex": "8A", "Unicode dec": "10121", "Unicode hex": "2789" },
            { "Typeface name": "Wingdings", "Dingbat dec": "139", "Dingbat hex": "8B", "Unicode dec": "127244", "Unicode hex": "1F10C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "140", "Dingbat hex": "8C", "Unicode dec": "10122", "Unicode hex": "278A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "141", "Dingbat hex": "8D", "Unicode dec": "10123", "Unicode hex": "278B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "142", "Dingbat hex": "8E", "Unicode dec": "10124", "Unicode hex": "278C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "143", "Dingbat hex": "8F", "Unicode dec": "10125", "Unicode hex": "278D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "144", "Dingbat hex": "90", "Unicode dec": "10126", "Unicode hex": "278E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "145", "Dingbat hex": "91", "Unicode dec": "10127", "Unicode hex": "278F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "146", "Dingbat hex": "92", "Unicode dec": "10128", "Unicode hex": "2790" },
            { "Typeface name": "Wingdings", "Dingbat dec": "147", "Dingbat hex": "93", "Unicode dec": "10129", "Unicode hex": "2791" },
            { "Typeface name": "Wingdings", "Dingbat dec": "148", "Dingbat hex": "94", "Unicode dec": "10130", "Unicode hex": "2792" },
            { "Typeface name": "Wingdings", "Dingbat dec": "149", "Dingbat hex": "95", "Unicode dec": "10131", "Unicode hex": "2793" },
            { "Typeface name": "Wingdings", "Dingbat dec": "150", "Dingbat hex": "96", "Unicode dec": "128610", "Unicode hex": "1F662" },
            { "Typeface name": "Wingdings", "Dingbat dec": "151", "Dingbat hex": "97", "Unicode dec": "128608", "Unicode hex": "1F660" },
            { "Typeface name": "Wingdings", "Dingbat dec": "152", "Dingbat hex": "98", "Unicode dec": "128609", "Unicode hex": "1F661" },
            { "Typeface name": "Wingdings", "Dingbat dec": "153", "Dingbat hex": "99", "Unicode dec": "128611", "Unicode hex": "1F663" },
            { "Typeface name": "Wingdings", "Dingbat dec": "154", "Dingbat hex": "9A", "Unicode dec": "128606", "Unicode hex": "1F65E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "155", "Dingbat hex": "9B", "Unicode dec": "128604", "Unicode hex": "1F65C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "156", "Dingbat hex": "9C", "Unicode dec": "128605", "Unicode hex": "1F65D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "157", "Dingbat hex": "9D", "Unicode dec": "128607", "Unicode hex": "1F65F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "158", "Dingbat hex": "9E", "Unicode dec": "8729", "Unicode hex": "2219" },
            { "Typeface name": "Wingdings", "Dingbat dec": "159", "Dingbat hex": "9F", "Unicode dec": "8226", "Unicode hex": "2022" },
            { "Typeface name": "Wingdings", "Dingbat dec": "160", "Dingbat hex": "A0", "Unicode dec": "11037", "Unicode hex": "2B1D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "161", "Dingbat hex": "A1", "Unicode dec": "11096", "Unicode hex": "2B58" },
            { "Typeface name": "Wingdings", "Dingbat dec": "162", "Dingbat hex": "A2", "Unicode dec": "128902", "Unicode hex": "1F786" },
            { "Typeface name": "Wingdings", "Dingbat dec": "163", "Dingbat hex": "A3", "Unicode dec": "128904", "Unicode hex": "1F788" },
            { "Typeface name": "Wingdings", "Dingbat dec": "164", "Dingbat hex": "A4", "Unicode dec": "128906", "Unicode hex": "1F78A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "165", "Dingbat hex": "A5", "Unicode dec": "128907", "Unicode hex": "1F78B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "166", "Dingbat hex": "A6", "Unicode dec": "128319", "Unicode hex": "1F53F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "167", "Dingbat hex": "A7", "Unicode dec": "9642", "Unicode hex": "25AA" },
            { "Typeface name": "Wingdings", "Dingbat dec": "168", "Dingbat hex": "A8", "Unicode dec": "128910", "Unicode hex": "1F78E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "169", "Dingbat hex": "A9", "Unicode dec": "128961", "Unicode hex": "1F7C1" },
            { "Typeface name": "Wingdings", "Dingbat dec": "170", "Dingbat hex": "AA", "Unicode dec": "128965", "Unicode hex": "1F7C5" },
            { "Typeface name": "Wingdings", "Dingbat dec": "171", "Dingbat hex": "AB", "Unicode dec": "9733", "Unicode hex": "2605" },
            { "Typeface name": "Wingdings", "Dingbat dec": "172", "Dingbat hex": "AC", "Unicode dec": "128971", "Unicode hex": "1F7CB" },
            { "Typeface name": "Wingdings", "Dingbat dec": "173", "Dingbat hex": "AD", "Unicode dec": "128975", "Unicode hex": "1F7CF" },
            { "Typeface name": "Wingdings", "Dingbat dec": "174", "Dingbat hex": "AE", "Unicode dec": "128979", "Unicode hex": "1F7D3" },
            { "Typeface name": "Wingdings", "Dingbat dec": "175", "Dingbat hex": "AF", "Unicode dec": "128977", "Unicode hex": "1F7D1" },
            { "Typeface name": "Wingdings", "Dingbat dec": "176", "Dingbat hex": "B0", "Unicode dec": "11216", "Unicode hex": "2BD0" },
            { "Typeface name": "Wingdings", "Dingbat dec": "177", "Dingbat hex": "B1", "Unicode dec": "8982", "Unicode hex": "2316" },
            { "Typeface name": "Wingdings", "Dingbat dec": "178", "Dingbat hex": "B2", "Unicode dec": "11214", "Unicode hex": "2BCE" },
            { "Typeface name": "Wingdings", "Dingbat dec": "179", "Dingbat hex": "B3", "Unicode dec": "11215", "Unicode hex": "2BCF" },
            { "Typeface name": "Wingdings", "Dingbat dec": "180", "Dingbat hex": "B4", "Unicode dec": "11217", "Unicode hex": "2BD1" },
            { "Typeface name": "Wingdings", "Dingbat dec": "181", "Dingbat hex": "B5", "Unicode dec": "10026", "Unicode hex": "272A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "182", "Dingbat hex": "B6", "Unicode dec": "10032", "Unicode hex": "2730" },
            { "Typeface name": "Wingdings", "Dingbat dec": "183", "Dingbat hex": "B7", "Unicode dec": "128336", "Unicode hex": "1F550" },
            { "Typeface name": "Wingdings", "Dingbat dec": "184", "Dingbat hex": "B8", "Unicode dec": "128337", "Unicode hex": "1F551" },
            { "Typeface name": "Wingdings", "Dingbat dec": "185", "Dingbat hex": "B9", "Unicode dec": "128338", "Unicode hex": "1F552" },
            { "Typeface name": "Wingdings", "Dingbat dec": "186", "Dingbat hex": "BA", "Unicode dec": "128339", "Unicode hex": "1F553" },
            { "Typeface name": "Wingdings", "Dingbat dec": "187", "Dingbat hex": "BB", "Unicode dec": "128340", "Unicode hex": "1F554" },
            { "Typeface name": "Wingdings", "Dingbat dec": "188", "Dingbat hex": "BC", "Unicode dec": "128341", "Unicode hex": "1F555" },
            { "Typeface name": "Wingdings", "Dingbat dec": "189", "Dingbat hex": "BD", "Unicode dec": "128342", "Unicode hex": "1F556" },
            { "Typeface name": "Wingdings", "Dingbat dec": "190", "Dingbat hex": "BE", "Unicode dec": "128343", "Unicode hex": "1F557" },
            { "Typeface name": "Wingdings", "Dingbat dec": "191", "Dingbat hex": "BF", "Unicode dec": "128344", "Unicode hex": "1F558" },
            { "Typeface name": "Wingdings", "Dingbat dec": "192", "Dingbat hex": "C0", "Unicode dec": "128345", "Unicode hex": "1F559" },
            { "Typeface name": "Wingdings", "Dingbat dec": "193", "Dingbat hex": "C1", "Unicode dec": "128346", "Unicode hex": "1F55A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "194", "Dingbat hex": "C2", "Unicode dec": "128347", "Unicode hex": "1F55B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "195", "Dingbat hex": "C3", "Unicode dec": "11184", "Unicode hex": "2BB0" },
            { "Typeface name": "Wingdings", "Dingbat dec": "196", "Dingbat hex": "C4", "Unicode dec": "11185", "Unicode hex": "2BB1" },
            { "Typeface name": "Wingdings", "Dingbat dec": "197", "Dingbat hex": "C5", "Unicode dec": "11186", "Unicode hex": "2BB2" },
            { "Typeface name": "Wingdings", "Dingbat dec": "198", "Dingbat hex": "C6", "Unicode dec": "11187", "Unicode hex": "2BB3" },
            { "Typeface name": "Wingdings", "Dingbat dec": "199", "Dingbat hex": "C7", "Unicode dec": "11188", "Unicode hex": "2BB4" },
            { "Typeface name": "Wingdings", "Dingbat dec": "200", "Dingbat hex": "C8", "Unicode dec": "11189", "Unicode hex": "2BB5" },
            { "Typeface name": "Wingdings", "Dingbat dec": "201", "Dingbat hex": "C9", "Unicode dec": "11190", "Unicode hex": "2BB6" },
            { "Typeface name": "Wingdings", "Dingbat dec": "202", "Dingbat hex": "CA", "Unicode dec": "11191", "Unicode hex": "2BB7" },
            { "Typeface name": "Wingdings", "Dingbat dec": "203", "Dingbat hex": "CB", "Unicode dec": "128618", "Unicode hex": "1F66A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "204", "Dingbat hex": "CC", "Unicode dec": "128619", "Unicode hex": "1F66B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "205", "Dingbat hex": "CD", "Unicode dec": "128597", "Unicode hex": "1F655" },
            { "Typeface name": "Wingdings", "Dingbat dec": "206", "Dingbat hex": "CE", "Unicode dec": "128596", "Unicode hex": "1F654" },
            { "Typeface name": "Wingdings", "Dingbat dec": "207", "Dingbat hex": "CF", "Unicode dec": "128599", "Unicode hex": "1F657" },
            { "Typeface name": "Wingdings", "Dingbat dec": "208", "Dingbat hex": "D0", "Unicode dec": "128598", "Unicode hex": "1F656" },
            { "Typeface name": "Wingdings", "Dingbat dec": "209", "Dingbat hex": "D1", "Unicode dec": "128592", "Unicode hex": "1F650" },
            { "Typeface name": "Wingdings", "Dingbat dec": "210", "Dingbat hex": "D2", "Unicode dec": "128593", "Unicode hex": "1F651" },
            { "Typeface name": "Wingdings", "Dingbat dec": "211", "Dingbat hex": "D3", "Unicode dec": "128594", "Unicode hex": "1F652" },
            { "Typeface name": "Wingdings", "Dingbat dec": "212", "Dingbat hex": "D4", "Unicode dec": "128595", "Unicode hex": "1F653" },
            { "Typeface name": "Wingdings", "Dingbat dec": "213", "Dingbat hex": "D5", "Unicode dec": "9003", "Unicode hex": "232B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "214", "Dingbat hex": "D6", "Unicode dec": "8998", "Unicode hex": "2326" },
            { "Typeface name": "Wingdings", "Dingbat dec": "215", "Dingbat hex": "D7", "Unicode dec": "11160", "Unicode hex": "2B98" },
            { "Typeface name": "Wingdings", "Dingbat dec": "216", "Dingbat hex": "D8", "Unicode dec": "11162", "Unicode hex": "2B9A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "217", "Dingbat hex": "D9", "Unicode dec": "11161", "Unicode hex": "2B99" },
            { "Typeface name": "Wingdings", "Dingbat dec": "218", "Dingbat hex": "DA", "Unicode dec": "11163", "Unicode hex": "2B9B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "219", "Dingbat hex": "DB", "Unicode dec": "11144", "Unicode hex": "2B88" },
            { "Typeface name": "Wingdings", "Dingbat dec": "220", "Dingbat hex": "DC", "Unicode dec": "11146", "Unicode hex": "2B8A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "221", "Dingbat hex": "DD", "Unicode dec": "11145", "Unicode hex": "2B89" },
            { "Typeface name": "Wingdings", "Dingbat dec": "222", "Dingbat hex": "DE", "Unicode dec": "11147", "Unicode hex": "2B8B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "223", "Dingbat hex": "DF", "Unicode dec": "129128", "Unicode hex": "1F868" },
            { "Typeface name": "Wingdings", "Dingbat dec": "224", "Dingbat hex": "E0", "Unicode dec": "129130", "Unicode hex": "1F86A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "225", "Dingbat hex": "E1", "Unicode dec": "129129", "Unicode hex": "1F869" },
            { "Typeface name": "Wingdings", "Dingbat dec": "226", "Dingbat hex": "E2", "Unicode dec": "129131", "Unicode hex": "1F86B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "227", "Dingbat hex": "E3", "Unicode dec": "129132", "Unicode hex": "1F86C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "228", "Dingbat hex": "E4", "Unicode dec": "129133", "Unicode hex": "1F86D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "229", "Dingbat hex": "E5", "Unicode dec": "129135", "Unicode hex": "1F86F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "230", "Dingbat hex": "E6", "Unicode dec": "129134", "Unicode hex": "1F86E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "231", "Dingbat hex": "E7", "Unicode dec": "129144", "Unicode hex": "1F878" },
            { "Typeface name": "Wingdings", "Dingbat dec": "232", "Dingbat hex": "E8", "Unicode dec": "129146", "Unicode hex": "1F87A" },
            { "Typeface name": "Wingdings", "Dingbat dec": "233", "Dingbat hex": "E9", "Unicode dec": "129145", "Unicode hex": "1F879" },
            { "Typeface name": "Wingdings", "Dingbat dec": "234", "Dingbat hex": "EA", "Unicode dec": "129147", "Unicode hex": "1F87B" },
            { "Typeface name": "Wingdings", "Dingbat dec": "235", "Dingbat hex": "EB", "Unicode dec": "129148", "Unicode hex": "1F87C" },
            { "Typeface name": "Wingdings", "Dingbat dec": "236", "Dingbat hex": "EC", "Unicode dec": "129149", "Unicode hex": "1F87D" },
            { "Typeface name": "Wingdings", "Dingbat dec": "237", "Dingbat hex": "ED", "Unicode dec": "129151", "Unicode hex": "1F87F" },
            { "Typeface name": "Wingdings", "Dingbat dec": "238", "Dingbat hex": "EE", "Unicode dec": "129150", "Unicode hex": "1F87E" },
            { "Typeface name": "Wingdings", "Dingbat dec": "239", "Dingbat hex": "EF", "Unicode dec": "8678", "Unicode hex": "21E6" },
            { "Typeface name": "Wingdings", "Dingbat dec": "240", "Dingbat hex": "F0", "Unicode dec": "8680", "Unicode hex": "21E8" },
            { "Typeface name": "Wingdings", "Dingbat dec": "241", "Dingbat hex": "F1", "Unicode dec": "8679", "Unicode hex": "21E7" },
            { "Typeface name": "Wingdings", "Dingbat dec": "242", "Dingbat hex": "F2", "Unicode dec": "8681", "Unicode hex": "21E9" },
            { "Typeface name": "Wingdings", "Dingbat dec": "243", "Dingbat hex": "F3", "Unicode dec": "11012", "Unicode hex": "2B04" },
            { "Typeface name": "Wingdings", "Dingbat dec": "244", "Dingbat hex": "F4", "Unicode dec": "8691", "Unicode hex": "21F3" },
            { "Typeface name": "Wingdings", "Dingbat dec": "245", "Dingbat hex": "F5", "Unicode dec": "11009", "Unicode hex": "2B01" },
            { "Typeface name": "Wingdings", "Dingbat dec": "246", "Dingbat hex": "F6", "Unicode dec": "11008", "Unicode hex": "2B00" },
            { "Typeface name": "Wingdings", "Dingbat dec": "247", "Dingbat hex": "F7", "Unicode dec": "11011", "Unicode hex": "2B03" },
            { "Typeface name": "Wingdings", "Dingbat dec": "248", "Dingbat hex": "F8", "Unicode dec": "11010", "Unicode hex": "2B02" },
            { "Typeface name": "Wingdings", "Dingbat dec": "249", "Dingbat hex": "F9", "Unicode dec": "129196", "Unicode hex": "1F8AC" },
            { "Typeface name": "Wingdings", "Dingbat dec": "250", "Dingbat hex": "FA", "Unicode dec": "129197", "Unicode hex": "1F8AD" },
            { "Typeface name": "Wingdings", "Dingbat dec": "251", "Dingbat hex": "FB", "Unicode dec": "128502", "Unicode hex": "1F5F6" },
            { "Typeface name": "Wingdings", "Dingbat dec": "252", "Dingbat hex": "FC", "Unicode dec": "10003", "Unicode hex": "2713" },
            { "Typeface name": "Wingdings", "Dingbat dec": "253", "Dingbat hex": "FD", "Unicode dec": "128503", "Unicode hex": "1F5F7" },
            { "Typeface name": "Wingdings", "Dingbat dec": "254", "Dingbat hex": "FE", "Unicode dec": "128505", "Unicode hex": "1F5F9" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "32", "Dingbat hex": "20", "Unicode dec": "32", "Unicode hex": "20" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "33", "Dingbat hex": "21", "Unicode dec": "128394", "Unicode hex": "1F58A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "34", "Dingbat hex": "22", "Unicode dec": "128395", "Unicode hex": "1F58B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "35", "Dingbat hex": "23", "Unicode dec": "128396", "Unicode hex": "1F58C" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "36", "Dingbat hex": "24", "Unicode dec": "128397", "Unicode hex": "1F58D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "37", "Dingbat hex": "25", "Unicode dec": "9988", "Unicode hex": "2704" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "38", "Dingbat hex": "26", "Unicode dec": "9984", "Unicode hex": "2700" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "39", "Dingbat hex": "27", "Unicode dec": "128382", "Unicode hex": "1F57E" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "40", "Dingbat hex": "28", "Unicode dec": "128381", "Unicode hex": "1F57D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "41", "Dingbat hex": "29", "Unicode dec": "128453", "Unicode hex": "1F5C5" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "42", "Dingbat hex": "2A", "Unicode dec": "128454", "Unicode hex": "1F5C6" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "43", "Dingbat hex": "2B", "Unicode dec": "128455", "Unicode hex": "1F5C7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "44", "Dingbat hex": "2C", "Unicode dec": "128456", "Unicode hex": "1F5C8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "45", "Dingbat hex": "2D", "Unicode dec": "128457", "Unicode hex": "1F5C9" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "46", "Dingbat hex": "2E", "Unicode dec": "128458", "Unicode hex": "1F5CA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "47", "Dingbat hex": "2F", "Unicode dec": "128459", "Unicode hex": "1F5CB" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "48", "Dingbat hex": "30", "Unicode dec": "128460", "Unicode hex": "1F5CC" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "49", "Dingbat hex": "31", "Unicode dec": "128461", "Unicode hex": "1F5CD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "50", "Dingbat hex": "32", "Unicode dec": "128203", "Unicode hex": "1F4CB" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "51", "Dingbat hex": "33", "Unicode dec": "128465", "Unicode hex": "1F5D1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "52", "Dingbat hex": "34", "Unicode dec": "128468", "Unicode hex": "1F5D4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "53", "Dingbat hex": "35", "Unicode dec": "128437", "Unicode hex": "1F5B5" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "54", "Dingbat hex": "36", "Unicode dec": "128438", "Unicode hex": "1F5B6" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "55", "Dingbat hex": "37", "Unicode dec": "128439", "Unicode hex": "1F5B7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "56", "Dingbat hex": "38", "Unicode dec": "128440", "Unicode hex": "1F5B8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "57", "Dingbat hex": "39", "Unicode dec": "128429", "Unicode hex": "1F5AD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "58", "Dingbat hex": "3A", "Unicode dec": "128431", "Unicode hex": "1F5AF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "59", "Dingbat hex": "3B", "Unicode dec": "128433", "Unicode hex": "1F5B1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "60", "Dingbat hex": "3C", "Unicode dec": "128402", "Unicode hex": "1F592" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "61", "Dingbat hex": "3D", "Unicode dec": "128403", "Unicode hex": "1F593" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "62", "Dingbat hex": "3E", "Unicode dec": "128408", "Unicode hex": "1F598" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "63", "Dingbat hex": "3F", "Unicode dec": "128409", "Unicode hex": "1F599" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "64", "Dingbat hex": "40", "Unicode dec": "128410", "Unicode hex": "1F59A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "65", "Dingbat hex": "41", "Unicode dec": "128411", "Unicode hex": "1F59B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "66", "Dingbat hex": "42", "Unicode dec": "128072", "Unicode hex": "1F448" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "67", "Dingbat hex": "43", "Unicode dec": "128073", "Unicode hex": "1F449" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "68", "Dingbat hex": "44", "Unicode dec": "128412", "Unicode hex": "1F59C" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "69", "Dingbat hex": "45", "Unicode dec": "128413", "Unicode hex": "1F59D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "70", "Dingbat hex": "46", "Unicode dec": "128414", "Unicode hex": "1F59E" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "71", "Dingbat hex": "47", "Unicode dec": "128415", "Unicode hex": "1F59F" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "72", "Dingbat hex": "48", "Unicode dec": "128416", "Unicode hex": "1F5A0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "73", "Dingbat hex": "49", "Unicode dec": "128417", "Unicode hex": "1F5A1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "74", "Dingbat hex": "4A", "Unicode dec": "128070", "Unicode hex": "1F446" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "75", "Dingbat hex": "4B", "Unicode dec": "128071", "Unicode hex": "1F447" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "76", "Dingbat hex": "4C", "Unicode dec": "128418", "Unicode hex": "1F5A2" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "77", "Dingbat hex": "4D", "Unicode dec": "128419", "Unicode hex": "1F5A3" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "78", "Dingbat hex": "4E", "Unicode dec": "128401", "Unicode hex": "1F591" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "79", "Dingbat hex": "4F", "Unicode dec": "128500", "Unicode hex": "1F5F4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "80", "Dingbat hex": "50", "Unicode dec": "128504", "Unicode hex": "1F5F8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "81", "Dingbat hex": "51", "Unicode dec": "128501", "Unicode hex": "1F5F5" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "82", "Dingbat hex": "52", "Unicode dec": "9745", "Unicode hex": "2611" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "83", "Dingbat hex": "53", "Unicode dec": "11197", "Unicode hex": "2BBD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "84", "Dingbat hex": "54", "Unicode dec": "9746", "Unicode hex": "2612" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "85", "Dingbat hex": "55", "Unicode dec": "11198", "Unicode hex": "2BBE" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "86", "Dingbat hex": "56", "Unicode dec": "11199", "Unicode hex": "2BBF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "87", "Dingbat hex": "57", "Unicode dec": "128711", "Unicode hex": "1F6C7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "88", "Dingbat hex": "58", "Unicode dec": "10680", "Unicode hex": "29B8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "89", "Dingbat hex": "59", "Unicode dec": "128625", "Unicode hex": "1F671" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "90", "Dingbat hex": "5A", "Unicode dec": "128628", "Unicode hex": "1F674" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "91", "Dingbat hex": "5B", "Unicode dec": "128626", "Unicode hex": "1F672" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "92", "Dingbat hex": "5C", "Unicode dec": "128627", "Unicode hex": "1F673" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "93", "Dingbat hex": "5D", "Unicode dec": "8253", "Unicode hex": "203D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "94", "Dingbat hex": "5E", "Unicode dec": "128633", "Unicode hex": "1F679" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "95", "Dingbat hex": "5F", "Unicode dec": "128634", "Unicode hex": "1F67A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "96", "Dingbat hex": "60", "Unicode dec": "128635", "Unicode hex": "1F67B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "97", "Dingbat hex": "61", "Unicode dec": "128614", "Unicode hex": "1F666" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "98", "Dingbat hex": "62", "Unicode dec": "128612", "Unicode hex": "1F664" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "99", "Dingbat hex": "63", "Unicode dec": "128613", "Unicode hex": "1F665" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "100", "Dingbat hex": "64", "Unicode dec": "128615", "Unicode hex": "1F667" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "101", "Dingbat hex": "65", "Unicode dec": "128602", "Unicode hex": "1F65A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "102", "Dingbat hex": "66", "Unicode dec": "128600", "Unicode hex": "1F658" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "103", "Dingbat hex": "67", "Unicode dec": "128601", "Unicode hex": "1F659" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "104", "Dingbat hex": "68", "Unicode dec": "128603", "Unicode hex": "1F65B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "105", "Dingbat hex": "69", "Unicode dec": "9450", "Unicode hex": "24EA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "106", "Dingbat hex": "6A", "Unicode dec": "9312", "Unicode hex": "2460" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "107", "Dingbat hex": "6B", "Unicode dec": "9313", "Unicode hex": "2461" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "108", "Dingbat hex": "6C", "Unicode dec": "9314", "Unicode hex": "2462" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "109", "Dingbat hex": "6D", "Unicode dec": "9315", "Unicode hex": "2463" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "110", "Dingbat hex": "6E", "Unicode dec": "9316", "Unicode hex": "2464" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "111", "Dingbat hex": "6F", "Unicode dec": "9317", "Unicode hex": "2465" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "112", "Dingbat hex": "70", "Unicode dec": "9318", "Unicode hex": "2466" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "113", "Dingbat hex": "71", "Unicode dec": "9319", "Unicode hex": "2467" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "114", "Dingbat hex": "72", "Unicode dec": "9320", "Unicode hex": "2468" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "115", "Dingbat hex": "73", "Unicode dec": "9321", "Unicode hex": "2469" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "116", "Dingbat hex": "74", "Unicode dec": "9471", "Unicode hex": "24FF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "117", "Dingbat hex": "75", "Unicode dec": "10102", "Unicode hex": "2776" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "118", "Dingbat hex": "76", "Unicode dec": "10103", "Unicode hex": "2777" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "119", "Dingbat hex": "77", "Unicode dec": "10104", "Unicode hex": "2778" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "120", "Dingbat hex": "78", "Unicode dec": "10105", "Unicode hex": "2779" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "121", "Dingbat hex": "79", "Unicode dec": "10106", "Unicode hex": "277A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "122", "Dingbat hex": "7A", "Unicode dec": "10107", "Unicode hex": "277B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "123", "Dingbat hex": "7B", "Unicode dec": "10108", "Unicode hex": "277C" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "124", "Dingbat hex": "7C", "Unicode dec": "10109", "Unicode hex": "277D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "125", "Dingbat hex": "7D", "Unicode dec": "10110", "Unicode hex": "277E" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "126", "Dingbat hex": "7E", "Unicode dec": "10111", "Unicode hex": "277F" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "128", "Dingbat hex": "80", "Unicode dec": "9737", "Unicode hex": "2609" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "129", "Dingbat hex": "81", "Unicode dec": "127765", "Unicode hex": "1F315" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "130", "Dingbat hex": "82", "Unicode dec": "9789", "Unicode hex": "263D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "131", "Dingbat hex": "83", "Unicode dec": "9790", "Unicode hex": "263E" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "132", "Dingbat hex": "84", "Unicode dec": "11839", "Unicode hex": "2E3F" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "133", "Dingbat hex": "85", "Unicode dec": "10013", "Unicode hex": "271D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "134", "Dingbat hex": "86", "Unicode dec": "128327", "Unicode hex": "1F547" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "135", "Dingbat hex": "87", "Unicode dec": "128348", "Unicode hex": "1F55C" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "136", "Dingbat hex": "88", "Unicode dec": "128349", "Unicode hex": "1F55D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "137", "Dingbat hex": "89", "Unicode dec": "128350", "Unicode hex": "1F55E" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "138", "Dingbat hex": "8A", "Unicode dec": "128351", "Unicode hex": "1F55F" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "139", "Dingbat hex": "8B", "Unicode dec": "128352", "Unicode hex": "1F560" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "140", "Dingbat hex": "8C", "Unicode dec": "128353", "Unicode hex": "1F561" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "141", "Dingbat hex": "8D", "Unicode dec": "128354", "Unicode hex": "1F562" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "142", "Dingbat hex": "8E", "Unicode dec": "128355", "Unicode hex": "1F563" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "143", "Dingbat hex": "8F", "Unicode dec": "128356", "Unicode hex": "1F564" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "144", "Dingbat hex": "90", "Unicode dec": "128357", "Unicode hex": "1F565" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "145", "Dingbat hex": "91", "Unicode dec": "128358", "Unicode hex": "1F566" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "146", "Dingbat hex": "92", "Unicode dec": "128359", "Unicode hex": "1F567" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "147", "Dingbat hex": "93", "Unicode dec": "128616", "Unicode hex": "1F668" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "148", "Dingbat hex": "94", "Unicode dec": "128617", "Unicode hex": "1F669" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "149", "Dingbat hex": "95", "Unicode dec": "8901", "Unicode hex": "22C5" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "150", "Dingbat hex": "96", "Unicode dec": "128900", "Unicode hex": "1F784" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "151", "Dingbat hex": "97", "Unicode dec": "10625", "Unicode hex": "2981" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "152", "Dingbat hex": "98", "Unicode dec": "9679", "Unicode hex": "25CF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "153", "Dingbat hex": "99", "Unicode dec": "9675", "Unicode hex": "25CB" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "154", "Dingbat hex": "9A", "Unicode dec": "128901", "Unicode hex": "1F785" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "155", "Dingbat hex": "9B", "Unicode dec": "128903", "Unicode hex": "1F787" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "156", "Dingbat hex": "9C", "Unicode dec": "128905", "Unicode hex": "1F789" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "157", "Dingbat hex": "9D", "Unicode dec": "8857", "Unicode hex": "2299" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "158", "Dingbat hex": "9E", "Unicode dec": "10687", "Unicode hex": "29BF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "159", "Dingbat hex": "9F", "Unicode dec": "128908", "Unicode hex": "1F78C" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "160", "Dingbat hex": "A0", "Unicode dec": "128909", "Unicode hex": "1F78D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "161", "Dingbat hex": "A1", "Unicode dec": "9726", "Unicode hex": "25FE" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "162", "Dingbat hex": "A2", "Unicode dec": "9632", "Unicode hex": "25A0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "163", "Dingbat hex": "A3", "Unicode dec": "9633", "Unicode hex": "25A1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "164", "Dingbat hex": "A4", "Unicode dec": "128913", "Unicode hex": "1F791" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "165", "Dingbat hex": "A5", "Unicode dec": "128914", "Unicode hex": "1F792" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "166", "Dingbat hex": "A6", "Unicode dec": "128915", "Unicode hex": "1F793" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "167", "Dingbat hex": "A7", "Unicode dec": "128916", "Unicode hex": "1F794" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "168", "Dingbat hex": "A8", "Unicode dec": "9635", "Unicode hex": "25A3" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "169", "Dingbat hex": "A9", "Unicode dec": "128917", "Unicode hex": "1F795" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "170", "Dingbat hex": "AA", "Unicode dec": "128918", "Unicode hex": "1F796" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "171", "Dingbat hex": "AB", "Unicode dec": "128919", "Unicode hex": "1F797" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "172", "Dingbat hex": "AC", "Unicode dec": "128920", "Unicode hex": "1F798" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "173", "Dingbat hex": "AD", "Unicode dec": "11049", "Unicode hex": "2B29" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "174", "Dingbat hex": "AE", "Unicode dec": "11045", "Unicode hex": "2B25" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "175", "Dingbat hex": "AF", "Unicode dec": "9671", "Unicode hex": "25C7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "176", "Dingbat hex": "B0", "Unicode dec": "128922", "Unicode hex": "1F79A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "177", "Dingbat hex": "B1", "Unicode dec": "9672", "Unicode hex": "25C8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "178", "Dingbat hex": "B2", "Unicode dec": "128923", "Unicode hex": "1F79B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "179", "Dingbat hex": "B3", "Unicode dec": "128924", "Unicode hex": "1F79C" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "180", "Dingbat hex": "B4", "Unicode dec": "128925", "Unicode hex": "1F79D" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "181", "Dingbat hex": "B5", "Unicode dec": "128926", "Unicode hex": "1F79E" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "182", "Dingbat hex": "B6", "Unicode dec": "11050", "Unicode hex": "2B2A" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "183", "Dingbat hex": "B7", "Unicode dec": "11047", "Unicode hex": "2B27" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "184", "Dingbat hex": "B8", "Unicode dec": "9674", "Unicode hex": "25CA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "185", "Dingbat hex": "B9", "Unicode dec": "128928", "Unicode hex": "1F7A0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "186", "Dingbat hex": "BA", "Unicode dec": "9686", "Unicode hex": "25D6" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "187", "Dingbat hex": "BB", "Unicode dec": "9687", "Unicode hex": "25D7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "188", "Dingbat hex": "BC", "Unicode dec": "11210", "Unicode hex": "2BCA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "189", "Dingbat hex": "BD", "Unicode dec": "11211", "Unicode hex": "2BCB" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "190", "Dingbat hex": "BE", "Unicode dec": "11200", "Unicode hex": "2BC0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "191", "Dingbat hex": "BF", "Unicode dec": "11201", "Unicode hex": "2BC1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "192", "Dingbat hex": "C0", "Unicode dec": "11039", "Unicode hex": "2B1F" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "193", "Dingbat hex": "C1", "Unicode dec": "11202", "Unicode hex": "2BC2" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "194", "Dingbat hex": "C2", "Unicode dec": "11043", "Unicode hex": "2B23" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "195", "Dingbat hex": "C3", "Unicode dec": "11042", "Unicode hex": "2B22" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "196", "Dingbat hex": "C4", "Unicode dec": "11203", "Unicode hex": "2BC3" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "197", "Dingbat hex": "C5", "Unicode dec": "11204", "Unicode hex": "2BC4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "198", "Dingbat hex": "C6", "Unicode dec": "128929", "Unicode hex": "1F7A1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "199", "Dingbat hex": "C7", "Unicode dec": "128930", "Unicode hex": "1F7A2" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "200", "Dingbat hex": "C8", "Unicode dec": "128931", "Unicode hex": "1F7A3" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "201", "Dingbat hex": "C9", "Unicode dec": "128932", "Unicode hex": "1F7A4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "202", "Dingbat hex": "CA", "Unicode dec": "128933", "Unicode hex": "1F7A5" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "203", "Dingbat hex": "CB", "Unicode dec": "128934", "Unicode hex": "1F7A6" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "204", "Dingbat hex": "CC", "Unicode dec": "128935", "Unicode hex": "1F7A7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "205", "Dingbat hex": "CD", "Unicode dec": "128936", "Unicode hex": "1F7A8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "206", "Dingbat hex": "CE", "Unicode dec": "128937", "Unicode hex": "1F7A9" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "207", "Dingbat hex": "CF", "Unicode dec": "128938", "Unicode hex": "1F7AA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "208", "Dingbat hex": "D0", "Unicode dec": "128939", "Unicode hex": "1F7AB" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "209", "Dingbat hex": "D1", "Unicode dec": "128940", "Unicode hex": "1F7AC" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "210", "Dingbat hex": "D2", "Unicode dec": "128941", "Unicode hex": "1F7AD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "211", "Dingbat hex": "D3", "Unicode dec": "128942", "Unicode hex": "1F7AE" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "212", "Dingbat hex": "D4", "Unicode dec": "128943", "Unicode hex": "1F7AF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "213", "Dingbat hex": "D5", "Unicode dec": "128944", "Unicode hex": "1F7B0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "214", "Dingbat hex": "D6", "Unicode dec": "128945", "Unicode hex": "1F7B1" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "215", "Dingbat hex": "D7", "Unicode dec": "128946", "Unicode hex": "1F7B2" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "216", "Dingbat hex": "D8", "Unicode dec": "128947", "Unicode hex": "1F7B3" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "217", "Dingbat hex": "D9", "Unicode dec": "128948", "Unicode hex": "1F7B4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "218", "Dingbat hex": "DA", "Unicode dec": "128949", "Unicode hex": "1F7B5" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "219", "Dingbat hex": "DB", "Unicode dec": "128950", "Unicode hex": "1F7B6" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "220", "Dingbat hex": "DC", "Unicode dec": "128951", "Unicode hex": "1F7B7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "221", "Dingbat hex": "DD", "Unicode dec": "128952", "Unicode hex": "1F7B8" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "222", "Dingbat hex": "DE", "Unicode dec": "128953", "Unicode hex": "1F7B9" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "223", "Dingbat hex": "DF", "Unicode dec": "128954", "Unicode hex": "1F7BA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "224", "Dingbat hex": "E0", "Unicode dec": "128955", "Unicode hex": "1F7BB" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "225", "Dingbat hex": "E1", "Unicode dec": "128956", "Unicode hex": "1F7BC" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "226", "Dingbat hex": "E2", "Unicode dec": "128957", "Unicode hex": "1F7BD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "227", "Dingbat hex": "E3", "Unicode dec": "128958", "Unicode hex": "1F7BE" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "228", "Dingbat hex": "E4", "Unicode dec": "128959", "Unicode hex": "1F7BF" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "229", "Dingbat hex": "E5", "Unicode dec": "128960", "Unicode hex": "1F7C0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "230", "Dingbat hex": "E6", "Unicode dec": "128962", "Unicode hex": "1F7C2" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "231", "Dingbat hex": "E7", "Unicode dec": "128964", "Unicode hex": "1F7C4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "232", "Dingbat hex": "E8", "Unicode dec": "128966", "Unicode hex": "1F7C6" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "233", "Dingbat hex": "E9", "Unicode dec": "128969", "Unicode hex": "1F7C9" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "234", "Dingbat hex": "EA", "Unicode dec": "128970", "Unicode hex": "1F7CA" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "235", "Dingbat hex": "EB", "Unicode dec": "10038", "Unicode hex": "2736" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "236", "Dingbat hex": "EC", "Unicode dec": "128972", "Unicode hex": "1F7CC" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "237", "Dingbat hex": "ED", "Unicode dec": "128974", "Unicode hex": "1F7CE" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "238", "Dingbat hex": "EE", "Unicode dec": "128976", "Unicode hex": "1F7D0" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "239", "Dingbat hex": "EF", "Unicode dec": "128978", "Unicode hex": "1F7D2" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "240", "Dingbat hex": "F0", "Unicode dec": "10041", "Unicode hex": "2739" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "241", "Dingbat hex": "F1", "Unicode dec": "128963", "Unicode hex": "1F7C3" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "242", "Dingbat hex": "F2", "Unicode dec": "128967", "Unicode hex": "1F7C7" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "243", "Dingbat hex": "F3", "Unicode dec": "10031", "Unicode hex": "272F" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "244", "Dingbat hex": "F4", "Unicode dec": "128973", "Unicode hex": "1F7CD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "245", "Dingbat hex": "F5", "Unicode dec": "128980", "Unicode hex": "1F7D4" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "246", "Dingbat hex": "F6", "Unicode dec": "11212", "Unicode hex": "2BCC" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "247", "Dingbat hex": "F7", "Unicode dec": "11213", "Unicode hex": "2BCD" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "248", "Dingbat hex": "F8", "Unicode dec": "8251", "Unicode hex": "203B" },
            { "Typeface name": "Wingdings 2", "Dingbat dec": "249", "Dingbat hex": "F9", "Unicode dec": "8258", "Unicode hex": "2042" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "32", "Dingbat hex": "20", "Unicode dec": "32", "Unicode hex": "20" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "33", "Dingbat hex": "21", "Unicode dec": "11104", "Unicode hex": "2B60" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "34", "Dingbat hex": "22", "Unicode dec": "11106", "Unicode hex": "2B62" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "35", "Dingbat hex": "23", "Unicode dec": "11105", "Unicode hex": "2B61" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "36", "Dingbat hex": "24", "Unicode dec": "11107", "Unicode hex": "2B63" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "37", "Dingbat hex": "25", "Unicode dec": "11110", "Unicode hex": "2B66" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "38", "Dingbat hex": "26", "Unicode dec": "11111", "Unicode hex": "2B67" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "39", "Dingbat hex": "27", "Unicode dec": "11113", "Unicode hex": "2B69" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "40", "Dingbat hex": "28", "Unicode dec": "11112", "Unicode hex": "2B68" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "41", "Dingbat hex": "29", "Unicode dec": "11120", "Unicode hex": "2B70" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "42", "Dingbat hex": "2A", "Unicode dec": "11122", "Unicode hex": "2B72" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "43", "Dingbat hex": "2B", "Unicode dec": "11121", "Unicode hex": "2B71" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "44", "Dingbat hex": "2C", "Unicode dec": "11123", "Unicode hex": "2B73" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "45", "Dingbat hex": "2D", "Unicode dec": "11126", "Unicode hex": "2B76" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "46", "Dingbat hex": "2E", "Unicode dec": "11128", "Unicode hex": "2B78" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "47", "Dingbat hex": "2F", "Unicode dec": "11131", "Unicode hex": "2B7B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "48", "Dingbat hex": "30", "Unicode dec": "11133", "Unicode hex": "2B7D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "49", "Dingbat hex": "31", "Unicode dec": "11108", "Unicode hex": "2B64" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "50", "Dingbat hex": "32", "Unicode dec": "11109", "Unicode hex": "2B65" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "51", "Dingbat hex": "33", "Unicode dec": "11114", "Unicode hex": "2B6A" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "52", "Dingbat hex": "34", "Unicode dec": "11116", "Unicode hex": "2B6C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "53", "Dingbat hex": "35", "Unicode dec": "11115", "Unicode hex": "2B6B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "54", "Dingbat hex": "36", "Unicode dec": "11117", "Unicode hex": "2B6D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "55", "Dingbat hex": "37", "Unicode dec": "11085", "Unicode hex": "2B4D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "56", "Dingbat hex": "38", "Unicode dec": "11168", "Unicode hex": "2BA0" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "57", "Dingbat hex": "39", "Unicode dec": "11169", "Unicode hex": "2BA1" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "58", "Dingbat hex": "3A", "Unicode dec": "11170", "Unicode hex": "2BA2" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "59", "Dingbat hex": "3B", "Unicode dec": "11171", "Unicode hex": "2BA3" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "60", "Dingbat hex": "3C", "Unicode dec": "11172", "Unicode hex": "2BA4" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "61", "Dingbat hex": "3D", "Unicode dec": "11173", "Unicode hex": "2BA5" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "62", "Dingbat hex": "3E", "Unicode dec": "11174", "Unicode hex": "2BA6" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "63", "Dingbat hex": "3F", "Unicode dec": "11175", "Unicode hex": "2BA7" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "64", "Dingbat hex": "40", "Unicode dec": "11152", "Unicode hex": "2B90" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "65", "Dingbat hex": "41", "Unicode dec": "11153", "Unicode hex": "2B91" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "66", "Dingbat hex": "42", "Unicode dec": "11154", "Unicode hex": "2B92" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "67", "Dingbat hex": "43", "Unicode dec": "11155", "Unicode hex": "2B93" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "68", "Dingbat hex": "44", "Unicode dec": "11136", "Unicode hex": "2B80" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "69", "Dingbat hex": "45", "Unicode dec": "11139", "Unicode hex": "2B83" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "70", "Dingbat hex": "46", "Unicode dec": "11134", "Unicode hex": "2B7E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "71", "Dingbat hex": "47", "Unicode dec": "11135", "Unicode hex": "2B7F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "72", "Dingbat hex": "48", "Unicode dec": "11140", "Unicode hex": "2B84" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "73", "Dingbat hex": "49", "Unicode dec": "11142", "Unicode hex": "2B86" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "74", "Dingbat hex": "4A", "Unicode dec": "11141", "Unicode hex": "2B85" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "75", "Dingbat hex": "4B", "Unicode dec": "11143", "Unicode hex": "2B87" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "76", "Dingbat hex": "4C", "Unicode dec": "11151", "Unicode hex": "2B8F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "77", "Dingbat hex": "4D", "Unicode dec": "11149", "Unicode hex": "2B8D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "78", "Dingbat hex": "4E", "Unicode dec": "11150", "Unicode hex": "2B8E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "79", "Dingbat hex": "4F", "Unicode dec": "11148", "Unicode hex": "2B8C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "80", "Dingbat hex": "50", "Unicode dec": "11118", "Unicode hex": "2B6E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "81", "Dingbat hex": "51", "Unicode dec": "11119", "Unicode hex": "2B6F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "82", "Dingbat hex": "52", "Unicode dec": "9099", "Unicode hex": "238B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "83", "Dingbat hex": "53", "Unicode dec": "8996", "Unicode hex": "2324" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "84", "Dingbat hex": "54", "Unicode dec": "8963", "Unicode hex": "2303" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "85", "Dingbat hex": "55", "Unicode dec": "8997", "Unicode hex": "2325" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "86", "Dingbat hex": "56", "Unicode dec": "9251", "Unicode hex": "2423" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "87", "Dingbat hex": "57", "Unicode dec": "9085", "Unicode hex": "237D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "88", "Dingbat hex": "58", "Unicode dec": "8682", "Unicode hex": "21EA" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "89", "Dingbat hex": "59", "Unicode dec": "11192", "Unicode hex": "2BB8" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "90", "Dingbat hex": "5A", "Unicode dec": "129184", "Unicode hex": "1F8A0" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "91", "Dingbat hex": "5B", "Unicode dec": "129185", "Unicode hex": "1F8A1" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "92", "Dingbat hex": "5C", "Unicode dec": "129186", "Unicode hex": "1F8A2" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "93", "Dingbat hex": "5D", "Unicode dec": "129187", "Unicode hex": "1F8A3" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "94", "Dingbat hex": "5E", "Unicode dec": "129188", "Unicode hex": "1F8A4" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "95", "Dingbat hex": "5F", "Unicode dec": "129189", "Unicode hex": "1F8A5" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "96", "Dingbat hex": "60", "Unicode dec": "129190", "Unicode hex": "1F8A6" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "97", "Dingbat hex": "61", "Unicode dec": "129191", "Unicode hex": "1F8A7" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "98", "Dingbat hex": "62", "Unicode dec": "129192", "Unicode hex": "1F8A8" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "99", "Dingbat hex": "63", "Unicode dec": "129193", "Unicode hex": "1F8A9" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "100", "Dingbat hex": "64", "Unicode dec": "129194", "Unicode hex": "1F8AA" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "101", "Dingbat hex": "65", "Unicode dec": "129195", "Unicode hex": "1F8AB" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "102", "Dingbat hex": "66", "Unicode dec": "129104", "Unicode hex": "1F850" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "103", "Dingbat hex": "67", "Unicode dec": "129106", "Unicode hex": "1F852" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "104", "Dingbat hex": "68", "Unicode dec": "129105", "Unicode hex": "1F851" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "105", "Dingbat hex": "69", "Unicode dec": "129107", "Unicode hex": "1F853" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "106", "Dingbat hex": "6A", "Unicode dec": "129108", "Unicode hex": "1F854" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "107", "Dingbat hex": "6B", "Unicode dec": "129109", "Unicode hex": "1F855" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "108", "Dingbat hex": "6C", "Unicode dec": "129111", "Unicode hex": "1F857" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "109", "Dingbat hex": "6D", "Unicode dec": "129110", "Unicode hex": "1F856" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "110", "Dingbat hex": "6E", "Unicode dec": "129112", "Unicode hex": "1F858" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "111", "Dingbat hex": "6F", "Unicode dec": "129113", "Unicode hex": "1F859" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "112", "Dingbat hex": "70", "Unicode dec": "9650", "Unicode hex": "25B2" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "113", "Dingbat hex": "71", "Unicode dec": "9660", "Unicode hex": "25BC" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "114", "Dingbat hex": "72", "Unicode dec": "9651", "Unicode hex": "25B3" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "115", "Dingbat hex": "73", "Unicode dec": "9661", "Unicode hex": "25BD" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "116", "Dingbat hex": "74", "Unicode dec": "9664", "Unicode hex": "25C0" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "117", "Dingbat hex": "75", "Unicode dec": "9654", "Unicode hex": "25B6" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "118", "Dingbat hex": "76", "Unicode dec": "9665", "Unicode hex": "25C1" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "119", "Dingbat hex": "77", "Unicode dec": "9655", "Unicode hex": "25B7" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "120", "Dingbat hex": "78", "Unicode dec": "9699", "Unicode hex": "25E3" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "121", "Dingbat hex": "79", "Unicode dec": "9698", "Unicode hex": "25E2" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "122", "Dingbat hex": "7A", "Unicode dec": "9700", "Unicode hex": "25E4" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "123", "Dingbat hex": "7B", "Unicode dec": "9701", "Unicode hex": "25E5" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "124", "Dingbat hex": "7C", "Unicode dec": "128896", "Unicode hex": "1F780" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "125", "Dingbat hex": "7D", "Unicode dec": "128898", "Unicode hex": "1F782" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "126", "Dingbat hex": "7E", "Unicode dec": "128897", "Unicode hex": "1F781" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "128", "Dingbat hex": "80", "Unicode dec": "128899", "Unicode hex": "1F783" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "129", "Dingbat hex": "81", "Unicode dec": "11205", "Unicode hex": "2BC5" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "130", "Dingbat hex": "82", "Unicode dec": "11206", "Unicode hex": "2BC6" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "131", "Dingbat hex": "83", "Unicode dec": "11207", "Unicode hex": "2BC7" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "132", "Dingbat hex": "84", "Unicode dec": "11208", "Unicode hex": "2BC8" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "133", "Dingbat hex": "85", "Unicode dec": "11164", "Unicode hex": "2B9C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "134", "Dingbat hex": "86", "Unicode dec": "11166", "Unicode hex": "2B9E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "135", "Dingbat hex": "87", "Unicode dec": "11165", "Unicode hex": "2B9D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "136", "Dingbat hex": "88", "Unicode dec": "11167", "Unicode hex": "2B9F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "137", "Dingbat hex": "89", "Unicode dec": "129040", "Unicode hex": "1F810" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "138", "Dingbat hex": "8A", "Unicode dec": "129042", "Unicode hex": "1F812" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "139", "Dingbat hex": "8B", "Unicode dec": "129041", "Unicode hex": "1F811" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "140", "Dingbat hex": "8C", "Unicode dec": "129043", "Unicode hex": "1F813" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "141", "Dingbat hex": "8D", "Unicode dec": "129044", "Unicode hex": "1F814" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "142", "Dingbat hex": "8E", "Unicode dec": "129046", "Unicode hex": "1F816" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "143", "Dingbat hex": "8F", "Unicode dec": "129045", "Unicode hex": "1F815" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "144", "Dingbat hex": "90", "Unicode dec": "129047", "Unicode hex": "1F817" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "145", "Dingbat hex": "91", "Unicode dec": "129048", "Unicode hex": "1F818" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "146", "Dingbat hex": "92", "Unicode dec": "129050", "Unicode hex": "1F81A" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "147", "Dingbat hex": "93", "Unicode dec": "129049", "Unicode hex": "1F819" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "148", "Dingbat hex": "94", "Unicode dec": "129051", "Unicode hex": "1F81B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "149", "Dingbat hex": "95", "Unicode dec": "129052", "Unicode hex": "1F81C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "150", "Dingbat hex": "96", "Unicode dec": "129054", "Unicode hex": "1F81E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "151", "Dingbat hex": "97", "Unicode dec": "129053", "Unicode hex": "1F81D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "152", "Dingbat hex": "98", "Unicode dec": "129055", "Unicode hex": "1F81F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "153", "Dingbat hex": "99", "Unicode dec": "129024", "Unicode hex": "1F800" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "154", "Dingbat hex": "9A", "Unicode dec": "129026", "Unicode hex": "1F802" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "155", "Dingbat hex": "9B", "Unicode dec": "129025", "Unicode hex": "1F801" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "156", "Dingbat hex": "9C", "Unicode dec": "129027", "Unicode hex": "1F803" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "157", "Dingbat hex": "9D", "Unicode dec": "129028", "Unicode hex": "1F804" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "158", "Dingbat hex": "9E", "Unicode dec": "129030", "Unicode hex": "1F806" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "159", "Dingbat hex": "9F", "Unicode dec": "129029", "Unicode hex": "1F805" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "160", "Dingbat hex": "A0", "Unicode dec": "129031", "Unicode hex": "1F807" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "161", "Dingbat hex": "A1", "Unicode dec": "129032", "Unicode hex": "1F808" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "162", "Dingbat hex": "A2", "Unicode dec": "129034", "Unicode hex": "1F80A" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "163", "Dingbat hex": "A3", "Unicode dec": "129033", "Unicode hex": "1F809" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "164", "Dingbat hex": "A4", "Unicode dec": "129035", "Unicode hex": "1F80B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "165", "Dingbat hex": "A5", "Unicode dec": "129056", "Unicode hex": "1F820" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "166", "Dingbat hex": "A6", "Unicode dec": "129058", "Unicode hex": "1F822" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "167", "Dingbat hex": "A7", "Unicode dec": "129060", "Unicode hex": "1F824" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "168", "Dingbat hex": "A8", "Unicode dec": "129062", "Unicode hex": "1F826" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "169", "Dingbat hex": "A9", "Unicode dec": "129064", "Unicode hex": "1F828" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "170", "Dingbat hex": "AA", "Unicode dec": "129066", "Unicode hex": "1F82A" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "171", "Dingbat hex": "AB", "Unicode dec": "129068", "Unicode hex": "1F82C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "172", "Dingbat hex": "AC", "Unicode dec": "129180", "Unicode hex": "1F89C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "173", "Dingbat hex": "AD", "Unicode dec": "129181", "Unicode hex": "1F89D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "174", "Dingbat hex": "AE", "Unicode dec": "129182", "Unicode hex": "1F89E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "175", "Dingbat hex": "AF", "Unicode dec": "129183", "Unicode hex": "1F89F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "176", "Dingbat hex": "B0", "Unicode dec": "129070", "Unicode hex": "1F82E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "177", "Dingbat hex": "B1", "Unicode dec": "129072", "Unicode hex": "1F830" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "178", "Dingbat hex": "B2", "Unicode dec": "129074", "Unicode hex": "1F832" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "179", "Dingbat hex": "B3", "Unicode dec": "129076", "Unicode hex": "1F834" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "180", "Dingbat hex": "B4", "Unicode dec": "129078", "Unicode hex": "1F836" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "181", "Dingbat hex": "B5", "Unicode dec": "129080", "Unicode hex": "1F838" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "182", "Dingbat hex": "B6", "Unicode dec": "129082", "Unicode hex": "1F83A" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "183", "Dingbat hex": "B7", "Unicode dec": "129081", "Unicode hex": "1F839" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "184", "Dingbat hex": "B8", "Unicode dec": "129083", "Unicode hex": "1F83B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "185", "Dingbat hex": "B9", "Unicode dec": "129176", "Unicode hex": "1F898" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "186", "Dingbat hex": "BA", "Unicode dec": "129178", "Unicode hex": "1F89A" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "187", "Dingbat hex": "BB", "Unicode dec": "129177", "Unicode hex": "1F899" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "188", "Dingbat hex": "BC", "Unicode dec": "129179", "Unicode hex": "1F89B" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "189", "Dingbat hex": "BD", "Unicode dec": "129084", "Unicode hex": "1F83C" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "190", "Dingbat hex": "BE", "Unicode dec": "129086", "Unicode hex": "1F83E" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "191", "Dingbat hex": "BF", "Unicode dec": "129085", "Unicode hex": "1F83D" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "192", "Dingbat hex": "C0", "Unicode dec": "129087", "Unicode hex": "1F83F" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "193", "Dingbat hex": "C1", "Unicode dec": "129088", "Unicode hex": "1F840" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "194", "Dingbat hex": "C2", "Unicode dec": "129090", "Unicode hex": "1F842" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "195", "Dingbat hex": "C3", "Unicode dec": "129089", "Unicode hex": "1F841" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "196", "Dingbat hex": "C4", "Unicode dec": "129091", "Unicode hex": "1F843" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "197", "Dingbat hex": "C5", "Unicode dec": "129092", "Unicode hex": "1F844" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "198", "Dingbat hex": "C6", "Unicode dec": "129094", "Unicode hex": "1F846" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "199", "Dingbat hex": "C7", "Unicode dec": "129093", "Unicode hex": "1F845" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "200", "Dingbat hex": "C8", "Unicode dec": "129095", "Unicode hex": "1F847" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "201", "Dingbat hex": "C9", "Unicode dec": "11176", "Unicode hex": "2BA8" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "202", "Dingbat hex": "CA", "Unicode dec": "11177", "Unicode hex": "2BA9" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "203", "Dingbat hex": "CB", "Unicode dec": "11178", "Unicode hex": "2BAA" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "204", "Dingbat hex": "CC", "Unicode dec": "11179", "Unicode hex": "2BAB" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "205", "Dingbat hex": "CD", "Unicode dec": "11180", "Unicode hex": "2BAC" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "206", "Dingbat hex": "CE", "Unicode dec": "11181", "Unicode hex": "2BAD" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "207", "Dingbat hex": "CF", "Unicode dec": "11182", "Unicode hex": "2BAE" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "208", "Dingbat hex": "D0", "Unicode dec": "11183", "Unicode hex": "2BAF" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "209", "Dingbat hex": "D1", "Unicode dec": "129120", "Unicode hex": "1F860" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "210", "Dingbat hex": "D2", "Unicode dec": "129122", "Unicode hex": "1F862" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "211", "Dingbat hex": "D3", "Unicode dec": "129121", "Unicode hex": "1F861" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "212", "Dingbat hex": "D4", "Unicode dec": "129123", "Unicode hex": "1F863" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "213", "Dingbat hex": "D5", "Unicode dec": "129124", "Unicode hex": "1F864" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "214", "Dingbat hex": "D6", "Unicode dec": "129125", "Unicode hex": "1F865" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "215", "Dingbat hex": "D7", "Unicode dec": "129127", "Unicode hex": "1F867" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "216", "Dingbat hex": "D8", "Unicode dec": "129126", "Unicode hex": "1F866" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "217", "Dingbat hex": "D9", "Unicode dec": "129136", "Unicode hex": "1F870" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "218", "Dingbat hex": "DA", "Unicode dec": "129138", "Unicode hex": "1F872" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "219", "Dingbat hex": "DB", "Unicode dec": "129137", "Unicode hex": "1F871" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "220", "Dingbat hex": "DC", "Unicode dec": "129139", "Unicode hex": "1F873" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "221", "Dingbat hex": "DD", "Unicode dec": "129140", "Unicode hex": "1F874" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "222", "Dingbat hex": "DE", "Unicode dec": "129141", "Unicode hex": "1F875" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "223", "Dingbat hex": "DF", "Unicode dec": "129143", "Unicode hex": "1F877" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "224", "Dingbat hex": "E0", "Unicode dec": "129142", "Unicode hex": "1F876" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "225", "Dingbat hex": "E1", "Unicode dec": "129152", "Unicode hex": "1F880" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "226", "Dingbat hex": "E2", "Unicode dec": "129154", "Unicode hex": "1F882" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "227", "Dingbat hex": "E3", "Unicode dec": "129153", "Unicode hex": "1F881" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "228", "Dingbat hex": "E4", "Unicode dec": "129155", "Unicode hex": "1F883" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "229", "Dingbat hex": "E5", "Unicode dec": "129156", "Unicode hex": "1F884" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "230", "Dingbat hex": "E6", "Unicode dec": "129157", "Unicode hex": "1F885" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "231", "Dingbat hex": "E7", "Unicode dec": "129159", "Unicode hex": "1F887" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "232", "Dingbat hex": "E8", "Unicode dec": "129158", "Unicode hex": "1F886" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "233", "Dingbat hex": "E9", "Unicode dec": "129168", "Unicode hex": "1F890" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "234", "Dingbat hex": "EA", "Unicode dec": "129170", "Unicode hex": "1F892" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "235", "Dingbat hex": "EB", "Unicode dec": "129169", "Unicode hex": "1F891" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "236", "Dingbat hex": "EC", "Unicode dec": "129171", "Unicode hex": "1F893" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "237", "Dingbat hex": "ED", "Unicode dec": "129172", "Unicode hex": "1F894" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "238", "Dingbat hex": "EE", "Unicode dec": "129174", "Unicode hex": "1F896" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "239", "Dingbat hex": "EF", "Unicode dec": "129173", "Unicode hex": "1F895" },
            { "Typeface name": "Wingdings 3", "Dingbat dec": "240", "Dingbat hex": "F0", "Unicode dec": "129175", "Unicode hex": "1F897" },
        ];
        exports.default = dingbats;

    },{}],80:[function(require,module,exports){
        "use strict";
        var __importDefault = (this && this.__importDefault) || function (mod) {
            return (mod && mod.__esModule) ? mod : { "default": mod };
        };
        Object.defineProperty(exports, "__esModule", { value: true });
        exports.hex = exports.dec = exports.codePoint = void 0;
        var dingbats_1 = __importDefault(require("./dingbats"));
        var dingbatsByCodePoint = {};
        var fromCodePoint = String.fromCodePoint ? String.fromCodePoint : fromCodePointPolyfill;
        for (var _i = 0, dingbats_2 = dingbats_1.default; _i < dingbats_2.length; _i++) {
            var dingbat = dingbats_2[_i];
            var codePoint_1 = parseInt(dingbat["Unicode dec"], 10);
            var scalarValue = {
                codePoint: codePoint_1,
                string: fromCodePoint(codePoint_1),
            };
            dingbatsByCodePoint[dingbat["Typeface name"].toUpperCase() + "_" + dingbat["Dingbat dec"]] = scalarValue;
        }
        function codePoint(typeface, codePoint) {
            return dingbatsByCodePoint[typeface.toUpperCase() + "_" + codePoint];
        }
        exports.codePoint = codePoint;
        function dec(typeface, dec) {
            return codePoint(typeface, parseInt(dec, 10));
        }
        exports.dec = dec;
        function hex(typeface, hex) {
            return codePoint(typeface, parseInt(hex, 16));
        }
        exports.hex = hex;
        function fromCodePointPolyfill(codePoint) {
            if (codePoint <= 0xFFFF) {
                // BMP
                return String.fromCharCode(codePoint);
            }
            else {
                // Astral
                // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
                var highSurrogate = Math.floor((codePoint - 0x10000) / 0x400) + 0xD800;
                var lowSurrogate = (codePoint - 0x10000) % 0x400 + 0xDC00;
                return String.fromCharCode(highSurrogate, lowSurrogate);
            }
        }
        ;

    },{"./dingbats":79}],81:[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
                    } else {
                        // At least give some kind of context to the user
                        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
                        err.context = er;
                        throw err;
                    }
                }
            }

            handler = this._events[type];

            if (isUndefined(handler))
                return false;

            if (isFunction(handler)) {
                switch (arguments.length) {
                    // 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;
        }

    },{}],82:[function(require,module,exports){
        /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
        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
        }

    },{}],83:[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
            }
        }

    },{}],84:[function(require,module,exports){
        if (typeof Object.create === 'function') {
            // implementation from standard node.js 'util' module
            module.exports = function inherits(ctor, superCtor) {
                if (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) {
                if (superCtor) {
                    ctor.super_ = superCtor
                    var TempCtor = function () {}
                    TempCtor.prototype = superCtor.prototype
                    ctor.prototype = new TempCtor()
                    ctor.prototype.constructor = ctor
                }
            }
        }

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

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

    },{}],86:[function(require,module,exports){
        (function (process,global,Buffer,__argument0,__argument1,__argument2,__argument3,setImmediate){(function (){
            /*!

JSZip v3.10.1 - A JavaScript class for generating and reading zip files
<http://stuartk.com/jszip>

(c) 2009-2016 Stuart Knightley <stuart [at] stuartk.com>
Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip/main/LICENSE.markdown.

JSZip uses the library pako released under the MIT license :
https://github.com/nodeca/pako/blob/main/LICENSE
*/

            !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).JSZip=e()}}(function(){return function s(a,o,h){function u(r,e){if(!o[r]){if(!a[r]){var t="function"==typeof require&&require;if(!e&&t)return t(r,!0);if(l)return l(r,!0);var n=new Error("Cannot find module '"+r+"'");throw n.code="MODULE_NOT_FOUND",n}var i=o[r]={exports:{}};a[r][0].call(i.exports,function(e){var t=a[r][1][e];return u(t||e)},i,i.exports,s,a,o,h)}return o[r].exports}for(var l="function"==typeof require&&require,e=0;e<h.length;e++)u(h[e]);return u}({1:[function(e,t,r){"use strict";var d=e("./utils"),c=e("./support"),p="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";r.encode=function(e){for(var t,r,n,i,s,a,o,h=[],u=0,l=e.length,f=l,c="string"!==d.getTypeOf(e);u<e.length;)f=l-u,n=c?(t=e[u++],r=u<l?e[u++]:0,u<l?e[u++]:0):(t=e.charCodeAt(u++),r=u<l?e.charCodeAt(u++):0,u<l?e.charCodeAt(u++):0),i=t>>2,s=(3&t)<<4|r>>4,a=1<f?(15&r)<<2|n>>6:64,o=2<f?63&n:64,h.push(p.charAt(i)+p.charAt(s)+p.charAt(a)+p.charAt(o));return h.join("")},r.decode=function(e){var t,r,n,i,s,a,o=0,h=0,u="data:";if(e.substr(0,u.length)===u)throw new Error("Invalid base64 input, it looks like a data url.");var l,f=3*(e=e.replace(/[^A-Za-z0-9+/=]/g,"")).length/4;if(e.charAt(e.length-1)===p.charAt(64)&&f--,e.charAt(e.length-2)===p.charAt(64)&&f--,f%1!=0)throw new Error("Invalid base64 input, bad content length.");for(l=c.uint8array?new Uint8Array(0|f):new Array(0|f);o<e.length;)t=p.indexOf(e.charAt(o++))<<2|(i=p.indexOf(e.charAt(o++)))>>4,r=(15&i)<<4|(s=p.indexOf(e.charAt(o++)))>>2,n=(3&s)<<6|(a=p.indexOf(e.charAt(o++))),l[h++]=t,64!==s&&(l[h++]=r),64!==a&&(l[h++]=n);return l}},{"./support":30,"./utils":32}],2:[function(e,t,r){"use strict";var n=e("./external"),i=e("./stream/DataWorker"),s=e("./stream/Crc32Probe"),a=e("./stream/DataLengthProbe");function o(e,t,r,n,i){this.compressedSize=e,this.uncompressedSize=t,this.crc32=r,this.compression=n,this.compressedContent=i}o.prototype={getContentWorker:function(){var e=new i(n.Promise.resolve(this.compressedContent)).pipe(this.compression.uncompressWorker()).pipe(new a("data_length")),t=this;return e.on("end",function(){if(this.streamInfo.data_length!==t.uncompressedSize)throw new Error("Bug : uncompressed data size mismatch")}),e},getCompressedWorker:function(){return new i(n.Promise.resolve(this.compressedContent)).withStreamInfo("compressedSize",this.compressedSize).withStreamInfo("uncompressedSize",this.uncompressedSize).withStreamInfo("crc32",this.crc32).withStreamInfo("compression",this.compression)}},o.createWorkerFrom=function(e,t,r){return e.pipe(new s).pipe(new a("uncompressedSize")).pipe(t.compressWorker(r)).pipe(new a("compressedSize")).withStreamInfo("compression",t)},t.exports=o},{"./external":6,"./stream/Crc32Probe":25,"./stream/DataLengthProbe":26,"./stream/DataWorker":27}],3:[function(e,t,r){"use strict";var n=e("./stream/GenericWorker");r.STORE={magic:"\0\0",compressWorker:function(){return new n("STORE compression")},uncompressWorker:function(){return new n("STORE decompression")}},r.DEFLATE=e("./flate")},{"./flate":7,"./stream/GenericWorker":28}],4:[function(e,t,r){"use strict";var n=e("./utils");var o=function(){for(var e,t=[],r=0;r<256;r++){e=r;for(var n=0;n<8;n++)e=1&e?3988292384^e>>>1:e>>>1;t[r]=e}return t}();t.exports=function(e,t){return void 0!==e&&e.length?"string"!==n.getTypeOf(e)?function(e,t,r,n){var i=o,s=n+r;e^=-1;for(var a=n;a<s;a++)e=e>>>8^i[255&(e^t[a])];return-1^e}(0|t,e,e.length,0):function(e,t,r,n){var i=o,s=n+r;e^=-1;for(var a=n;a<s;a++)e=e>>>8^i[255&(e^t.charCodeAt(a))];return-1^e}(0|t,e,e.length,0):0}},{"./utils":32}],5:[function(e,t,r){"use strict";r.base64=!1,r.binary=!1,r.dir=!1,r.createFolders=!0,r.date=null,r.compression=null,r.compressionOptions=null,r.comment=null,r.unixPermissions=null,r.dosPermissions=null},{}],6:[function(e,t,r){"use strict";var n=null;n="undefined"!=typeof Promise?Promise:e("lie"),t.exports={Promise:n}},{lie:37}],7:[function(e,t,r){"use strict";var n="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Uint32Array,i=e("pako"),s=e("./utils"),a=e("./stream/GenericWorker"),o=n?"uint8array":"array";function h(e,t){a.call(this,"FlateWorker/"+e),this._pako=null,this._pakoAction=e,this._pakoOptions=t,this.meta={}}r.magic="\b\0",s.inherits(h,a),h.prototype.processChunk=function(e){this.meta=e.meta,null===this._pako&&this._createPako(),this._pako.push(s.transformTo(o,e.data),!1)},h.prototype.flush=function(){a.prototype.flush.call(this),null===this._pako&&this._createPako(),this._pako.push([],!0)},h.prototype.cleanUp=function(){a.prototype.cleanUp.call(this),this._pako=null},h.prototype._createPako=function(){this._pako=new i[this._pakoAction]({raw:!0,level:this._pakoOptions.level||-1});var t=this;this._pako.onData=function(e){t.push({data:e,meta:t.meta})}},r.compressWorker=function(e){return new h("Deflate",e)},r.uncompressWorker=function(){return new h("Inflate",{})}},{"./stream/GenericWorker":28,"./utils":32,pako:38}],8:[function(e,t,r){"use strict";function A(e,t){var r,n="";for(r=0;r<t;r++)n+=String.fromCharCode(255&e),e>>>=8;return n}function n(e,t,r,n,i,s){var a,o,h=e.file,u=e.compression,l=s!==O.utf8encode,f=I.transformTo("string",s(h.name)),c=I.transformTo("string",O.utf8encode(h.name)),d=h.comment,p=I.transformTo("string",s(d)),m=I.transformTo("string",O.utf8encode(d)),_=c.length!==h.name.length,g=m.length!==d.length,b="",v="",y="",w=h.dir,k=h.date,x={crc32:0,compressedSize:0,uncompressedSize:0};t&&!r||(x.crc32=e.crc32,x.compressedSize=e.compressedSize,x.uncompressedSize=e.uncompressedSize);var S=0;t&&(S|=8),l||!_&&!g||(S|=2048);var z=0,C=0;w&&(z|=16),"UNIX"===i?(C=798,z|=function(e,t){var r=e;return e||(r=t?16893:33204),(65535&r)<<16}(h.unixPermissions,w)):(C=20,z|=function(e){return 63&(e||0)}(h.dosPermissions)),a=k.getUTCHours(),a<<=6,a|=k.getUTCMinutes(),a<<=5,a|=k.getUTCSeconds()/2,o=k.getUTCFullYear()-1980,o<<=4,o|=k.getUTCMonth()+1,o<<=5,o|=k.getUTCDate(),_&&(v=A(1,1)+A(B(f),4)+c,b+="up"+A(v.length,2)+v),g&&(y=A(1,1)+A(B(p),4)+m,b+="uc"+A(y.length,2)+y);var E="";return E+="\n\0",E+=A(S,2),E+=u.magic,E+=A(a,2),E+=A(o,2),E+=A(x.crc32,4),E+=A(x.compressedSize,4),E+=A(x.uncompressedSize,4),E+=A(f.length,2),E+=A(b.length,2),{fileRecord:R.LOCAL_FILE_HEADER+E+f+b,dirRecord:R.CENTRAL_FILE_HEADER+A(C,2)+E+A(p.length,2)+"\0\0\0\0"+A(z,4)+A(n,4)+f+b+p}}var I=e("../utils"),i=e("../stream/GenericWorker"),O=e("../utf8"),B=e("../crc32"),R=e("../signature");function s(e,t,r,n){i.call(this,"ZipFileWorker"),this.bytesWritten=0,this.zipComment=t,this.zipPlatform=r,this.encodeFileName=n,this.streamFiles=e,this.accumulate=!1,this.contentBuffer=[],this.dirRecords=[],this.currentSourceOffset=0,this.entriesCount=0,this.currentFile=null,this._sources=[]}I.inherits(s,i),s.prototype.push=function(e){var t=e.meta.percent||0,r=this.entriesCount,n=this._sources.length;this.accumulate?this.contentBuffer.push(e):(this.bytesWritten+=e.data.length,i.prototype.push.call(this,{data:e.data,meta:{currentFile:this.currentFile,percent:r?(t+100*(r-n-1))/r:100}}))},s.prototype.openedSource=function(e){this.currentSourceOffset=this.bytesWritten,this.currentFile=e.file.name;var t=this.streamFiles&&!e.file.dir;if(t){var r=n(e,t,!1,this.currentSourceOffset,this.zipPlatform,this.encodeFileName);this.push({data:r.fileRecord,meta:{percent:0}})}else this.accumulate=!0},s.prototype.closedSource=function(e){this.accumulate=!1;var t=this.streamFiles&&!e.file.dir,r=n(e,t,!0,this.currentSourceOffset,this.zipPlatform,this.encodeFileName);if(this.dirRecords.push(r.dirRecord),t)this.push({data:function(e){return R.DATA_DESCRIPTOR+A(e.crc32,4)+A(e.compressedSize,4)+A(e.uncompressedSize,4)}(e),meta:{percent:100}});else for(this.push({data:r.fileRecord,meta:{percent:0}});this.contentBuffer.length;)this.push(this.contentBuffer.shift());this.currentFile=null},s.prototype.flush=function(){for(var e=this.bytesWritten,t=0;t<this.dirRecords.length;t++)this.push({data:this.dirRecords[t],meta:{percent:100}});var r=this.bytesWritten-e,n=function(e,t,r,n,i){var s=I.transformTo("string",i(n));return R.CENTRAL_DIRECTORY_END+"\0\0\0\0"+A(e,2)+A(e,2)+A(t,4)+A(r,4)+A(s.length,2)+s}(this.dirRecords.length,r,e,this.zipComment,this.encodeFileName);this.push({data:n,meta:{percent:100}})},s.prototype.prepareNextSource=function(){this.previous=this._sources.shift(),this.openedSource(this.previous.streamInfo),this.isPaused?this.previous.pause():this.previous.resume()},s.prototype.registerPrevious=function(e){this._sources.push(e);var t=this;return e.on("data",function(e){t.processChunk(e)}),e.on("end",function(){t.closedSource(t.previous.streamInfo),t._sources.length?t.prepareNextSource():t.end()}),e.on("error",function(e){t.error(e)}),this},s.prototype.resume=function(){return!!i.prototype.resume.call(this)&&(!this.previous&&this._sources.length?(this.prepareNextSource(),!0):this.previous||this._sources.length||this.generatedError?void 0:(this.end(),!0))},s.prototype.error=function(e){var t=this._sources;if(!i.prototype.error.call(this,e))return!1;for(var r=0;r<t.length;r++)try{t[r].error(e)}catch(e){}return!0},s.prototype.lock=function(){i.prototype.lock.call(this);for(var e=this._sources,t=0;t<e.length;t++)e[t].lock()},t.exports=s},{"../crc32":4,"../signature":23,"../stream/GenericWorker":28,"../utf8":31,"../utils":32}],9:[function(e,t,r){"use strict";var u=e("../compressions"),n=e("./ZipFileWorker");r.generateWorker=function(e,a,t){var o=new n(a.streamFiles,t,a.platform,a.encodeFileName),h=0;try{e.forEach(function(e,t){h++;var r=function(e,t){var r=e||t,n=u[r];if(!n)throw new Error(r+" is not a valid compression method !");return n}(t.options.compression,a.compression),n=t.options.compressionOptions||a.compressionOptions||{},i=t.dir,s=t.date;t._compressWorker(r,n).withStreamInfo("file",{name:e,dir:i,date:s,comment:t.comment||"",unixPermissions:t.unixPermissions,dosPermissions:t.dosPermissions}).pipe(o)}),o.entriesCount=h}catch(e){o.error(e)}return o}},{"../compressions":3,"./ZipFileWorker":8}],10:[function(e,t,r){"use strict";function n(){if(!(this instanceof n))return new n;if(arguments.length)throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");this.files=Object.create(null),this.comment=null,this.root="",this.clone=function(){var e=new n;for(var t in this)"function"!=typeof this[t]&&(e[t]=this[t]);return e}}(n.prototype=e("./object")).loadAsync=e("./load"),n.support=e("./support"),n.defaults=e("./defaults"),n.version="3.10.1",n.loadAsync=function(e,t){return(new n).loadAsync(e,t)},n.external=e("./external"),t.exports=n},{"./defaults":5,"./external":6,"./load":11,"./object":15,"./support":30}],11:[function(e,t,r){"use strict";var u=e("./utils"),i=e("./external"),n=e("./utf8"),s=e("./zipEntries"),a=e("./stream/Crc32Probe"),l=e("./nodejsUtils");function f(n){return new i.Promise(function(e,t){var r=n.decompressed.getContentWorker().pipe(new a);r.on("error",function(e){t(e)}).on("end",function(){r.streamInfo.crc32!==n.decompressed.crc32?t(new Error("Corrupted zip : CRC32 mismatch")):e()}).resume()})}t.exports=function(e,o){var h=this;return o=u.extend(o||{},{base64:!1,checkCRC32:!1,optimizedBinaryString:!1,createFolders:!1,decodeFileName:n.utf8decode}),l.isNode&&l.isStream(e)?i.Promise.reject(new Error("JSZip can't accept a stream when loading a zip file.")):u.prepareContent("the loaded zip file",e,!0,o.optimizedBinaryString,o.base64).then(function(e){var t=new s(o);return t.load(e),t}).then(function(e){var t=[i.Promise.resolve(e)],r=e.files;if(o.checkCRC32)for(var n=0;n<r.length;n++)t.push(f(r[n]));return i.Promise.all(t)}).then(function(e){for(var t=e.shift(),r=t.files,n=0;n<r.length;n++){var i=r[n],s=i.fileNameStr,a=u.resolve(i.fileNameStr);h.file(a,i.decompressed,{binary:!0,optimizedBinaryString:!0,date:i.date,dir:i.dir,comment:i.fileCommentStr.length?i.fileCommentStr:null,unixPermissions:i.unixPermissions,dosPermissions:i.dosPermissions,createFolders:o.createFolders}),i.dir||(h.file(a).unsafeOriginalName=s)}return t.zipComment.length&&(h.comment=t.zipComment),h})}},{"./external":6,"./nodejsUtils":14,"./stream/Crc32Probe":25,"./utf8":31,"./utils":32,"./zipEntries":33}],12:[function(e,t,r){"use strict";var n=e("../utils"),i=e("../stream/GenericWorker");function s(e,t){i.call(this,"Nodejs stream input adapter for "+e),this._upstreamEnded=!1,this._bindStream(t)}n.inherits(s,i),s.prototype._bindStream=function(e){var t=this;(this._stream=e).pause(),e.on("data",function(e){t.push({data:e,meta:{percent:0}})}).on("error",function(e){t.isPaused?this.generatedError=e:t.error(e)}).on("end",function(){t.isPaused?t._upstreamEnded=!0:t.end()})},s.prototype.pause=function(){return!!i.prototype.pause.call(this)&&(this._stream.pause(),!0)},s.prototype.resume=function(){return!!i.prototype.resume.call(this)&&(this._upstreamEnded?this.end():this._stream.resume(),!0)},t.exports=s},{"../stream/GenericWorker":28,"../utils":32}],13:[function(e,t,r){"use strict";var i=e("readable-stream").Readable;function n(e,t,r){i.call(this,t),this._helper=e;var n=this;e.on("data",function(e,t){n.push(e)||n._helper.pause(),r&&r(t)}).on("error",function(e){n.emit("error",e)}).on("end",function(){n.push(null)})}e("../utils").inherits(n,i),n.prototype._read=function(){this._helper.resume()},t.exports=n},{"../utils":32,"readable-stream":16}],14:[function(e,t,r){"use strict";t.exports={isNode:"undefined"!=typeof Buffer,newBufferFrom:function(e,t){if(Buffer.from&&Buffer.from!==Uint8Array.from)return Buffer.from(e,t);if("number"==typeof e)throw new Error('The "data" argument must not be a number');return new Buffer(e,t)},allocBuffer:function(e){if(Buffer.alloc)return Buffer.alloc(e);var t=new Buffer(e);return t.fill(0),t},isBuffer:function(e){return Buffer.isBuffer(e)},isStream:function(e){return e&&"function"==typeof e.on&&"function"==typeof e.pause&&"function"==typeof e.resume}}},{}],15:[function(e,t,r){"use strict";function s(e,t,r){var n,i=u.getTypeOf(t),s=u.extend(r||{},f);s.date=s.date||new Date,null!==s.compression&&(s.compression=s.compression.toUpperCase()),"string"==typeof s.unixPermissions&&(s.unixPermissions=parseInt(s.unixPermissions,8)),s.unixPermissions&&16384&s.unixPermissions&&(s.dir=!0),s.dosPermissions&&16&s.dosPermissions&&(s.dir=!0),s.dir&&(e=g(e)),s.createFolders&&(n=_(e))&&b.call(this,n,!0);var a="string"===i&&!1===s.binary&&!1===s.base64;r&&void 0!==r.binary||(s.binary=!a),(t instanceof c&&0===t.uncompressedSize||s.dir||!t||0===t.length)&&(s.base64=!1,s.binary=!0,t="",s.compression="STORE",i="string");var o=null;o=t instanceof c||t instanceof l?t:p.isNode&&p.isStream(t)?new m(e,t):u.prepareContent(e,t,s.binary,s.optimizedBinaryString,s.base64);var h=new d(e,o,s);this.files[e]=h}var i=e("./utf8"),u=e("./utils"),l=e("./stream/GenericWorker"),a=e("./stream/StreamHelper"),f=e("./defaults"),c=e("./compressedObject"),d=e("./zipObject"),o=e("./generate"),p=e("./nodejsUtils"),m=e("./nodejs/NodejsStreamInputAdapter"),_=function(e){"/"===e.slice(-1)&&(e=e.substring(0,e.length-1));var t=e.lastIndexOf("/");return 0<t?e.substring(0,t):""},g=function(e){return"/"!==e.slice(-1)&&(e+="/"),e},b=function(e,t){return t=void 0!==t?t:f.createFolders,e=g(e),this.files[e]||s.call(this,e,null,{dir:!0,createFolders:t}),this.files[e]};function h(e){return"[object RegExp]"===Object.prototype.toString.call(e)}var n={load:function(){throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.")},forEach:function(e){var t,r,n;for(t in this.files)n=this.files[t],(r=t.slice(this.root.length,t.length))&&t.slice(0,this.root.length)===this.root&&e(r,n)},filter:function(r){var n=[];return this.forEach(function(e,t){r(e,t)&&n.push(t)}),n},file:function(e,t,r){if(1!==arguments.length)return e=this.root+e,s.call(this,e,t,r),this;if(h(e)){var n=e;return this.filter(function(e,t){return!t.dir&&n.test(e)})}var i=this.files[this.root+e];return i&&!i.dir?i:null},folder:function(r){if(!r)return this;if(h(r))return this.filter(function(e,t){return t.dir&&r.test(e)});var e=this.root+r,t=b.call(this,e),n=this.clone();return n.root=t.name,n},remove:function(r){r=this.root+r;var e=this.files[r];if(e||("/"!==r.slice(-1)&&(r+="/"),e=this.files[r]),e&&!e.dir)delete this.files[r];else for(var t=this.filter(function(e,t){return t.name.slice(0,r.length)===r}),n=0;n<t.length;n++)delete this.files[t[n].name];return this},generate:function(){throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.")},generateInternalStream:function(e){var t,r={};try{if((r=u.extend(e||{},{streamFiles:!1,compression:"STORE",compressionOptions:null,type:"",platform:"DOS",comment:null,mimeType:"application/zip",encodeFileName:i.utf8encode})).type=r.type.toLowerCase(),r.compression=r.compression.toUpperCase(),"binarystring"===r.type&&(r.type="string"),!r.type)throw new Error("No output type specified.");u.checkSupport(r.type),"darwin"!==r.platform&&"freebsd"!==r.platform&&"linux"!==r.platform&&"sunos"!==r.platform||(r.platform="UNIX"),"win32"===r.platform&&(r.platform="DOS");var n=r.comment||this.comment||"";t=o.generateWorker(this,r,n)}catch(e){(t=new l("error")).error(e)}return new a(t,r.type||"string",r.mimeType)},generateAsync:function(e,t){return this.generateInternalStream(e).accumulate(t)},generateNodeStream:function(e,t){return(e=e||{}).type||(e.type="nodebuffer"),this.generateInternalStream(e).toNodejsStream(t)}};t.exports=n},{"./compressedObject":2,"./defaults":5,"./generate":9,"./nodejs/NodejsStreamInputAdapter":12,"./nodejsUtils":14,"./stream/GenericWorker":28,"./stream/StreamHelper":29,"./utf8":31,"./utils":32,"./zipObject":35}],16:[function(e,t,r){"use strict";t.exports=e("stream")},{stream:void 0}],17:[function(e,t,r){"use strict";var n=e("./DataReader");function i(e){n.call(this,e);for(var t=0;t<this.data.length;t++)e[t]=255&e[t]}e("../utils").inherits(i,n),i.prototype.byteAt=function(e){return this.data[this.zero+e]},i.prototype.lastIndexOfSignature=function(e){for(var t=e.charCodeAt(0),r=e.charCodeAt(1),n=e.charCodeAt(2),i=e.charCodeAt(3),s=this.length-4;0<=s;--s)if(this.data[s]===t&&this.data[s+1]===r&&this.data[s+2]===n&&this.data[s+3]===i)return s-this.zero;return-1},i.prototype.readAndCheckSignature=function(e){var t=e.charCodeAt(0),r=e.charCodeAt(1),n=e.charCodeAt(2),i=e.charCodeAt(3),s=this.readData(4);return t===s[0]&&r===s[1]&&n===s[2]&&i===s[3]},i.prototype.readData=function(e){if(this.checkOffset(e),0===e)return[];var t=this.data.slice(this.zero+this.index,this.zero+this.index+e);return this.index+=e,t},t.exports=i},{"../utils":32,"./DataReader":18}],18:[function(e,t,r){"use strict";var n=e("../utils");function i(e){this.data=e,this.length=e.length,this.index=0,this.zero=0}i.prototype={checkOffset:function(e){this.checkIndex(this.index+e)},checkIndex:function(e){if(this.length<this.zero+e||e<0)throw new Error("End of data reached (data length = "+this.length+", asked index = "+e+"). Corrupted zip ?")},setIndex:function(e){this.checkIndex(e),this.index=e},skip:function(e){this.setIndex(this.index+e)},byteAt:function(){},readInt:function(e){var t,r=0;for(this.checkOffset(e),t=this.index+e-1;t>=this.index;t--)r=(r<<8)+this.byteAt(t);return this.index+=e,r},readString:function(e){return n.transformTo("string",this.readData(e))},readData:function(){},lastIndexOfSignature:function(){},readAndCheckSignature:function(){},readDate:function(){var e=this.readInt(4);return new Date(Date.UTC(1980+(e>>25&127),(e>>21&15)-1,e>>16&31,e>>11&31,e>>5&63,(31&e)<<1))}},t.exports=i},{"../utils":32}],19:[function(e,t,r){"use strict";var n=e("./Uint8ArrayReader");function i(e){n.call(this,e)}e("../utils").inherits(i,n),i.prototype.readData=function(e){this.checkOffset(e);var t=this.data.slice(this.zero+this.index,this.zero+this.index+e);return this.index+=e,t},t.exports=i},{"../utils":32,"./Uint8ArrayReader":21}],20:[function(e,t,r){"use strict";var n=e("./DataReader");function i(e){n.call(this,e)}e("../utils").inherits(i,n),i.prototype.byteAt=function(e){return this.data.charCodeAt(this.zero+e)},i.prototype.lastIndexOfSignature=function(e){return this.data.lastIndexOf(e)-this.zero},i.prototype.readAndCheckSignature=function(e){return e===this.readData(4)},i.prototype.readData=function(e){this.checkOffset(e);var t=this.data.slice(this.zero+this.index,this.zero+this.index+e);return this.index+=e,t},t.exports=i},{"../utils":32,"./DataReader":18}],21:[function(e,t,r){"use strict";var n=e("./ArrayReader");function i(e){n.call(this,e)}e("../utils").inherits(i,n),i.prototype.readData=function(e){if(this.checkOffset(e),0===e)return new Uint8Array(0);var t=this.data.subarray(this.zero+this.index,this.zero+this.index+e);return this.index+=e,t},t.exports=i},{"../utils":32,"./ArrayReader":17}],22:[function(e,t,r){"use strict";var n=e("../utils"),i=e("../support"),s=e("./ArrayReader"),a=e("./StringReader"),o=e("./NodeBufferReader"),h=e("./Uint8ArrayReader");t.exports=function(e){var t=n.getTypeOf(e);return n.checkSupport(t),"string"!==t||i.uint8array?"nodebuffer"===t?new o(e):i.uint8array?new h(n.transformTo("uint8array",e)):new s(n.transformTo("array",e)):new a(e)}},{"../support":30,"../utils":32,"./ArrayReader":17,"./NodeBufferReader":19,"./StringReader":20,"./Uint8ArrayReader":21}],23:[function(e,t,r){"use strict";r.LOCAL_FILE_HEADER="PK",r.CENTRAL_FILE_HEADER="PK
",r.CENTRAL_DIRECTORY_END="PK",r.ZIP64_CENTRAL_DIRECTORY_LOCATOR="PK",r.ZIP64_CENTRAL_DIRECTORY_END="PK",r.DATA_DESCRIPTOR="PK\b"},{}],24:[function(e,t,r){"use strict";var n=e("./GenericWorker"),i=e("../utils");function s(e){n.call(this,"ConvertWorker to "+e),this.destType=e}i.inherits(s,n),s.prototype.processChunk=function(e){this.push({data:i.transformTo(this.destType,e.data),meta:e.meta})},t.exports=s},{"../utils":32,"./GenericWorker":28}],25:[function(e,t,r){"use strict";var n=e("./GenericWorker"),i=e("../crc32");function s(){n.call(this,"Crc32Probe"),this.withStreamInfo("crc32",0)}e("../utils").inherits(s,n),s.prototype.processChunk=function(e){this.streamInfo.crc32=i(e.data,this.streamInfo.crc32||0),this.push(e)},t.exports=s},{"../crc32":4,"../utils":32,"./GenericWorker":28}],26:[function(e,t,r){"use strict";var n=e("../utils"),i=e("./GenericWorker");function s(e){i.call(this,"DataLengthProbe for "+e),this.propName=e,this.withStreamInfo(e,0)}n.inherits(s,i),s.prototype.processChunk=function(e){if(e){var t=this.streamInfo[this.propName]||0;this.streamInfo[this.propName]=t+e.data.length}i.prototype.processChunk.call(this,e)},t.exports=s},{"../utils":32,"./GenericWorker":28}],27:[function(e,t,r){"use strict";var n=e("../utils"),i=e("./GenericWorker");function s(e){i.call(this,"DataWorker");var t=this;this.dataIsReady=!1,this.index=0,this.max=0,this.data=null,this.type="",this._tickScheduled=!1,e.then(function(e){t.dataIsReady=!0,t.data=e,t.max=e&&e.length||0,t.type=n.getTypeOf(e),t.isPaused||t._tickAndRepeat()},function(e){t.error(e)})}n.inherits(s,i),s.prototype.cleanUp=function(){i.prototype.cleanUp.call(this),this.data=null},s.prototype.resume=function(){return!!i.prototype.resume.call(this)&&(!this._tickScheduled&&this.dataIsReady&&(this._tickScheduled=!0,n.delay(this._tickAndRepeat,[],this)),!0)},s.prototype._tickAndRepeat=function(){this._tickScheduled=!1,this.isPaused||this.isFinished||(this._tick(),this.isFinished||(n.delay(this._tickAndRepeat,[],this),this._tickScheduled=!0))},s.prototype._tick=function(){if(this.isPaused||this.isFinished)return!1;var e=null,t=Math.min(this.max,this.index+16384);if(this.index>=this.max)return this.end();switch(this.type){case"string":e=this.data.substring(this.index,t);break;case"uint8array":e=this.data.subarray(this.index,t);break;case"array":case"nodebuffer":e=this.data.slice(this.index,t)}return this.index=t,this.push({data:e,meta:{percent:this.max?this.index/this.max*100:0}})},t.exports=s},{"../utils":32,"./GenericWorker":28}],28:[function(e,t,r){"use strict";function n(e){this.name=e||"default",this.streamInfo={},this.generatedError=null,this.extraStreamInfo={},this.isPaused=!0,this.isFinished=!1,this.isLocked=!1,this._listeners={data:[],end:[],error:[]},this.previous=null}n.prototype={push:function(e){this.emit("data",e)},end:function(){if(this.isFinished)return!1;this.flush();try{this.emit("end"),this.cleanUp(),this.isFinished=!0}catch(e){this.emit("error",e)}return!0},error:function(e){return!this.isFinished&&(this.isPaused?this.generatedError=e:(this.isFinished=!0,this.emit("error",e),this.previous&&this.previous.error(e),this.cleanUp()),!0)},on:function(e,t){return this._listeners[e].push(t),this},cleanUp:function(){this.streamInfo=this.generatedError=this.extraStreamInfo=null,this._listeners=[]},emit:function(e,t){if(this._listeners[e])for(var r=0;r<this._listeners[e].length;r++)this._listeners[e][r].call(this,t)},pipe:function(e){return e.registerPrevious(this)},registerPrevious:function(e){if(this.isLocked)throw new Error("The stream '"+this+"' has already been used.");this.streamInfo=e.streamInfo,this.mergeStreamInfo(),this.previous=e;var t=this;return e.on("data",function(e){t.processChunk(e)}),e.on("end",function(){t.end()}),e.on("error",function(e){t.error(e)}),this},pause:function(){return!this.isPaused&&!this.isFinished&&(this.isPaused=!0,this.previous&&this.previous.pause(),!0)},resume:function(){if(!this.isPaused||this.isFinished)return!1;var e=this.isPaused=!1;return this.generatedError&&(this.error(this.generatedError),e=!0),this.previous&&this.previous.resume(),!e},flush:function(){},processChunk:function(e){this.push(e)},withStreamInfo:function(e,t){return this.extraStreamInfo[e]=t,this.mergeStreamInfo(),this},mergeStreamInfo:function(){for(var e in this.extraStreamInfo)Object.prototype.hasOwnProperty.call(this.extraStreamInfo,e)&&(this.streamInfo[e]=this.extraStreamInfo[e])},lock:function(){if(this.isLocked)throw new Error("The stream '"+this+"' has already been used.");this.isLocked=!0,this.previous&&this.previous.lock()},toString:function(){var e="Worker "+this.name;return this.previous?this.previous+" -> "+e:e}},t.exports=n},{}],29:[function(e,t,r){"use strict";var h=e("../utils"),i=e("./ConvertWorker"),s=e("./GenericWorker"),u=e("../base64"),n=e("../support"),a=e("../external"),o=null;if(n.nodestream)try{o=e("../nodejs/NodejsStreamOutputAdapter")}catch(e){}function l(e,o){return new a.Promise(function(t,r){var n=[],i=e._internalType,s=e._outputType,a=e._mimeType;e.on("data",function(e,t){n.push(e),o&&o(t)}).on("error",function(e){n=[],r(e)}).on("end",function(){try{var e=function(e,t,r){switch(e){case"blob":return h.newBlob(h.transformTo("arraybuffer",t),r);case"base64":return u.encode(t);default:return h.transformTo(e,t)}}(s,function(e,t){var r,n=0,i=null,s=0;for(r=0;r<t.length;r++)s+=t[r].length;switch(e){case"string":return t.join("");case"array":return Array.prototype.concat.apply([],t);case"uint8array":for(i=new Uint8Array(s),r=0;r<t.length;r++)i.set(t[r],n),n+=t[r].length;return i;case"nodebuffer":return Buffer.concat(t);default:throw new Error("concat : unsupported type '"+e+"'")}}(i,n),a);t(e)}catch(e){r(e)}n=[]}).resume()})}function f(e,t,r){var n=t;switch(t){case"blob":case"arraybuffer":n="uint8array";break;case"base64":n="string"}try{this._internalType=n,this._outputType=t,this._mimeType=r,h.checkSupport(n),this._worker=e.pipe(new i(n)),e.lock()}catch(e){this._worker=new s("error"),this._worker.error(e)}}f.prototype={accumulate:function(e){return l(this,e)},on:function(e,t){var r=this;return"data"===e?this._worker.on(e,function(e){t.call(r,e.data,e.meta)}):this._worker.on(e,function(){h.delay(t,arguments,r)}),this},resume:function(){return h.delay(this._worker.resume,[],this._worker),this},pause:function(){return this._worker.pause(),this},toNodejsStream:function(e){if(h.checkSupport("nodestream"),"nodebuffer"!==this._outputType)throw new Error(this._outputType+" is not supported by this method");return new o(this,{objectMode:"nodebuffer"!==this._outputType},e)}},t.exports=f},{"../base64":1,"../external":6,"../nodejs/NodejsStreamOutputAdapter":13,"../support":30,"../utils":32,"./ConvertWorker":24,"./GenericWorker":28}],30:[function(e,t,r){"use strict";if(r.base64=!0,r.array=!0,r.string=!0,r.arraybuffer="undefined"!=typeof ArrayBuffer&&"undefined"!=typeof Uint8Array,r.nodebuffer="undefined"!=typeof Buffer,r.uint8array="undefined"!=typeof Uint8Array,"undefined"==typeof ArrayBuffer)r.blob=!1;else{var n=new ArrayBuffer(0);try{r.blob=0===new Blob([n],{type:"application/zip"}).size}catch(e){try{var i=new(self.BlobBuilder||self.WebKitBlobBuilder||self.MozBlobBuilder||self.MSBlobBuilder);i.append(n),r.blob=0===i.getBlob("application/zip").size}catch(e){r.blob=!1}}}try{r.nodestream=!!e("readable-stream").Readable}catch(e){r.nodestream=!1}},{"readable-stream":16}],31:[function(e,t,s){"use strict";for(var o=e("./utils"),h=e("./support"),r=e("./nodejsUtils"),n=e("./stream/GenericWorker"),u=new Array(256),i=0;i<256;i++)u[i]=252<=i?6:248<=i?5:240<=i?4:224<=i?3:192<=i?2:1;u[254]=u[254]=1;function a(){n.call(this,"utf-8 decode"),this.leftOver=null}function l(){n.call(this,"utf-8 encode")}s.utf8encode=function(e){return h.nodebuffer?r.newBufferFrom(e,"utf-8"):function(e){var t,r,n,i,s,a=e.length,o=0;for(i=0;i<a;i++)55296==(64512&(r=e.charCodeAt(i)))&&i+1<a&&56320==(64512&(n=e.charCodeAt(i+1)))&&(r=65536+(r-55296<<10)+(n-56320),i++),o+=r<128?1:r<2048?2:r<65536?3:4;for(t=h.uint8array?new Uint8Array(o):new Array(o),i=s=0;s<o;i++)55296==(64512&(r=e.charCodeAt(i)))&&i+1<a&&56320==(64512&(n=e.charCodeAt(i+1)))&&(r=65536+(r-55296<<10)+(n-56320),i++),r<128?t[s++]=r:(r<2048?t[s++]=192|r>>>6:(r<65536?t[s++]=224|r>>>12:(t[s++]=240|r>>>18,t[s++]=128|r>>>12&63),t[s++]=128|r>>>6&63),t[s++]=128|63&r);return t}(e)},s.utf8decode=function(e){return h.nodebuffer?o.transformTo("nodebuffer",e).toString("utf-8"):function(e){var t,r,n,i,s=e.length,a=new Array(2*s);for(t=r=0;t<s;)if((n=e[t++])<128)a[r++]=n;else if(4<(i=u[n]))a[r++]=65533,t+=i-1;else{for(n&=2===i?31:3===i?15:7;1<i&&t<s;)n=n<<6|63&e[t++],i--;1<i?a[r++]=65533:n<65536?a[r++]=n:(n-=65536,a[r++]=55296|n>>10&1023,a[r++]=56320|1023&n)}return a.length!==r&&(a.subarray?a=a.subarray(0,r):a.length=r),o.applyFromCharCode(a)}(e=o.transformTo(h.uint8array?"uint8array":"array",e))},o.inherits(a,n),a.prototype.processChunk=function(e){var t=o.transformTo(h.uint8array?"uint8array":"array",e.data);if(this.leftOver&&this.leftOver.length){if(h.uint8array){var r=t;(t=new Uint8Array(r.length+this.leftOver.length)).set(this.leftOver,0),t.set(r,this.leftOver.length)}else t=this.leftOver.concat(t);this.leftOver=null}var n=function(e,t){var r;for((t=t||e.length)>e.length&&(t=e.length),r=t-1;0<=r&&128==(192&e[r]);)r--;return r<0?t:0===r?t:r+u[e[r]]>t?r:t}(t),i=t;n!==t.length&&(h.uint8array?(i=t.subarray(0,n),this.leftOver=t.subarray(n,t.length)):(i=t.slice(0,n),this.leftOver=t.slice(n,t.length))),this.push({data:s.utf8decode(i),meta:e.meta})},a.prototype.flush=function(){this.leftOver&&this.leftOver.length&&(this.push({data:s.utf8decode(this.leftOver),meta:{}}),this.leftOver=null)},s.Utf8DecodeWorker=a,o.inherits(l,n),l.prototype.processChunk=function(e){this.push({data:s.utf8encode(e.data),meta:e.meta})},s.Utf8EncodeWorker=l},{"./nodejsUtils":14,"./stream/GenericWorker":28,"./support":30,"./utils":32}],32:[function(e,t,a){"use strict";var o=e("./support"),h=e("./base64"),r=e("./nodejsUtils"),u=e("./external");function n(e){return e}function l(e,t){for(var r=0;r<e.length;++r)t[r]=255&e.charCodeAt(r);return t}e("setimmediate"),a.newBlob=function(t,r){a.checkSupport("blob");try{return new Blob([t],{type:r})}catch(e){try{var n=new(self.BlobBuilder||self.WebKitBlobBuilder||self.MozBlobBuilder||self.MSBlobBuilder);return n.append(t),n.getBlob(r)}catch(e){throw new Error("Bug : can't construct the Blob.")}}};var i={stringifyByChunk:function(e,t,r){var n=[],i=0,s=e.length;if(s<=r)return String.fromCharCode.apply(null,e);for(;i<s;)"array"===t||"nodebuffer"===t?n.push(String.fromCharCode.apply(null,e.slice(i,Math.min(i+r,s)))):n.push(String.fromCharCode.apply(null,e.subarray(i,Math.min(i+r,s)))),i+=r;return n.join("")},stringifyByChar:function(e){for(var t="",r=0;r<e.length;r++)t+=String.fromCharCode(e[r]);return t},applyCanBeUsed:{uint8array:function(){try{return o.uint8array&&1===String.fromCharCode.apply(null,new Uint8Array(1)).length}catch(e){return!1}}(),nodebuffer:function(){try{return o.nodebuffer&&1===String.fromCharCode.apply(null,r.allocBuffer(1)).length}catch(e){return!1}}()}};function s(e){var t=65536,r=a.getTypeOf(e),n=!0;if("uint8array"===r?n=i.applyCanBeUsed.uint8array:"nodebuffer"===r&&(n=i.applyCanBeUsed.nodebuffer),n)for(;1<t;)try{return i.stringifyByChunk(e,r,t)}catch(e){t=Math.floor(t/2)}return i.stringifyByChar(e)}function f(e,t){for(var r=0;r<e.length;r++)t[r]=e[r];return t}a.applyFromCharCode=s;var c={};c.string={string:n,array:function(e){return l(e,new Array(e.length))},arraybuffer:function(e){return c.string.uint8array(e).buffer},uint8array:function(e){return l(e,new Uint8Array(e.length))},nodebuffer:function(e){return l(e,r.allocBuffer(e.length))}},c.array={string:s,array:n,arraybuffer:function(e){return new Uint8Array(e).buffer},uint8array:function(e){return new Uint8Array(e)},nodebuffer:function(e){return r.newBufferFrom(e)}},c.arraybuffer={string:function(e){return s(new Uint8Array(e))},array:function(e){return f(new Uint8Array(e),new Array(e.byteLength))},arraybuffer:n,uint8array:function(e){return new Uint8Array(e)},nodebuffer:function(e){return r.newBufferFrom(new Uint8Array(e))}},c.uint8array={string:s,array:function(e){return f(e,new Array(e.length))},arraybuffer:function(e){return e.buffer},uint8array:n,nodebuffer:function(e){return r.newBufferFrom(e)}},c.nodebuffer={string:s,array:function(e){return f(e,new Array(e.length))},arraybuffer:function(e){return c.nodebuffer.uint8array(e).buffer},uint8array:function(e){return f(e,new Uint8Array(e.length))},nodebuffer:n},a.transformTo=function(e,t){if(t=t||"",!e)return t;a.checkSupport(e);var r=a.getTypeOf(t);return c[r][e](t)},a.resolve=function(e){for(var t=e.split("/"),r=[],n=0;n<t.length;n++){var i=t[n];"."===i||""===i&&0!==n&&n!==t.length-1||(".."===i?r.pop():r.push(i))}return r.join("/")},a.getTypeOf=function(e){return"string"==typeof e?"string":"[object Array]"===Object.prototype.toString.call(e)?"array":o.nodebuffer&&r.isBuffer(e)?"nodebuffer":o.uint8array&&e instanceof Uint8Array?"uint8array":o.arraybuffer&&e instanceof ArrayBuffer?"arraybuffer":void 0},a.checkSupport=function(e){if(!o[e.toLowerCase()])throw new Error(e+" is not supported by this platform")},a.MAX_VALUE_16BITS=65535,a.MAX_VALUE_32BITS=-1,a.pretty=function(e){var t,r,n="";for(r=0;r<(e||"").length;r++)n+="\\x"+((t=e.charCodeAt(r))<16?"0":"")+t.toString(16).toUpperCase();return n},a.delay=function(e,t,r){setImmediate(function(){e.apply(r||null,t||[])})},a.inherits=function(e,t){function r(){}r.prototype=t.prototype,e.prototype=new r},a.extend=function(){var e,t,r={};for(e=0;e<arguments.length;e++)for(t in arguments[e])Object.prototype.hasOwnProperty.call(arguments[e],t)&&void 0===r[t]&&(r[t]=arguments[e][t]);return r},a.prepareContent=function(r,e,n,i,s){return u.Promise.resolve(e).then(function(n){return o.blob&&(n instanceof Blob||-1!==["[object File]","[object Blob]"].indexOf(Object.prototype.toString.call(n)))&&"undefined"!=typeof FileReader?new u.Promise(function(t,r){var e=new FileReader;e.onload=function(e){t(e.target.result)},e.onerror=function(e){r(e.target.error)},e.readAsArrayBuffer(n)}):n}).then(function(e){var t=a.getTypeOf(e);return t?("arraybuffer"===t?e=a.transformTo("uint8array",e):"string"===t&&(s?e=h.decode(e):n&&!0!==i&&(e=function(e){return l(e,o.uint8array?new Uint8Array(e.length):new Array(e.length))}(e))),e):u.Promise.reject(new Error("Can't read the data of '"+r+"'. Is it in a supported JavaScript type (String, Blob, ArrayBuffer, etc) ?"))})}},{"./base64":1,"./external":6,"./nodejsUtils":14,"./support":30,setimmediate:54}],33:[function(e,t,r){"use strict";var n=e("./reader/readerFor"),i=e("./utils"),s=e("./signature"),a=e("./zipEntry"),o=e("./support");function h(e){this.files=[],this.loadOptions=e}h.prototype={checkSignature:function(e){if(!this.reader.readAndCheckSignature(e)){this.reader.index-=4;var t=this.reader.readString(4);throw new Error("Corrupted zip or bug: unexpected signature ("+i.pretty(t)+", expected "+i.pretty(e)+")")}},isSignature:function(e,t){var r=this.reader.index;this.reader.setIndex(e);var n=this.reader.readString(4)===t;return this.reader.setIndex(r),n},readBlockEndOfCentral:function(){this.diskNumber=this.reader.readInt(2),this.diskWithCentralDirStart=this.reader.readInt(2),this.centralDirRecordsOnThisDisk=this.reader.readInt(2),this.centralDirRecords=this.reader.readInt(2),this.centralDirSize=this.reader.readInt(4),this.centralDirOffset=this.reader.readInt(4),this.zipCommentLength=this.reader.readInt(2);var e=this.reader.readData(this.zipCommentLength),t=o.uint8array?"uint8array":"array",r=i.transformTo(t,e);this.zipComment=this.loadOptions.decodeFileName(r)},readBlockZip64EndOfCentral:function(){this.zip64EndOfCentralSize=this.reader.readInt(8),this.reader.skip(4),this.diskNumber=this.reader.readInt(4),this.diskWithCentralDirStart=this.reader.readInt(4),this.centralDirRecordsOnThisDisk=this.reader.readInt(8),this.centralDirRecords=this.reader.readInt(8),this.centralDirSize=this.reader.readInt(8),this.centralDirOffset=this.reader.readInt(8),this.zip64ExtensibleData={};for(var e,t,r,n=this.zip64EndOfCentralSize-44;0<n;)e=this.reader.readInt(2),t=this.reader.readInt(4),r=this.reader.readData(t),this.zip64ExtensibleData[e]={id:e,length:t,value:r}},readBlockZip64EndOfCentralLocator:function(){if(this.diskWithZip64CentralDirStart=this.reader.readInt(4),this.relativeOffsetEndOfZip64CentralDir=this.reader.readInt(8),this.disksCount=this.reader.readInt(4),1<this.disksCount)throw new Error("Multi-volumes zip are not supported")},readLocalFiles:function(){var e,t;for(e=0;e<this.files.length;e++)t=this.files[e],this.reader.setIndex(t.localHeaderOffset),this.checkSignature(s.LOCAL_FILE_HEADER),t.readLocalPart(this.reader),t.handleUTF8(),t.processAttributes()},readCentralDir:function(){var e;for(this.reader.setIndex(this.centralDirOffset);this.reader.readAndCheckSignature(s.CENTRAL_FILE_HEADER);)(e=new a({zip64:this.zip64},this.loadOptions)).readCentralPart(this.reader),this.files.push(e);if(this.centralDirRecords!==this.files.length&&0!==this.centralDirRecords&&0===this.files.length)throw new Error("Corrupted zip or bug: expected "+this.centralDirRecords+" records in central dir, got "+this.files.length)},readEndOfCentral:function(){var e=this.reader.lastIndexOfSignature(s.CENTRAL_DIRECTORY_END);if(e<0)throw!this.isSignature(0,s.LOCAL_FILE_HEADER)?new Error("Can't find end of central directory : is this a zip file ? If it is, see https://stuk.github.io/jszip/documentation/howto/read_zip.html"):new Error("Corrupted zip: can't find end of central directory");this.reader.setIndex(e);var t=e;if(this.checkSignature(s.CENTRAL_DIRECTORY_END),this.readBlockEndOfCentral(),this.diskNumber===i.MAX_VALUE_16BITS||this.diskWithCentralDirStart===i.MAX_VALUE_16BITS||this.centralDirRecordsOnThisDisk===i.MAX_VALUE_16BITS||this.centralDirRecords===i.MAX_VALUE_16BITS||this.centralDirSize===i.MAX_VALUE_32BITS||this.centralDirOffset===i.MAX_VALUE_32BITS){if(this.zip64=!0,(e=this.reader.lastIndexOfSignature(s.ZIP64_CENTRAL_DIRECTORY_LOCATOR))<0)throw new Error("Corrupted zip: can't find the ZIP64 end of central directory locator");if(this.reader.setIndex(e),this.checkSignature(s.ZIP64_CENTRAL_DIRECTORY_LOCATOR),this.readBlockZip64EndOfCentralLocator(),!this.isSignature(this.relativeOffsetEndOfZip64CentralDir,s.ZIP64_CENTRAL_DIRECTORY_END)&&(this.relativeOffsetEndOfZip64CentralDir=this.reader.lastIndexOfSignature(s.ZIP64_CENTRAL_DIRECTORY_END),this.relativeOffsetEndOfZip64CentralDir<0))throw new Error("Corrupted zip: can't find the ZIP64 end of central directory");this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir),this.checkSignature(s.ZIP64_CENTRAL_DIRECTORY_END),this.readBlockZip64EndOfCentral()}var r=this.centralDirOffset+this.centralDirSize;this.zip64&&(r+=20,r+=12+this.zip64EndOfCentralSize);var n=t-r;if(0<n)this.isSignature(t,s.CENTRAL_FILE_HEADER)||(this.reader.zero=n);else if(n<0)throw new Error("Corrupted zip: missing "+Math.abs(n)+" bytes.")},prepareReader:function(e){this.reader=n(e)},load:function(e){this.prepareReader(e),this.readEndOfCentral(),this.readCentralDir(),this.readLocalFiles()}},t.exports=h},{"./reader/readerFor":22,"./signature":23,"./support":30,"./utils":32,"./zipEntry":34}],34:[function(e,t,r){"use strict";var n=e("./reader/readerFor"),s=e("./utils"),i=e("./compressedObject"),a=e("./crc32"),o=e("./utf8"),h=e("./compressions"),u=e("./support");function l(e,t){this.options=e,this.loadOptions=t}l.prototype={isEncrypted:function(){return 1==(1&this.bitFlag)},useUTF8:function(){return 2048==(2048&this.bitFlag)},readLocalPart:function(e){var t,r;if(e.skip(22),this.fileNameLength=e.readInt(2),r=e.readInt(2),this.fileName=e.readData(this.fileNameLength),e.skip(r),-1===this.compressedSize||-1===this.uncompressedSize)throw new Error("Bug or corrupted zip : didn't get enough information from the central directory (compressedSize === -1 || uncompressedSize === -1)");if(null===(t=function(e){for(var t in h)if(Object.prototype.hasOwnProperty.call(h,t)&&h[t].magic===e)return h[t];return null}(this.compressionMethod)))throw new Error("Corrupted zip : compression "+s.pretty(this.compressionMethod)+" unknown (inner file : "+s.transformTo("string",this.fileName)+")");this.decompressed=new i(this.compressedSize,this.uncompressedSize,this.crc32,t,e.readData(this.compressedSize))},readCentralPart:function(e){this.versionMadeBy=e.readInt(2),e.skip(2),this.bitFlag=e.readInt(2),this.compressionMethod=e.readString(2),this.date=e.readDate(),this.crc32=e.readInt(4),this.compressedSize=e.readInt(4),this.uncompressedSize=e.readInt(4);var t=e.readInt(2);if(this.extraFieldsLength=e.readInt(2),this.fileCommentLength=e.readInt(2),this.diskNumberStart=e.readInt(2),this.internalFileAttributes=e.readInt(2),this.externalFileAttributes=e.readInt(4),this.localHeaderOffset=e.readInt(4),this.isEncrypted())throw new Error("Encrypted zip are not supported");e.skip(t),this.readExtraFields(e),this.parseZIP64ExtraField(e),this.fileComment=e.readData(this.fileCommentLength)},processAttributes:function(){this.unixPermissions=null,this.dosPermissions=null;var e=this.versionMadeBy>>8;this.dir=!!(16&this.externalFileAttributes),0==e&&(this.dosPermissions=63&this.externalFileAttributes),3==e&&(this.unixPermissions=this.externalFileAttributes>>16&65535),this.dir||"/"!==this.fileNameStr.slice(-1)||(this.dir=!0)},parseZIP64ExtraField:function(){if(this.extraFields[1]){var e=n(this.extraFields[1].value);this.uncompressedSize===s.MAX_VALUE_32BITS&&(this.uncompressedSize=e.readInt(8)),this.compressedSize===s.MAX_VALUE_32BITS&&(this.compressedSize=e.readInt(8)),this.localHeaderOffset===s.MAX_VALUE_32BITS&&(this.localHeaderOffset=e.readInt(8)),this.diskNumberStart===s.MAX_VALUE_32BITS&&(this.diskNumberStart=e.readInt(4))}},readExtraFields:function(e){var t,r,n,i=e.index+this.extraFieldsLength;for(this.extraFields||(this.extraFields={});e.index+4<i;)t=e.readInt(2),r=e.readInt(2),n=e.readData(r),this.extraFields[t]={id:t,length:r,value:n};e.setIndex(i)},handleUTF8:function(){var e=u.uint8array?"uint8array":"array";if(this.useUTF8())this.fileNameStr=o.utf8decode(this.fileName),this.fileCommentStr=o.utf8decode(this.fileComment);else{var t=this.findExtraFieldUnicodePath();if(null!==t)this.fileNameStr=t;else{var r=s.transformTo(e,this.fileName);this.fileNameStr=this.loadOptions.decodeFileName(r)}var n=this.findExtraFieldUnicodeComment();if(null!==n)this.fileCommentStr=n;else{var i=s.transformTo(e,this.fileComment);this.fileCommentStr=this.loadOptions.decodeFileName(i)}}},findExtraFieldUnicodePath:function(){var e=this.extraFields[28789];if(e){var t=n(e.value);return 1!==t.readInt(1)?null:a(this.fileName)!==t.readInt(4)?null:o.utf8decode(t.readData(e.length-5))}return null},findExtraFieldUnicodeComment:function(){var e=this.extraFields[25461];if(e){var t=n(e.value);return 1!==t.readInt(1)?null:a(this.fileComment)!==t.readInt(4)?null:o.utf8decode(t.readData(e.length-5))}return null}},t.exports=l},{"./compressedObject":2,"./compressions":3,"./crc32":4,"./reader/readerFor":22,"./support":30,"./utf8":31,"./utils":32}],35:[function(e,t,r){"use strict";function n(e,t,r){this.name=e,this.dir=r.dir,this.date=r.date,this.comment=r.comment,this.unixPermissions=r.unixPermissions,this.dosPermissions=r.dosPermissions,this._data=t,this._dataBinary=r.binary,this.options={compression:r.compression,compressionOptions:r.compressionOptions}}var s=e("./stream/StreamHelper"),i=e("./stream/DataWorker"),a=e("./utf8"),o=e("./compressedObject"),h=e("./stream/GenericWorker");n.prototype={internalStream:function(e){var t=null,r="string";try{if(!e)throw new Error("No output type specified.");var n="string"===(r=e.toLowerCase())||"text"===r;"binarystring"!==r&&"text"!==r||(r="string"),t=this._decompressWorker();var i=!this._dataBinary;i&&!n&&(t=t.pipe(new a.Utf8EncodeWorker)),!i&&n&&(t=t.pipe(new a.Utf8DecodeWorker))}catch(e){(t=new h("error")).error(e)}return new s(t,r,"")},async:function(e,t){return this.internalStream(e).accumulate(t)},nodeStream:function(e,t){return this.internalStream(e||"nodebuffer").toNodejsStream(t)},_compressWorker:function(e,t){if(this._data instanceof o&&this._data.compression.magic===e.magic)return this._data.getCompressedWorker();var r=this._decompressWorker();return this._dataBinary||(r=r.pipe(new a.Utf8EncodeWorker)),o.createWorkerFrom(r,e,t)},_decompressWorker:function(){return this._data instanceof o?this._data.getContentWorker():this._data instanceof h?this._data:new i(this._data)}};for(var u=["asText","asBinary","asNodeBuffer","asUint8Array","asArrayBuffer"],l=function(){throw new Error("This method has been removed in JSZip 3.0, please check the upgrade guide.")},f=0;f<u.length;f++)n.prototype[u[f]]=l;t.exports=n},{"./compressedObject":2,"./stream/DataWorker":27,"./stream/GenericWorker":28,"./stream/StreamHelper":29,"./utf8":31}],36:[function(e,l,t){(function(t){"use strict";var r,n,e=t.MutationObserver||t.WebKitMutationObserver;if(e){var i=0,s=new e(u),a=t.document.createTextNode("");s.observe(a,{characterData:!0}),r=function(){a.data=i=++i%2}}else if(t.setImmediate||void 0===t.MessageChannel)r="document"in t&&"onreadystatechange"in t.document.createElement("script")?function(){var e=t.document.createElement("script");e.onreadystatechange=function(){u(),e.onreadystatechange=null,e.parentNode.removeChild(e),e=null},t.document.documentElement.appendChild(e)}:function(){setTimeout(u,0)};else{var o=new t.MessageChannel;o.port1.onmessage=u,r=function(){o.port2.postMessage(0)}}var h=[];function u(){var e,t;n=!0;for(var r=h.length;r;){for(t=h,h=[],e=-1;++e<r;)t[e]();r=h.length}n=!1}l.exports=function(e){1!==h.push(e)||n||r()}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],37:[function(e,t,r){"use strict";var i=e("immediate");function u(){}var l={},s=["REJECTED"],a=["FULFILLED"],n=["PENDING"];function o(e){if("function"!=typeof e)throw new TypeError("resolver must be a function");this.state=n,this.queue=[],this.outcome=void 0,e!==u&&d(this,e)}function h(e,t,r){this.promise=e,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof r&&(this.onRejected=r,this.callRejected=this.otherCallRejected)}function f(t,r,n){i(function(){var e;try{e=r(n)}catch(e){return l.reject(t,e)}e===t?l.reject(t,new TypeError("Cannot resolve promise with itself")):l.resolve(t,e)})}function c(e){var t=e&&e.then;if(e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof t)return function(){t.apply(e,arguments)}}function d(t,e){var r=!1;function n(e){r||(r=!0,l.reject(t,e))}function i(e){r||(r=!0,l.resolve(t,e))}var s=p(function(){e(i,n)});"error"===s.status&&n(s.value)}function p(e,t){var r={};try{r.value=e(t),r.status="success"}catch(e){r.status="error",r.value=e}return r}(t.exports=o).prototype.finally=function(t){if("function"!=typeof t)return this;var r=this.constructor;return this.then(function(e){return r.resolve(t()).then(function(){return e})},function(e){return r.resolve(t()).then(function(){throw e})})},o.prototype.catch=function(e){return this.then(null,e)},o.prototype.then=function(e,t){if("function"!=typeof e&&this.state===a||"function"!=typeof t&&this.state===s)return this;var r=new this.constructor(u);this.state!==n?f(r,this.state===a?e:t,this.outcome):this.queue.push(new h(r,e,t));return r},h.prototype.callFulfilled=function(e){l.resolve(this.promise,e)},h.prototype.otherCallFulfilled=function(e){f(this.promise,this.onFulfilled,e)},h.prototype.callRejected=function(e){l.reject(this.promise,e)},h.prototype.otherCallRejected=function(e){f(this.promise,this.onRejected,e)},l.resolve=function(e,t){var r=p(c,t);if("error"===r.status)return l.reject(e,r.value);var n=r.value;if(n)d(e,n);else{e.state=a,e.outcome=t;for(var i=-1,s=e.queue.length;++i<s;)e.queue[i].callFulfilled(t)}return e},l.reject=function(e,t){e.state=s,e.outcome=t;for(var r=-1,n=e.queue.length;++r<n;)e.queue[r].callRejected(t);return e},o.resolve=function(e){if(e instanceof this)return e;return l.resolve(new this(u),e)},o.reject=function(e){var t=new this(u);return l.reject(t,e)},o.all=function(e){var r=this;if("[object Array]"!==Object.prototype.toString.call(e))return this.reject(new TypeError("must be an array"));var n=e.length,i=!1;if(!n)return this.resolve([]);var s=new Array(n),a=0,t=-1,o=new this(u);for(;++t<n;)h(e[t],t);return o;function h(e,t){r.resolve(e).then(function(e){s[t]=e,++a!==n||i||(i=!0,l.resolve(o,s))},function(e){i||(i=!0,l.reject(o,e))})}},o.race=function(e){var t=this;if("[object Array]"!==Object.prototype.toString.call(e))return this.reject(new TypeError("must be an array"));var r=e.length,n=!1;if(!r)return this.resolve([]);var i=-1,s=new this(u);for(;++i<r;)a=e[i],t.resolve(a).then(function(e){n||(n=!0,l.resolve(s,e))},function(e){n||(n=!0,l.reject(s,e))});var a;return s}},{immediate:36}],38:[function(e,t,r){"use strict";var n={};(0,e("./lib/utils/common").assign)(n,e("./lib/deflate"),e("./lib/inflate"),e("./lib/zlib/constants")),t.exports=n},{"./lib/deflate":39,"./lib/inflate":40,"./lib/utils/common":41,"./lib/zlib/constants":44}],39:[function(e,t,r){"use strict";var a=e("./zlib/deflate"),o=e("./utils/common"),h=e("./utils/strings"),i=e("./zlib/messages"),s=e("./zlib/zstream"),u=Object.prototype.toString,l=0,f=-1,c=0,d=8;function p(e){if(!(this instanceof p))return new p(e);this.options=o.assign({level:f,method:d,chunkSize:16384,windowBits:15,memLevel:8,strategy:c,to:""},e||{});var t=this.options;t.raw&&0<t.windowBits?t.windowBits=-t.windowBits:t.gzip&&0<t.windowBits&&t.windowBits<16&&(t.windowBits+=16),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new s,this.strm.avail_out=0;var r=a.deflateInit2(this.strm,t.level,t.method,t.windowBits,t.memLevel,t.strategy);if(r!==l)throw new Error(i[r]);if(t.header&&a.deflateSetHeader(this.strm,t.header),t.dictionary){var n;if(n="string"==typeof t.dictionary?h.string2buf(t.dictionary):"[object ArrayBuffer]"===u.call(t.dictionary)?new Uint8Array(t.dictionary):t.dictionary,(r=a.deflateSetDictionary(this.strm,n))!==l)throw new Error(i[r]);this._dict_set=!0}}function n(e,t){var r=new p(t);if(r.push(e,!0),r.err)throw r.msg||i[r.err];return r.result}p.prototype.push=function(e,t){var r,n,i=this.strm,s=this.options.chunkSize;if(this.ended)return!1;n=t===~~t?t:!0===t?4:0,"string"==typeof e?i.input=h.string2buf(e):"[object ArrayBuffer]"===u.call(e)?i.input=new Uint8Array(e):i.input=e,i.next_in=0,i.avail_in=i.input.length;do{if(0===i.avail_out&&(i.output=new o.Buf8(s),i.next_out=0,i.avail_out=s),1!==(r=a.deflate(i,n))&&r!==l)return this.onEnd(r),!(this.ended=!0);0!==i.avail_out&&(0!==i.avail_in||4!==n&&2!==n)||("string"===this.options.to?this.onData(h.buf2binstring(o.shrinkBuf(i.output,i.next_out))):this.onData(o.shrinkBuf(i.output,i.next_out)))}while((0<i.avail_in||0===i.avail_out)&&1!==r);return 4===n?(r=a.deflateEnd(this.strm),this.onEnd(r),this.ended=!0,r===l):2!==n||(this.onEnd(l),!(i.avail_out=0))},p.prototype.onData=function(e){this.chunks.push(e)},p.prototype.onEnd=function(e){e===l&&("string"===this.options.to?this.result=this.chunks.join(""):this.result=o.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg},r.Deflate=p,r.deflate=n,r.deflateRaw=function(e,t){return(t=t||{}).raw=!0,n(e,t)},r.gzip=function(e,t){return(t=t||{}).gzip=!0,n(e,t)}},{"./utils/common":41,"./utils/strings":42,"./zlib/deflate":46,"./zlib/messages":51,"./zlib/zstream":53}],40:[function(e,t,r){"use strict";var c=e("./zlib/inflate"),d=e("./utils/common"),p=e("./utils/strings"),m=e("./zlib/constants"),n=e("./zlib/messages"),i=e("./zlib/zstream"),s=e("./zlib/gzheader"),_=Object.prototype.toString;function a(e){if(!(this instanceof a))return new a(e);this.options=d.assign({chunkSize:16384,windowBits:0,to:""},e||{});var t=this.options;t.raw&&0<=t.windowBits&&t.windowBits<16&&(t.windowBits=-t.windowBits,0===t.windowBits&&(t.windowBits=-15)),!(0<=t.windowBits&&t.windowBits<16)||e&&e.windowBits||(t.windowBits+=32),15<t.windowBits&&t.windowBits<48&&0==(15&t.windowBits)&&(t.windowBits|=15),this.err=0,this.msg="",this.ended=!1,this.chunks=[],this.strm=new i,this.strm.avail_out=0;var r=c.inflateInit2(this.strm,t.windowBits);if(r!==m.Z_OK)throw new Error(n[r]);this.header=new s,c.inflateGetHeader(this.strm,this.header)}function o(e,t){var r=new a(t);if(r.push(e,!0),r.err)throw r.msg||n[r.err];return r.result}a.prototype.push=function(e,t){var r,n,i,s,a,o,h=this.strm,u=this.options.chunkSize,l=this.options.dictionary,f=!1;if(this.ended)return!1;n=t===~~t?t:!0===t?m.Z_FINISH:m.Z_NO_FLUSH,"string"==typeof e?h.input=p.binstring2buf(e):"[object ArrayBuffer]"===_.call(e)?h.input=new Uint8Array(e):h.input=e,h.next_in=0,h.avail_in=h.input.length;do{if(0===h.avail_out&&(h.output=new d.Buf8(u),h.next_out=0,h.avail_out=u),(r=c.inflate(h,m.Z_NO_FLUSH))===m.Z_NEED_DICT&&l&&(o="string"==typeof l?p.string2buf(l):"[object ArrayBuffer]"===_.call(l)?new Uint8Array(l):l,r=c.inflateSetDictionary(this.strm,o)),r===m.Z_BUF_ERROR&&!0===f&&(r=m.Z_OK,f=!1),r!==m.Z_STREAM_END&&r!==m.Z_OK)return this.onEnd(r),!(this.ended=!0);h.next_out&&(0!==h.avail_out&&r!==m.Z_STREAM_END&&(0!==h.avail_in||n!==m.Z_FINISH&&n!==m.Z_SYNC_FLUSH)||("string"===this.options.to?(i=p.utf8border(h.output,h.next_out),s=h.next_out-i,a=p.buf2string(h.output,i),h.next_out=s,h.avail_out=u-s,s&&d.arraySet(h.output,h.output,i,s,0),this.onData(a)):this.onData(d.shrinkBuf(h.output,h.next_out)))),0===h.avail_in&&0===h.avail_out&&(f=!0)}while((0<h.avail_in||0===h.avail_out)&&r!==m.Z_STREAM_END);return r===m.Z_STREAM_END&&(n=m.Z_FINISH),n===m.Z_FINISH?(r=c.inflateEnd(this.strm),this.onEnd(r),this.ended=!0,r===m.Z_OK):n!==m.Z_SYNC_FLUSH||(this.onEnd(m.Z_OK),!(h.avail_out=0))},a.prototype.onData=function(e){this.chunks.push(e)},a.prototype.onEnd=function(e){e===m.Z_OK&&("string"===this.options.to?this.result=this.chunks.join(""):this.result=d.flattenChunks(this.chunks)),this.chunks=[],this.err=e,this.msg=this.strm.msg},r.Inflate=a,r.inflate=o,r.inflateRaw=function(e,t){return(t=t||{}).raw=!0,o(e,t)},r.ungzip=o},{"./utils/common":41,"./utils/strings":42,"./zlib/constants":44,"./zlib/gzheader":47,"./zlib/inflate":49,"./zlib/messages":51,"./zlib/zstream":53}],41:[function(e,t,r){"use strict";var n="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Int32Array;r.assign=function(e){for(var t=Array.prototype.slice.call(arguments,1);t.length;){var r=t.shift();if(r){if("object"!=typeof r)throw new TypeError(r+"must be non-object");for(var n in r)r.hasOwnProperty(n)&&(e[n]=r[n])}}return e},r.shrinkBuf=function(e,t){return e.length===t?e:e.subarray?e.subarray(0,t):(e.length=t,e)};var i={arraySet:function(e,t,r,n,i){if(t.subarray&&e.subarray)e.set(t.subarray(r,r+n),i);else for(var s=0;s<n;s++)e[i+s]=t[r+s]},flattenChunks:function(e){var t,r,n,i,s,a;for(t=n=0,r=e.length;t<r;t++)n+=e[t].length;for(a=new Uint8Array(n),t=i=0,r=e.length;t<r;t++)s=e[t],a.set(s,i),i+=s.length;return a}},s={arraySet:function(e,t,r,n,i){for(var s=0;s<n;s++)e[i+s]=t[r+s]},flattenChunks:function(e){return[].concat.apply([],e)}};r.setTyped=function(e){e?(r.Buf8=Uint8Array,r.Buf16=Uint16Array,r.Buf32=Int32Array,r.assign(r,i)):(r.Buf8=Array,r.Buf16=Array,r.Buf32=Array,r.assign(r,s))},r.setTyped(n)},{}],42:[function(e,t,r){"use strict";var h=e("./common"),i=!0,s=!0;try{String.fromCharCode.apply(null,[0])}catch(e){i=!1}try{String.fromCharCode.apply(null,new Uint8Array(1))}catch(e){s=!1}for(var u=new h.Buf8(256),n=0;n<256;n++)u[n]=252<=n?6:248<=n?5:240<=n?4:224<=n?3:192<=n?2:1;function l(e,t){if(t<65537&&(e.subarray&&s||!e.subarray&&i))return String.fromCharCode.apply(null,h.shrinkBuf(e,t));for(var r="",n=0;n<t;n++)r+=String.fromCharCode(e[n]);return r}u[254]=u[254]=1,r.string2buf=function(e){var t,r,n,i,s,a=e.length,o=0;for(i=0;i<a;i++)55296==(64512&(r=e.charCodeAt(i)))&&i+1<a&&56320==(64512&(n=e.charCodeAt(i+1)))&&(r=65536+(r-55296<<10)+(n-56320),i++),o+=r<128?1:r<2048?2:r<65536?3:4;for(t=new h.Buf8(o),i=s=0;s<o;i++)55296==(64512&(r=e.charCodeAt(i)))&&i+1<a&&56320==(64512&(n=e.charCodeAt(i+1)))&&(r=65536+(r-55296<<10)+(n-56320),i++),r<128?t[s++]=r:(r<2048?t[s++]=192|r>>>6:(r<65536?t[s++]=224|r>>>12:(t[s++]=240|r>>>18,t[s++]=128|r>>>12&63),t[s++]=128|r>>>6&63),t[s++]=128|63&r);return t},r.buf2binstring=function(e){return l(e,e.length)},r.binstring2buf=function(e){for(var t=new h.Buf8(e.length),r=0,n=t.length;r<n;r++)t[r]=e.charCodeAt(r);return t},r.buf2string=function(e,t){var r,n,i,s,a=t||e.length,o=new Array(2*a);for(r=n=0;r<a;)if((i=e[r++])<128)o[n++]=i;else if(4<(s=u[i]))o[n++]=65533,r+=s-1;else{for(i&=2===s?31:3===s?15:7;1<s&&r<a;)i=i<<6|63&e[r++],s--;1<s?o[n++]=65533:i<65536?o[n++]=i:(i-=65536,o[n++]=55296|i>>10&1023,o[n++]=56320|1023&i)}return l(o,n)},r.utf8border=function(e,t){var r;for((t=t||e.length)>e.length&&(t=e.length),r=t-1;0<=r&&128==(192&e[r]);)r--;return r<0?t:0===r?t:r+u[e[r]]>t?r:t}},{"./common":41}],43:[function(e,t,r){"use strict";t.exports=function(e,t,r,n){for(var i=65535&e|0,s=e>>>16&65535|0,a=0;0!==r;){for(r-=a=2e3<r?2e3:r;s=s+(i=i+t[n++]|0)|0,--a;);i%=65521,s%=65521}return i|s<<16|0}},{}],44:[function(e,t,r){"use strict";t.exports={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8}},{}],45:[function(e,t,r){"use strict";var o=function(){for(var e,t=[],r=0;r<256;r++){e=r;for(var n=0;n<8;n++)e=1&e?3988292384^e>>>1:e>>>1;t[r]=e}return t}();t.exports=function(e,t,r,n){var i=o,s=n+r;e^=-1;for(var a=n;a<s;a++)e=e>>>8^i[255&(e^t[a])];return-1^e}},{}],46:[function(e,t,r){"use strict";var h,c=e("../utils/common"),u=e("./trees"),d=e("./adler32"),p=e("./crc32"),n=e("./messages"),l=0,f=4,m=0,_=-2,g=-1,b=4,i=2,v=8,y=9,s=286,a=30,o=19,w=2*s+1,k=15,x=3,S=258,z=S+x+1,C=42,E=113,A=1,I=2,O=3,B=4;function R(e,t){return e.msg=n[t],t}function T(e){return(e<<1)-(4<e?9:0)}function D(e){for(var t=e.length;0<=--t;)e[t]=0}function F(e){var t=e.state,r=t.pending;r>e.avail_out&&(r=e.avail_out),0!==r&&(c.arraySet(e.output,t.pending_buf,t.pending_out,r,e.next_out),e.next_out+=r,t.pending_out+=r,e.total_out+=r,e.avail_out-=r,t.pending-=r,0===t.pending&&(t.pending_out=0))}function N(e,t){u._tr_flush_block(e,0<=e.block_start?e.block_start:-1,e.strstart-e.block_start,t),e.block_start=e.strstart,F(e.strm)}function U(e,t){e.pending_buf[e.pending++]=t}function P(e,t){e.pending_buf[e.pending++]=t>>>8&255,e.pending_buf[e.pending++]=255&t}function L(e,t){var r,n,i=e.max_chain_length,s=e.strstart,a=e.prev_length,o=e.nice_match,h=e.strstart>e.w_size-z?e.strstart-(e.w_size-z):0,u=e.window,l=e.w_mask,f=e.prev,c=e.strstart+S,d=u[s+a-1],p=u[s+a];e.prev_length>=e.good_match&&(i>>=2),o>e.lookahead&&(o=e.lookahead);do{if(u[(r=t)+a]===p&&u[r+a-1]===d&&u[r]===u[s]&&u[++r]===u[s+1]){s+=2,r++;do{}while(u[++s]===u[++r]&&u[++s]===u[++r]&&u[++s]===u[++r]&&u[++s]===u[++r]&&u[++s]===u[++r]&&u[++s]===u[++r]&&u[++s]===u[++r]&&u[++s]===u[++r]&&s<c);if(n=S-(c-s),s=c-S,a<n){if(e.match_start=t,o<=(a=n))break;d=u[s+a-1],p=u[s+a]}}}while((t=f[t&l])>h&&0!=--i);return a<=e.lookahead?a:e.lookahead}function j(e){var t,r,n,i,s,a,o,h,u,l,f=e.w_size;do{if(i=e.window_size-e.lookahead-e.strstart,e.strstart>=f+(f-z)){for(c.arraySet(e.window,e.window,f,f,0),e.match_start-=f,e.strstart-=f,e.block_start-=f,t=r=e.hash_size;n=e.head[--t],e.head[t]=f<=n?n-f:0,--r;);for(t=r=f;n=e.prev[--t],e.prev[t]=f<=n?n-f:0,--r;);i+=f}if(0===e.strm.avail_in)break;if(a=e.strm,o=e.window,h=e.strstart+e.lookahead,u=i,l=void 0,l=a.avail_in,u<l&&(l=u),r=0===l?0:(a.avail_in-=l,c.arraySet(o,a.input,a.next_in,l,h),1===a.state.wrap?a.adler=d(a.adler,o,l,h):2===a.state.wrap&&(a.adler=p(a.adler,o,l,h)),a.next_in+=l,a.total_in+=l,l),e.lookahead+=r,e.lookahead+e.insert>=x)for(s=e.strstart-e.insert,e.ins_h=e.window[s],e.ins_h=(e.ins_h<<e.hash_shift^e.window[s+1])&e.hash_mask;e.insert&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[s+x-1])&e.hash_mask,e.prev[s&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=s,s++,e.insert--,!(e.lookahead+e.insert<x)););}while(e.lookahead<z&&0!==e.strm.avail_in)}function Z(e,t){for(var r,n;;){if(e.lookahead<z){if(j(e),e.lookahead<z&&t===l)return A;if(0===e.lookahead)break}if(r=0,e.lookahead>=x&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+x-1])&e.hash_mask,r=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart),0!==r&&e.strstart-r<=e.w_size-z&&(e.match_length=L(e,r)),e.match_length>=x)if(n=u._tr_tally(e,e.strstart-e.match_start,e.match_length-x),e.lookahead-=e.match_length,e.match_length<=e.max_lazy_match&&e.lookahead>=x){for(e.match_length--;e.strstart++,e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+x-1])&e.hash_mask,r=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart,0!=--e.match_length;);e.strstart++}else e.strstart+=e.match_length,e.match_length=0,e.ins_h=e.window[e.strstart],e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+1])&e.hash_mask;else n=u._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++;if(n&&(N(e,!1),0===e.strm.avail_out))return A}return e.insert=e.strstart<x-1?e.strstart:x-1,t===f?(N(e,!0),0===e.strm.avail_out?O:B):e.last_lit&&(N(e,!1),0===e.strm.avail_out)?A:I}function W(e,t){for(var r,n,i;;){if(e.lookahead<z){if(j(e),e.lookahead<z&&t===l)return A;if(0===e.lookahead)break}if(r=0,e.lookahead>=x&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+x-1])&e.hash_mask,r=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart),e.prev_length=e.match_length,e.prev_match=e.match_start,e.match_length=x-1,0!==r&&e.prev_length<e.max_lazy_match&&e.strstart-r<=e.w_size-z&&(e.match_length=L(e,r),e.match_length<=5&&(1===e.strategy||e.match_length===x&&4096<e.strstart-e.match_start)&&(e.match_length=x-1)),e.prev_length>=x&&e.match_length<=e.prev_length){for(i=e.strstart+e.lookahead-x,n=u._tr_tally(e,e.strstart-1-e.prev_match,e.prev_length-x),e.lookahead-=e.prev_length-1,e.prev_length-=2;++e.strstart<=i&&(e.ins_h=(e.ins_h<<e.hash_shift^e.window[e.strstart+x-1])&e.hash_mask,r=e.prev[e.strstart&e.w_mask]=e.head[e.ins_h],e.head[e.ins_h]=e.strstart),0!=--e.prev_length;);if(e.match_available=0,e.match_length=x-1,e.strstart++,n&&(N(e,!1),0===e.strm.avail_out))return A}else if(e.match_available){if((n=u._tr_tally(e,0,e.window[e.strstart-1]))&&N(e,!1),e.strstart++,e.lookahead--,0===e.strm.avail_out)return A}else e.match_available=1,e.strstart++,e.lookahead--}return e.match_available&&(n=u._tr_tally(e,0,e.window[e.strstart-1]),e.match_available=0),e.insert=e.strstart<x-1?e.strstart:x-1,t===f?(N(e,!0),0===e.strm.avail_out?O:B):e.last_lit&&(N(e,!1),0===e.strm.avail_out)?A:I}function M(e,t,r,n,i){this.good_length=e,this.max_lazy=t,this.nice_length=r,this.max_chain=n,this.func=i}function H(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=v,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new c.Buf16(2*w),this.dyn_dtree=new c.Buf16(2*(2*a+1)),this.bl_tree=new c.Buf16(2*(2*o+1)),D(this.dyn_ltree),D(this.dyn_dtree),D(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new c.Buf16(k+1),this.heap=new c.Buf16(2*s+1),D(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new c.Buf16(2*s+1),D(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}function G(e){var t;return e&&e.state?(e.total_in=e.total_out=0,e.data_type=i,(t=e.state).pending=0,t.pending_out=0,t.wrap<0&&(t.wrap=-t.wrap),t.status=t.wrap?C:E,e.adler=2===t.wrap?0:1,t.last_flush=l,u._tr_init(t),m):R(e,_)}function K(e){var t=G(e);return t===m&&function(e){e.window_size=2*e.w_size,D(e.head),e.max_lazy_match=h[e.level].max_lazy,e.good_match=h[e.level].good_length,e.nice_match=h[e.level].nice_length,e.max_chain_length=h[e.level].max_chain,e.strstart=0,e.block_start=0,e.lookahead=0,e.insert=0,e.match_length=e.prev_length=x-1,e.match_available=0,e.ins_h=0}(e.state),t}function Y(e,t,r,n,i,s){if(!e)return _;var a=1;if(t===g&&(t=6),n<0?(a=0,n=-n):15<n&&(a=2,n-=16),i<1||y<i||r!==v||n<8||15<n||t<0||9<t||s<0||b<s)return R(e,_);8===n&&(n=9);var o=new H;return(e.state=o).strm=e,o.wrap=a,o.gzhead=null,o.w_bits=n,o.w_size=1<<o.w_bits,o.w_mask=o.w_size-1,o.hash_bits=i+7,o.hash_size=1<<o.hash_bits,o.hash_mask=o.hash_size-1,o.hash_shift=~~((o.hash_bits+x-1)/x),o.window=new c.Buf8(2*o.w_size),o.head=new c.Buf16(o.hash_size),o.prev=new c.Buf16(o.w_size),o.lit_bufsize=1<<i+6,o.pending_buf_size=4*o.lit_bufsize,o.pending_buf=new c.Buf8(o.pending_buf_size),o.d_buf=1*o.lit_bufsize,o.l_buf=3*o.lit_bufsize,o.level=t,o.strategy=s,o.method=r,K(e)}h=[new M(0,0,0,0,function(e,t){var r=65535;for(r>e.pending_buf_size-5&&(r=e.pending_buf_size-5);;){if(e.lookahead<=1){if(j(e),0===e.lookahead&&t===l)return A;if(0===e.lookahead)break}e.strstart+=e.lookahead,e.lookahead=0;var n=e.block_start+r;if((0===e.strstart||e.strstart>=n)&&(e.lookahead=e.strstart-n,e.strstart=n,N(e,!1),0===e.strm.avail_out))return A;if(e.strstart-e.block_start>=e.w_size-z&&(N(e,!1),0===e.strm.avail_out))return A}return e.insert=0,t===f?(N(e,!0),0===e.strm.avail_out?O:B):(e.strstart>e.block_start&&(N(e,!1),e.strm.avail_out),A)}),new M(4,4,8,4,Z),new M(4,5,16,8,Z),new M(4,6,32,32,Z),new M(4,4,16,16,W),new M(8,16,32,32,W),new M(8,16,128,128,W),new M(8,32,128,256,W),new M(32,128,258,1024,W),new M(32,258,258,4096,W)],r.deflateInit=function(e,t){return Y(e,t,v,15,8,0)},r.deflateInit2=Y,r.deflateReset=K,r.deflateResetKeep=G,r.deflateSetHeader=function(e,t){return e&&e.state?2!==e.state.wrap?_:(e.state.gzhead=t,m):_},r.deflate=function(e,t){var r,n,i,s;if(!e||!e.state||5<t||t<0)return e?R(e,_):_;if(n=e.state,!e.output||!e.input&&0!==e.avail_in||666===n.status&&t!==f)return R(e,0===e.avail_out?-5:_);if(n.strm=e,r=n.last_flush,n.last_flush=t,n.status===C)if(2===n.wrap)e.adler=0,U(n,31),U(n,139),U(n,8),n.gzhead?(U(n,(n.gzhead.text?1:0)+(n.gzhead.hcrc?2:0)+(n.gzhead.extra?4:0)+(n.gzhead.name?8:0)+(n.gzhead.comment?16:0)),U(n,255&n.gzhead.time),U(n,n.gzhead.time>>8&255),U(n,n.gzhead.time>>16&255),U(n,n.gzhead.time>>24&255),U(n,9===n.level?2:2<=n.strategy||n.level<2?4:0),U(n,255&n.gzhead.os),n.gzhead.extra&&n.gzhead.extra.length&&(U(n,255&n.gzhead.extra.length),U(n,n.gzhead.extra.length>>8&255)),n.gzhead.hcrc&&(e.adler=p(e.adler,n.pending_buf,n.pending,0)),n.gzindex=0,n.status=69):(U(n,0),U(n,0),U(n,0),U(n,0),U(n,0),U(n,9===n.level?2:2<=n.strategy||n.level<2?4:0),U(n,3),n.status=E);else{var a=v+(n.w_bits-8<<4)<<8;a|=(2<=n.strategy||n.level<2?0:n.level<6?1:6===n.level?2:3)<<6,0!==n.strstart&&(a|=32),a+=31-a%31,n.status=E,P(n,a),0!==n.strstart&&(P(n,e.adler>>>16),P(n,65535&e.adler)),e.adler=1}if(69===n.status)if(n.gzhead.extra){for(i=n.pending;n.gzindex<(65535&n.gzhead.extra.length)&&(n.pending!==n.pending_buf_size||(n.gzhead.hcrc&&n.pending>i&&(e.adler=p(e.adler,n.pending_buf,n.pending-i,i)),F(e),i=n.pending,n.pending!==n.pending_buf_size));)U(n,255&n.gzhead.extra[n.gzindex]),n.gzindex++;n.gzhead.hcrc&&n.pending>i&&(e.adler=p(e.adler,n.pending_buf,n.pending-i,i)),n.gzindex===n.gzhead.extra.length&&(n.gzindex=0,n.status=73)}else n.status=73;if(73===n.status)if(n.gzhead.name){i=n.pending;do{if(n.pending===n.pending_buf_size&&(n.gzhead.hcrc&&n.pending>i&&(e.adler=p(e.adler,n.pending_buf,n.pending-i,i)),F(e),i=n.pending,n.pending===n.pending_buf_size)){s=1;break}s=n.gzindex<n.gzhead.name.length?255&n.gzhead.name.charCodeAt(n.gzindex++):0,U(n,s)}while(0!==s);n.gzhead.hcrc&&n.pending>i&&(e.adler=p(e.adler,n.pending_buf,n.pending-i,i)),0===s&&(n.gzindex=0,n.status=91)}else n.status=91;if(91===n.status)if(n.gzhead.comment){i=n.pending;do{if(n.pending===n.pending_buf_size&&(n.gzhead.hcrc&&n.pending>i&&(e.adler=p(e.adler,n.pending_buf,n.pending-i,i)),F(e),i=n.pending,n.pending===n.pending_buf_size)){s=1;break}s=n.gzindex<n.gzhead.comment.length?255&n.gzhead.comment.charCodeAt(n.gzindex++):0,U(n,s)}while(0!==s);n.gzhead.hcrc&&n.pending>i&&(e.adler=p(e.adler,n.pending_buf,n.pending-i,i)),0===s&&(n.status=103)}else n.status=103;if(103===n.status&&(n.gzhead.hcrc?(n.pending+2>n.pending_buf_size&&F(e),n.pending+2<=n.pending_buf_size&&(U(n,255&e.adler),U(n,e.adler>>8&255),e.adler=0,n.status=E)):n.status=E),0!==n.pending){if(F(e),0===e.avail_out)return n.last_flush=-1,m}else if(0===e.avail_in&&T(t)<=T(r)&&t!==f)return R(e,-5);if(666===n.status&&0!==e.avail_in)return R(e,-5);if(0!==e.avail_in||0!==n.lookahead||t!==l&&666!==n.status){var o=2===n.strategy?function(e,t){for(var r;;){if(0===e.lookahead&&(j(e),0===e.lookahead)){if(t===l)return A;break}if(e.match_length=0,r=u._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++,r&&(N(e,!1),0===e.strm.avail_out))return A}return e.insert=0,t===f?(N(e,!0),0===e.strm.avail_out?O:B):e.last_lit&&(N(e,!1),0===e.strm.avail_out)?A:I}(n,t):3===n.strategy?function(e,t){for(var r,n,i,s,a=e.window;;){if(e.lookahead<=S){if(j(e),e.lookahead<=S&&t===l)return A;if(0===e.lookahead)break}if(e.match_length=0,e.lookahead>=x&&0<e.strstart&&(n=a[i=e.strstart-1])===a[++i]&&n===a[++i]&&n===a[++i]){s=e.strstart+S;do{}while(n===a[++i]&&n===a[++i]&&n===a[++i]&&n===a[++i]&&n===a[++i]&&n===a[++i]&&n===a[++i]&&n===a[++i]&&i<s);e.match_length=S-(s-i),e.match_length>e.lookahead&&(e.match_length=e.lookahead)}if(e.match_length>=x?(r=u._tr_tally(e,1,e.match_length-x),e.lookahead-=e.match_length,e.strstart+=e.match_length,e.match_length=0):(r=u._tr_tally(e,0,e.window[e.strstart]),e.lookahead--,e.strstart++),r&&(N(e,!1),0===e.strm.avail_out))return A}return e.insert=0,t===f?(N(e,!0),0===e.strm.avail_out?O:B):e.last_lit&&(N(e,!1),0===e.strm.avail_out)?A:I}(n,t):h[n.level].func(n,t);if(o!==O&&o!==B||(n.status=666),o===A||o===O)return 0===e.avail_out&&(n.last_flush=-1),m;if(o===I&&(1===t?u._tr_align(n):5!==t&&(u._tr_stored_block(n,0,0,!1),3===t&&(D(n.head),0===n.lookahead&&(n.strstart=0,n.block_start=0,n.insert=0))),F(e),0===e.avail_out))return n.last_flush=-1,m}return t!==f?m:n.wrap<=0?1:(2===n.wrap?(U(n,255&e.adler),U(n,e.adler>>8&255),U(n,e.adler>>16&255),U(n,e.adler>>24&255),U(n,255&e.total_in),U(n,e.total_in>>8&255),U(n,e.total_in>>16&255),U(n,e.total_in>>24&255)):(P(n,e.adler>>>16),P(n,65535&e.adler)),F(e),0<n.wrap&&(n.wrap=-n.wrap),0!==n.pending?m:1)},r.deflateEnd=function(e){var t;return e&&e.state?(t=e.state.status)!==C&&69!==t&&73!==t&&91!==t&&103!==t&&t!==E&&666!==t?R(e,_):(e.state=null,t===E?R(e,-3):m):_},r.deflateSetDictionary=function(e,t){var r,n,i,s,a,o,h,u,l=t.length;if(!e||!e.state)return _;if(2===(s=(r=e.state).wrap)||1===s&&r.status!==C||r.lookahead)return _;for(1===s&&(e.adler=d(e.adler,t,l,0)),r.wrap=0,l>=r.w_size&&(0===s&&(D(r.head),r.strstart=0,r.block_start=0,r.insert=0),u=new c.Buf8(r.w_size),c.arraySet(u,t,l-r.w_size,r.w_size,0),t=u,l=r.w_size),a=e.avail_in,o=e.next_in,h=e.input,e.avail_in=l,e.next_in=0,e.input=t,j(r);r.lookahead>=x;){for(n=r.strstart,i=r.lookahead-(x-1);r.ins_h=(r.ins_h<<r.hash_shift^r.window[n+x-1])&r.hash_mask,r.prev[n&r.w_mask]=r.head[r.ins_h],r.head[r.ins_h]=n,n++,--i;);r.strstart=n,r.lookahead=x-1,j(r)}return r.strstart+=r.lookahead,r.block_start=r.strstart,r.insert=r.lookahead,r.lookahead=0,r.match_length=r.prev_length=x-1,r.match_available=0,e.next_in=o,e.input=h,e.avail_in=a,r.wrap=s,m},r.deflateInfo="pako deflate (from Nodeca project)"},{"../utils/common":41,"./adler32":43,"./crc32":45,"./messages":51,"./trees":52}],47:[function(e,t,r){"use strict";t.exports=function(){this.text=0,this.time=0,this.xflags=0,this.os=0,this.extra=null,this.extra_len=0,this.name="",this.comment="",this.hcrc=0,this.done=!1}},{}],48:[function(e,t,r){"use strict";t.exports=function(e,t){var r,n,i,s,a,o,h,u,l,f,c,d,p,m,_,g,b,v,y,w,k,x,S,z,C;r=e.state,n=e.next_in,z=e.input,i=n+(e.avail_in-5),s=e.next_out,C=e.output,a=s-(t-e.avail_out),o=s+(e.avail_out-257),h=r.dmax,u=r.wsize,l=r.whave,f=r.wnext,c=r.window,d=r.hold,p=r.bits,m=r.lencode,_=r.distcode,g=(1<<r.lenbits)-1,b=(1<<r.distbits)-1;e:do{p<15&&(d+=z[n++]<<p,p+=8,d+=z[n++]<<p,p+=8),v=m[d&g];t:for(;;){if(d>>>=y=v>>>24,p-=y,0===(y=v>>>16&255))C[s++]=65535&v;else{if(!(16&y)){if(0==(64&y)){v=m[(65535&v)+(d&(1<<y)-1)];continue t}if(32&y){r.mode=12;break e}e.msg="invalid literal/length code",r.mode=30;break e}w=65535&v,(y&=15)&&(p<y&&(d+=z[n++]<<p,p+=8),w+=d&(1<<y)-1,d>>>=y,p-=y),p<15&&(d+=z[n++]<<p,p+=8,d+=z[n++]<<p,p+=8),v=_[d&b];r:for(;;){if(d>>>=y=v>>>24,p-=y,!(16&(y=v>>>16&255))){if(0==(64&y)){v=_[(65535&v)+(d&(1<<y)-1)];continue r}e.msg="invalid distance code",r.mode=30;break e}if(k=65535&v,p<(y&=15)&&(d+=z[n++]<<p,(p+=8)<y&&(d+=z[n++]<<p,p+=8)),h<(k+=d&(1<<y)-1)){e.msg="invalid distance too far back",r.mode=30;break e}if(d>>>=y,p-=y,(y=s-a)<k){if(l<(y=k-y)&&r.sane){e.msg="invalid distance too far back",r.mode=30;break e}if(S=c,(x=0)===f){if(x+=u-y,y<w){for(w-=y;C[s++]=c[x++],--y;);x=s-k,S=C}}else if(f<y){if(x+=u+f-y,(y-=f)<w){for(w-=y;C[s++]=c[x++],--y;);if(x=0,f<w){for(w-=y=f;C[s++]=c[x++],--y;);x=s-k,S=C}}}else if(x+=f-y,y<w){for(w-=y;C[s++]=c[x++],--y;);x=s-k,S=C}for(;2<w;)C[s++]=S[x++],C[s++]=S[x++],C[s++]=S[x++],w-=3;w&&(C[s++]=S[x++],1<w&&(C[s++]=S[x++]))}else{for(x=s-k;C[s++]=C[x++],C[s++]=C[x++],C[s++]=C[x++],2<(w-=3););w&&(C[s++]=C[x++],1<w&&(C[s++]=C[x++]))}break}}break}}while(n<i&&s<o);n-=w=p>>3,d&=(1<<(p-=w<<3))-1,e.next_in=n,e.next_out=s,e.avail_in=n<i?i-n+5:5-(n-i),e.avail_out=s<o?o-s+257:257-(s-o),r.hold=d,r.bits=p}},{}],49:[function(e,t,r){"use strict";var I=e("../utils/common"),O=e("./adler32"),B=e("./crc32"),R=e("./inffast"),T=e("./inftrees"),D=1,F=2,N=0,U=-2,P=1,n=852,i=592;function L(e){return(e>>>24&255)+(e>>>8&65280)+((65280&e)<<8)+((255&e)<<24)}function s(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new I.Buf16(320),this.work=new I.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function a(e){var t;return e&&e.state?(t=e.state,e.total_in=e.total_out=t.total=0,e.msg="",t.wrap&&(e.adler=1&t.wrap),t.mode=P,t.last=0,t.havedict=0,t.dmax=32768,t.head=null,t.hold=0,t.bits=0,t.lencode=t.lendyn=new I.Buf32(n),t.distcode=t.distdyn=new I.Buf32(i),t.sane=1,t.back=-1,N):U}function o(e){var t;return e&&e.state?((t=e.state).wsize=0,t.whave=0,t.wnext=0,a(e)):U}function h(e,t){var r,n;return e&&e.state?(n=e.state,t<0?(r=0,t=-t):(r=1+(t>>4),t<48&&(t&=15)),t&&(t<8||15<t)?U:(null!==n.window&&n.wbits!==t&&(n.window=null),n.wrap=r,n.wbits=t,o(e))):U}function u(e,t){var r,n;return e?(n=new s,(e.state=n).window=null,(r=h(e,t))!==N&&(e.state=null),r):U}var l,f,c=!0;function j(e){if(c){var t;for(l=new I.Buf32(512),f=new I.Buf32(32),t=0;t<144;)e.lens[t++]=8;for(;t<256;)e.lens[t++]=9;for(;t<280;)e.lens[t++]=7;for(;t<288;)e.lens[t++]=8;for(T(D,e.lens,0,288,l,0,e.work,{bits:9}),t=0;t<32;)e.lens[t++]=5;T(F,e.lens,0,32,f,0,e.work,{bits:5}),c=!1}e.lencode=l,e.lenbits=9,e.distcode=f,e.distbits=5}function Z(e,t,r,n){var i,s=e.state;return null===s.window&&(s.wsize=1<<s.wbits,s.wnext=0,s.whave=0,s.window=new I.Buf8(s.wsize)),n>=s.wsize?(I.arraySet(s.window,t,r-s.wsize,s.wsize,0),s.wnext=0,s.whave=s.wsize):(n<(i=s.wsize-s.wnext)&&(i=n),I.arraySet(s.window,t,r-n,i,s.wnext),(n-=i)?(I.arraySet(s.window,t,r-n,n,0),s.wnext=n,s.whave=s.wsize):(s.wnext+=i,s.wnext===s.wsize&&(s.wnext=0),s.whave<s.wsize&&(s.whave+=i))),0}r.inflateReset=o,r.inflateReset2=h,r.inflateResetKeep=a,r.inflateInit=function(e){return u(e,15)},r.inflateInit2=u,r.inflate=function(e,t){var r,n,i,s,a,o,h,u,l,f,c,d,p,m,_,g,b,v,y,w,k,x,S,z,C=0,E=new I.Buf8(4),A=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];if(!e||!e.state||!e.output||!e.input&&0!==e.avail_in)return U;12===(r=e.state).mode&&(r.mode=13),a=e.next_out,i=e.output,h=e.avail_out,s=e.next_in,n=e.input,o=e.avail_in,u=r.hold,l=r.bits,f=o,c=h,x=N;e:for(;;)switch(r.mode){case P:if(0===r.wrap){r.mode=13;break}for(;l<16;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(2&r.wrap&&35615===u){E[r.check=0]=255&u,E[1]=u>>>8&255,r.check=B(r.check,E,2,0),l=u=0,r.mode=2;break}if(r.flags=0,r.head&&(r.head.done=!1),!(1&r.wrap)||(((255&u)<<8)+(u>>8))%31){e.msg="incorrect header check",r.mode=30;break}if(8!=(15&u)){e.msg="unknown compression method",r.mode=30;break}if(l-=4,k=8+(15&(u>>>=4)),0===r.wbits)r.wbits=k;else if(k>r.wbits){e.msg="invalid window size",r.mode=30;break}r.dmax=1<<k,e.adler=r.check=1,r.mode=512&u?10:12,l=u=0;break;case 2:for(;l<16;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(r.flags=u,8!=(255&r.flags)){e.msg="unknown compression method",r.mode=30;break}if(57344&r.flags){e.msg="unknown header flags set",r.mode=30;break}r.head&&(r.head.text=u>>8&1),512&r.flags&&(E[0]=255&u,E[1]=u>>>8&255,r.check=B(r.check,E,2,0)),l=u=0,r.mode=3;case 3:for(;l<32;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}r.head&&(r.head.time=u),512&r.flags&&(E[0]=255&u,E[1]=u>>>8&255,E[2]=u>>>16&255,E[3]=u>>>24&255,r.check=B(r.check,E,4,0)),l=u=0,r.mode=4;case 4:for(;l<16;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}r.head&&(r.head.xflags=255&u,r.head.os=u>>8),512&r.flags&&(E[0]=255&u,E[1]=u>>>8&255,r.check=B(r.check,E,2,0)),l=u=0,r.mode=5;case 5:if(1024&r.flags){for(;l<16;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}r.length=u,r.head&&(r.head.extra_len=u),512&r.flags&&(E[0]=255&u,E[1]=u>>>8&255,r.check=B(r.check,E,2,0)),l=u=0}else r.head&&(r.head.extra=null);r.mode=6;case 6:if(1024&r.flags&&(o<(d=r.length)&&(d=o),d&&(r.head&&(k=r.head.extra_len-r.length,r.head.extra||(r.head.extra=new Array(r.head.extra_len)),I.arraySet(r.head.extra,n,s,d,k)),512&r.flags&&(r.check=B(r.check,n,d,s)),o-=d,s+=d,r.length-=d),r.length))break e;r.length=0,r.mode=7;case 7:if(2048&r.flags){if(0===o)break e;for(d=0;k=n[s+d++],r.head&&k&&r.length<65536&&(r.head.name+=String.fromCharCode(k)),k&&d<o;);if(512&r.flags&&(r.check=B(r.check,n,d,s)),o-=d,s+=d,k)break e}else r.head&&(r.head.name=null);r.length=0,r.mode=8;case 8:if(4096&r.flags){if(0===o)break e;for(d=0;k=n[s+d++],r.head&&k&&r.length<65536&&(r.head.comment+=String.fromCharCode(k)),k&&d<o;);if(512&r.flags&&(r.check=B(r.check,n,d,s)),o-=d,s+=d,k)break e}else r.head&&(r.head.comment=null);r.mode=9;case 9:if(512&r.flags){for(;l<16;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(u!==(65535&r.check)){e.msg="header crc mismatch",r.mode=30;break}l=u=0}r.head&&(r.head.hcrc=r.flags>>9&1,r.head.done=!0),e.adler=r.check=0,r.mode=12;break;case 10:for(;l<32;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}e.adler=r.check=L(u),l=u=0,r.mode=11;case 11:if(0===r.havedict)return e.next_out=a,e.avail_out=h,e.next_in=s,e.avail_in=o,r.hold=u,r.bits=l,2;e.adler=r.check=1,r.mode=12;case 12:if(5===t||6===t)break e;case 13:if(r.last){u>>>=7&l,l-=7&l,r.mode=27;break}for(;l<3;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}switch(r.last=1&u,l-=1,3&(u>>>=1)){case 0:r.mode=14;break;case 1:if(j(r),r.mode=20,6!==t)break;u>>>=2,l-=2;break e;case 2:r.mode=17;break;case 3:e.msg="invalid block type",r.mode=30}u>>>=2,l-=2;break;case 14:for(u>>>=7&l,l-=7&l;l<32;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if((65535&u)!=(u>>>16^65535)){e.msg="invalid stored block lengths",r.mode=30;break}if(r.length=65535&u,l=u=0,r.mode=15,6===t)break e;case 15:r.mode=16;case 16:if(d=r.length){if(o<d&&(d=o),h<d&&(d=h),0===d)break e;I.arraySet(i,n,s,d,a),o-=d,s+=d,h-=d,a+=d,r.length-=d;break}r.mode=12;break;case 17:for(;l<14;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(r.nlen=257+(31&u),u>>>=5,l-=5,r.ndist=1+(31&u),u>>>=5,l-=5,r.ncode=4+(15&u),u>>>=4,l-=4,286<r.nlen||30<r.ndist){e.msg="too many length or distance symbols",r.mode=30;break}r.have=0,r.mode=18;case 18:for(;r.have<r.ncode;){for(;l<3;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}r.lens[A[r.have++]]=7&u,u>>>=3,l-=3}for(;r.have<19;)r.lens[A[r.have++]]=0;if(r.lencode=r.lendyn,r.lenbits=7,S={bits:r.lenbits},x=T(0,r.lens,0,19,r.lencode,0,r.work,S),r.lenbits=S.bits,x){e.msg="invalid code lengths set",r.mode=30;break}r.have=0,r.mode=19;case 19:for(;r.have<r.nlen+r.ndist;){for(;g=(C=r.lencode[u&(1<<r.lenbits)-1])>>>16&255,b=65535&C,!((_=C>>>24)<=l);){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(b<16)u>>>=_,l-=_,r.lens[r.have++]=b;else{if(16===b){for(z=_+2;l<z;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(u>>>=_,l-=_,0===r.have){e.msg="invalid bit length repeat",r.mode=30;break}k=r.lens[r.have-1],d=3+(3&u),u>>>=2,l-=2}else if(17===b){for(z=_+3;l<z;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}l-=_,k=0,d=3+(7&(u>>>=_)),u>>>=3,l-=3}else{for(z=_+7;l<z;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}l-=_,k=0,d=11+(127&(u>>>=_)),u>>>=7,l-=7}if(r.have+d>r.nlen+r.ndist){e.msg="invalid bit length repeat",r.mode=30;break}for(;d--;)r.lens[r.have++]=k}}if(30===r.mode)break;if(0===r.lens[256]){e.msg="invalid code -- missing end-of-block",r.mode=30;break}if(r.lenbits=9,S={bits:r.lenbits},x=T(D,r.lens,0,r.nlen,r.lencode,0,r.work,S),r.lenbits=S.bits,x){e.msg="invalid literal/lengths set",r.mode=30;break}if(r.distbits=6,r.distcode=r.distdyn,S={bits:r.distbits},x=T(F,r.lens,r.nlen,r.ndist,r.distcode,0,r.work,S),r.distbits=S.bits,x){e.msg="invalid distances set",r.mode=30;break}if(r.mode=20,6===t)break e;case 20:r.mode=21;case 21:if(6<=o&&258<=h){e.next_out=a,e.avail_out=h,e.next_in=s,e.avail_in=o,r.hold=u,r.bits=l,R(e,c),a=e.next_out,i=e.output,h=e.avail_out,s=e.next_in,n=e.input,o=e.avail_in,u=r.hold,l=r.bits,12===r.mode&&(r.back=-1);break}for(r.back=0;g=(C=r.lencode[u&(1<<r.lenbits)-1])>>>16&255,b=65535&C,!((_=C>>>24)<=l);){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(g&&0==(240&g)){for(v=_,y=g,w=b;g=(C=r.lencode[w+((u&(1<<v+y)-1)>>v)])>>>16&255,b=65535&C,!(v+(_=C>>>24)<=l);){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}u>>>=v,l-=v,r.back+=v}if(u>>>=_,l-=_,r.back+=_,r.length=b,0===g){r.mode=26;break}if(32&g){r.back=-1,r.mode=12;break}if(64&g){e.msg="invalid literal/length code",r.mode=30;break}r.extra=15&g,r.mode=22;case 22:if(r.extra){for(z=r.extra;l<z;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}r.length+=u&(1<<r.extra)-1,u>>>=r.extra,l-=r.extra,r.back+=r.extra}r.was=r.length,r.mode=23;case 23:for(;g=(C=r.distcode[u&(1<<r.distbits)-1])>>>16&255,b=65535&C,!((_=C>>>24)<=l);){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(0==(240&g)){for(v=_,y=g,w=b;g=(C=r.distcode[w+((u&(1<<v+y)-1)>>v)])>>>16&255,b=65535&C,!(v+(_=C>>>24)<=l);){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}u>>>=v,l-=v,r.back+=v}if(u>>>=_,l-=_,r.back+=_,64&g){e.msg="invalid distance code",r.mode=30;break}r.offset=b,r.extra=15&g,r.mode=24;case 24:if(r.extra){for(z=r.extra;l<z;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}r.offset+=u&(1<<r.extra)-1,u>>>=r.extra,l-=r.extra,r.back+=r.extra}if(r.offset>r.dmax){e.msg="invalid distance too far back",r.mode=30;break}r.mode=25;case 25:if(0===h)break e;if(d=c-h,r.offset>d){if((d=r.offset-d)>r.whave&&r.sane){e.msg="invalid distance too far back",r.mode=30;break}p=d>r.wnext?(d-=r.wnext,r.wsize-d):r.wnext-d,d>r.length&&(d=r.length),m=r.window}else m=i,p=a-r.offset,d=r.length;for(h<d&&(d=h),h-=d,r.length-=d;i[a++]=m[p++],--d;);0===r.length&&(r.mode=21);break;case 26:if(0===h)break e;i[a++]=r.length,h--,r.mode=21;break;case 27:if(r.wrap){for(;l<32;){if(0===o)break e;o--,u|=n[s++]<<l,l+=8}if(c-=h,e.total_out+=c,r.total+=c,c&&(e.adler=r.check=r.flags?B(r.check,i,c,a-c):O(r.check,i,c,a-c)),c=h,(r.flags?u:L(u))!==r.check){e.msg="incorrect data check",r.mode=30;break}l=u=0}r.mode=28;case 28:if(r.wrap&&r.flags){for(;l<32;){if(0===o)break e;o--,u+=n[s++]<<l,l+=8}if(u!==(4294967295&r.total)){e.msg="incorrect length check",r.mode=30;break}l=u=0}r.mode=29;case 29:x=1;break e;case 30:x=-3;break e;case 31:return-4;case 32:default:return U}return e.next_out=a,e.avail_out=h,e.next_in=s,e.avail_in=o,r.hold=u,r.bits=l,(r.wsize||c!==e.avail_out&&r.mode<30&&(r.mode<27||4!==t))&&Z(e,e.output,e.next_out,c-e.avail_out)?(r.mode=31,-4):(f-=e.avail_in,c-=e.avail_out,e.total_in+=f,e.total_out+=c,r.total+=c,r.wrap&&c&&(e.adler=r.check=r.flags?B(r.check,i,c,e.next_out-c):O(r.check,i,c,e.next_out-c)),e.data_type=r.bits+(r.last?64:0)+(12===r.mode?128:0)+(20===r.mode||15===r.mode?256:0),(0==f&&0===c||4===t)&&x===N&&(x=-5),x)},r.inflateEnd=function(e){if(!e||!e.state)return U;var t=e.state;return t.window&&(t.window=null),e.state=null,N},r.inflateGetHeader=function(e,t){var r;return e&&e.state?0==(2&(r=e.state).wrap)?U:((r.head=t).done=!1,N):U},r.inflateSetDictionary=function(e,t){var r,n=t.length;return e&&e.state?0!==(r=e.state).wrap&&11!==r.mode?U:11===r.mode&&O(1,t,n,0)!==r.check?-3:Z(e,t,n,n)?(r.mode=31,-4):(r.havedict=1,N):U},r.inflateInfo="pako inflate (from Nodeca project)"},{"../utils/common":41,"./adler32":43,"./crc32":45,"./inffast":48,"./inftrees":50}],50:[function(e,t,r){"use strict";var D=e("../utils/common"),F=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,0,0],N=[16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,16,72,78],U=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0],P=[16,16,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,64,64];t.exports=function(e,t,r,n,i,s,a,o){var h,u,l,f,c,d,p,m,_,g=o.bits,b=0,v=0,y=0,w=0,k=0,x=0,S=0,z=0,C=0,E=0,A=null,I=0,O=new D.Buf16(16),B=new D.Buf16(16),R=null,T=0;for(b=0;b<=15;b++)O[b]=0;for(v=0;v<n;v++)O[t[r+v]]++;for(k=g,w=15;1<=w&&0===O[w];w--);if(w<k&&(k=w),0===w)return i[s++]=20971520,i[s++]=20971520,o.bits=1,0;for(y=1;y<w&&0===O[y];y++);for(k<y&&(k=y),b=z=1;b<=15;b++)if(z<<=1,(z-=O[b])<0)return-1;if(0<z&&(0===e||1!==w))return-1;for(B[1]=0,b=1;b<15;b++)B[b+1]=B[b]+O[b];for(v=0;v<n;v++)0!==t[r+v]&&(a[B[t[r+v]]++]=v);if(d=0===e?(A=R=a,19):1===e?(A=F,I-=257,R=N,T-=257,256):(A=U,R=P,-1),b=y,c=s,S=v=E=0,l=-1,f=(C=1<<(x=k))-1,1===e&&852<C||2===e&&592<C)return 1;for(;;){for(p=b-S,_=a[v]<d?(m=0,a[v]):a[v]>d?(m=R[T+a[v]],A[I+a[v]]):(m=96,0),h=1<<b-S,y=u=1<<x;i[c+(E>>S)+(u-=h)]=p<<24|m<<16|_|0,0!==u;);for(h=1<<b-1;E&h;)h>>=1;if(0!==h?(E&=h-1,E+=h):E=0,v++,0==--O[b]){if(b===w)break;b=t[r+a[v]]}if(k<b&&(E&f)!==l){for(0===S&&(S=k),c+=y,z=1<<(x=b-S);x+S<w&&!((z-=O[x+S])<=0);)x++,z<<=1;if(C+=1<<x,1===e&&852<C||2===e&&592<C)return 1;i[l=E&f]=k<<24|x<<16|c-s|0}}return 0!==E&&(i[c+E]=b-S<<24|64<<16|0),o.bits=k,0}},{"../utils/common":41}],51:[function(e,t,r){"use strict";t.exports={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"}},{}],52:[function(e,t,r){"use strict";var i=e("../utils/common"),o=0,h=1;function n(e){for(var t=e.length;0<=--t;)e[t]=0}var s=0,a=29,u=256,l=u+1+a,f=30,c=19,_=2*l+1,g=15,d=16,p=7,m=256,b=16,v=17,y=18,w=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],k=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],x=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],S=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],z=new Array(2*(l+2));n(z);var C=new Array(2*f);n(C);var E=new Array(512);n(E);var A=new Array(256);n(A);var I=new Array(a);n(I);var O,B,R,T=new Array(f);function D(e,t,r,n,i){this.static_tree=e,this.extra_bits=t,this.extra_base=r,this.elems=n,this.max_length=i,this.has_stree=e&&e.length}function F(e,t){this.dyn_tree=e,this.max_code=0,this.stat_desc=t}function N(e){return e<256?E[e]:E[256+(e>>>7)]}function U(e,t){e.pending_buf[e.pending++]=255&t,e.pending_buf[e.pending++]=t>>>8&255}function P(e,t,r){e.bi_valid>d-r?(e.bi_buf|=t<<e.bi_valid&65535,U(e,e.bi_buf),e.bi_buf=t>>d-e.bi_valid,e.bi_valid+=r-d):(e.bi_buf|=t<<e.bi_valid&65535,e.bi_valid+=r)}function L(e,t,r){P(e,r[2*t],r[2*t+1])}function j(e,t){for(var r=0;r|=1&e,e>>>=1,r<<=1,0<--t;);return r>>>1}function Z(e,t,r){var n,i,s=new Array(g+1),a=0;for(n=1;n<=g;n++)s[n]=a=a+r[n-1]<<1;for(i=0;i<=t;i++){var o=e[2*i+1];0!==o&&(e[2*i]=j(s[o]++,o))}}function W(e){var t;for(t=0;t<l;t++)e.dyn_ltree[2*t]=0;for(t=0;t<f;t++)e.dyn_dtree[2*t]=0;for(t=0;t<c;t++)e.bl_tree[2*t]=0;e.dyn_ltree[2*m]=1,e.opt_len=e.static_len=0,e.last_lit=e.matches=0}function M(e){8<e.bi_valid?U(e,e.bi_buf):0<e.bi_valid&&(e.pending_buf[e.pending++]=e.bi_buf),e.bi_buf=0,e.bi_valid=0}function H(e,t,r,n){var i=2*t,s=2*r;return e[i]<e[s]||e[i]===e[s]&&n[t]<=n[r]}function G(e,t,r){for(var n=e.heap[r],i=r<<1;i<=e.heap_len&&(i<e.heap_len&&H(t,e.heap[i+1],e.heap[i],e.depth)&&i++,!H(t,n,e.heap[i],e.depth));)e.heap[r]=e.heap[i],r=i,i<<=1;e.heap[r]=n}function K(e,t,r){var n,i,s,a,o=0;if(0!==e.last_lit)for(;n=e.pending_buf[e.d_buf+2*o]<<8|e.pending_buf[e.d_buf+2*o+1],i=e.pending_buf[e.l_buf+o],o++,0===n?L(e,i,t):(L(e,(s=A[i])+u+1,t),0!==(a=w[s])&&P(e,i-=I[s],a),L(e,s=N(--n),r),0!==(a=k[s])&&P(e,n-=T[s],a)),o<e.last_lit;);L(e,m,t)}function Y(e,t){var r,n,i,s=t.dyn_tree,a=t.stat_desc.static_tree,o=t.stat_desc.has_stree,h=t.stat_desc.elems,u=-1;for(e.heap_len=0,e.heap_max=_,r=0;r<h;r++)0!==s[2*r]?(e.heap[++e.heap_len]=u=r,e.depth[r]=0):s[2*r+1]=0;for(;e.heap_len<2;)s[2*(i=e.heap[++e.heap_len]=u<2?++u:0)]=1,e.depth[i]=0,e.opt_len--,o&&(e.static_len-=a[2*i+1]);for(t.max_code=u,r=e.heap_len>>1;1<=r;r--)G(e,s,r);for(i=h;r=e.heap[1],e.heap[1]=e.heap[e.heap_len--],G(e,s,1),n=e.heap[1],e.heap[--e.heap_max]=r,e.heap[--e.heap_max]=n,s[2*i]=s[2*r]+s[2*n],e.depth[i]=(e.depth[r]>=e.depth[n]?e.depth[r]:e.depth[n])+1,s[2*r+1]=s[2*n+1]=i,e.heap[1]=i++,G(e,s,1),2<=e.heap_len;);e.heap[--e.heap_max]=e.heap[1],function(e,t){var r,n,i,s,a,o,h=t.dyn_tree,u=t.max_code,l=t.stat_desc.static_tree,f=t.stat_desc.has_stree,c=t.stat_desc.extra_bits,d=t.stat_desc.extra_base,p=t.stat_desc.max_length,m=0;for(s=0;s<=g;s++)e.bl_count[s]=0;for(h[2*e.heap[e.heap_max]+1]=0,r=e.heap_max+1;r<_;r++)p<(s=h[2*h[2*(n=e.heap[r])+1]+1]+1)&&(s=p,m++),h[2*n+1]=s,u<n||(e.bl_count[s]++,a=0,d<=n&&(a=c[n-d]),o=h[2*n],e.opt_len+=o*(s+a),f&&(e.static_len+=o*(l[2*n+1]+a)));if(0!==m){do{for(s=p-1;0===e.bl_count[s];)s--;e.bl_count[s]--,e.bl_count[s+1]+=2,e.bl_count[p]--,m-=2}while(0<m);for(s=p;0!==s;s--)for(n=e.bl_count[s];0!==n;)u<(i=e.heap[--r])||(h[2*i+1]!==s&&(e.opt_len+=(s-h[2*i+1])*h[2*i],h[2*i+1]=s),n--)}}(e,t),Z(s,u,e.bl_count)}function X(e,t,r){var n,i,s=-1,a=t[1],o=0,h=7,u=4;for(0===a&&(h=138,u=3),t[2*(r+1)+1]=65535,n=0;n<=r;n++)i=a,a=t[2*(n+1)+1],++o<h&&i===a||(o<u?e.bl_tree[2*i]+=o:0!==i?(i!==s&&e.bl_tree[2*i]++,e.bl_tree[2*b]++):o<=10?e.bl_tree[2*v]++:e.bl_tree[2*y]++,s=i,u=(o=0)===a?(h=138,3):i===a?(h=6,3):(h=7,4))}function V(e,t,r){var n,i,s=-1,a=t[1],o=0,h=7,u=4;for(0===a&&(h=138,u=3),n=0;n<=r;n++)if(i=a,a=t[2*(n+1)+1],!(++o<h&&i===a)){if(o<u)for(;L(e,i,e.bl_tree),0!=--o;);else 0!==i?(i!==s&&(L(e,i,e.bl_tree),o--),L(e,b,e.bl_tree),P(e,o-3,2)):o<=10?(L(e,v,e.bl_tree),P(e,o-3,3)):(L(e,y,e.bl_tree),P(e,o-11,7));s=i,u=(o=0)===a?(h=138,3):i===a?(h=6,3):(h=7,4)}}n(T);var q=!1;function J(e,t,r,n){P(e,(s<<1)+(n?1:0),3),function(e,t,r,n){M(e),n&&(U(e,r),U(e,~r)),i.arraySet(e.pending_buf,e.window,t,r,e.pending),e.pending+=r}(e,t,r,!0)}r._tr_init=function(e){q||(function(){var e,t,r,n,i,s=new Array(g+1);for(n=r=0;n<a-1;n++)for(I[n]=r,e=0;e<1<<w[n];e++)A[r++]=n;for(A[r-1]=n,n=i=0;n<16;n++)for(T[n]=i,e=0;e<1<<k[n];e++)E[i++]=n;for(i>>=7;n<f;n++)for(T[n]=i<<7,e=0;e<1<<k[n]-7;e++)E[256+i++]=n;for(t=0;t<=g;t++)s[t]=0;for(e=0;e<=143;)z[2*e+1]=8,e++,s[8]++;for(;e<=255;)z[2*e+1]=9,e++,s[9]++;for(;e<=279;)z[2*e+1]=7,e++,s[7]++;for(;e<=287;)z[2*e+1]=8,e++,s[8]++;for(Z(z,l+1,s),e=0;e<f;e++)C[2*e+1]=5,C[2*e]=j(e,5);O=new D(z,w,u+1,l,g),B=new D(C,k,0,f,g),R=new D(new Array(0),x,0,c,p)}(),q=!0),e.l_desc=new F(e.dyn_ltree,O),e.d_desc=new F(e.dyn_dtree,B),e.bl_desc=new F(e.bl_tree,R),e.bi_buf=0,e.bi_valid=0,W(e)},r._tr_stored_block=J,r._tr_flush_block=function(e,t,r,n){var i,s,a=0;0<e.level?(2===e.strm.data_type&&(e.strm.data_type=function(e){var t,r=4093624447;for(t=0;t<=31;t++,r>>>=1)if(1&r&&0!==e.dyn_ltree[2*t])return o;if(0!==e.dyn_ltree[18]||0!==e.dyn_ltree[20]||0!==e.dyn_ltree[26])return h;for(t=32;t<u;t++)if(0!==e.dyn_ltree[2*t])return h;return o}(e)),Y(e,e.l_desc),Y(e,e.d_desc),a=function(e){var t;for(X(e,e.dyn_ltree,e.l_desc.max_code),X(e,e.dyn_dtree,e.d_desc.max_code),Y(e,e.bl_desc),t=c-1;3<=t&&0===e.bl_tree[2*S[t]+1];t--);return e.opt_len+=3*(t+1)+5+5+4,t}(e),i=e.opt_len+3+7>>>3,(s=e.static_len+3+7>>>3)<=i&&(i=s)):i=s=r+5,r+4<=i&&-1!==t?J(e,t,r,n):4===e.strategy||s===i?(P(e,2+(n?1:0),3),K(e,z,C)):(P(e,4+(n?1:0),3),function(e,t,r,n){var i;for(P(e,t-257,5),P(e,r-1,5),P(e,n-4,4),i=0;i<n;i++)P(e,e.bl_tree[2*S[i]+1],3);V(e,e.dyn_ltree,t-1),V(e,e.dyn_dtree,r-1)}(e,e.l_desc.max_code+1,e.d_desc.max_code+1,a+1),K(e,e.dyn_ltree,e.dyn_dtree)),W(e),n&&M(e)},r._tr_tally=function(e,t,r){return e.pending_buf[e.d_buf+2*e.last_lit]=t>>>8&255,e.pending_buf[e.d_buf+2*e.last_lit+1]=255&t,e.pending_buf[e.l_buf+e.last_lit]=255&r,e.last_lit++,0===t?e.dyn_ltree[2*r]++:(e.matches++,t--,e.dyn_ltree[2*(A[r]+u+1)]++,e.dyn_dtree[2*N(t)]++),e.last_lit===e.lit_bufsize-1},r._tr_align=function(e){P(e,2,3),L(e,m,z),function(e){16===e.bi_valid?(U(e,e.bi_buf),e.bi_buf=0,e.bi_valid=0):8<=e.bi_valid&&(e.pending_buf[e.pending++]=255&e.bi_buf,e.bi_buf>>=8,e.bi_valid-=8)}(e)}},{"../utils/common":41}],53:[function(e,t,r){"use strict";t.exports=function(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}},{}],54:[function(e,t,r){(function(e){!function(r,n){"use strict";if(!r.setImmediate){var i,s,t,a,o=1,h={},u=!1,l=r.document,e=Object.getPrototypeOf&&Object.getPrototypeOf(r);e=e&&e.setTimeout?e:r,i="[object process]"==={}.toString.call(r.process)?function(e){process.nextTick(function(){c(e)})}:function(){if(r.postMessage&&!r.importScripts){var e=!0,t=r.onmessage;return r.onmessage=function(){e=!1},r.postMessage("","*"),r.onmessage=t,e}}()?(a="setImmediate$"+Math.random()+"$",r.addEventListener?r.addEventListener("message",d,!1):r.attachEvent("onmessage",d),function(e){r.postMessage(a+e,"*")}):r.MessageChannel?((t=new MessageChannel).port1.onmessage=function(e){c(e.data)},function(e){t.port2.postMessage(e)}):l&&"onreadystatechange"in l.createElement("script")?(s=l.documentElement,function(e){var t=l.createElement("script");t.onreadystatechange=function(){c(e),t.onreadystatechange=null,s.removeChild(t),t=null},s.appendChild(t)}):function(e){setTimeout(c,0,e)},e.setImmediate=function(e){"function"!=typeof e&&(e=new Function(""+e));for(var t=new Array(arguments.length-1),r=0;r<t.length;r++)t[r]=arguments[r+1];var n={callback:e,args:t};return h[o]=n,i(o),o++},e.clearImmediate=f}function f(e){delete h[e]}function c(e){if(u)setTimeout(c,0,e);else{var t=h[e];if(t){u=!0;try{!function(e){var t=e.callback,r=e.args;switch(r.length){case 0:t();break;case 1:t(r[0]);break;case 2:t(r[0],r[1]);break;case 3:t(r[0],r[1],r[2]);break;default:t.apply(n,r)}}(t)}finally{f(e),u=!1}}}}function d(e){e.source===r&&"string"==typeof e.data&&0===e.data.indexOf(a)&&c(+e.data.slice(a.length))}}("undefined"==typeof self?void 0===e?this:e:self)}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}]},{},[10])(10)});
        }).call(this)}).call(this,require('_process'),typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],require("timers").setImmediate)
    },{"_process":102,"buffer":77,"timers":121}],87:[function(require,module,exports){
        (function (global){(function (){
            /**
             * @license
             * Lodash <https://lodash.com/>
             * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
             * Released under MIT license <https://lodash.com/license>
             * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
             * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
             */
            ;(function() {

                /** Used as a safe reference for `undefined` in pre-ES5 environments. */
                var undefined;

                /** Used as the semantic version number. */
                var VERSION = '4.17.21';

                /** Used as the size to enable large array optimizations. */
                var LARGE_ARRAY_SIZE = 200;

                /** Error message constants. */
                var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
                    FUNC_ERROR_TEXT = 'Expected a function',
                    INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';

                /** Used to stand-in for `undefined` hash values. */
                var HASH_UNDEFINED = '__lodash_hash_undefined__';

                /** Used as the maximum memoize cache size. */
                var MAX_MEMOIZE_SIZE = 500;

                /** Used as the internal argument placeholder. */
                var PLACEHOLDER = '__lodash_placeholder__';

                /** Used to compose bitmasks for cloning. */
                var CLONE_DEEP_FLAG = 1,
                    CLONE_FLAT_FLAG = 2,
                    CLONE_SYMBOLS_FLAG = 4;

                /** Used to compose bitmasks for value comparisons. */
                var COMPARE_PARTIAL_FLAG = 1,
                    COMPARE_UNORDERED_FLAG = 2;

                /** Used to compose bitmasks for function metadata. */
                var WRAP_BIND_FLAG = 1,
                    WRAP_BIND_KEY_FLAG = 2,
                    WRAP_CURRY_BOUND_FLAG = 4,
                    WRAP_CURRY_FLAG = 8,
                    WRAP_CURRY_RIGHT_FLAG = 16,
                    WRAP_PARTIAL_FLAG = 32,
                    WRAP_PARTIAL_RIGHT_FLAG = 64,
                    WRAP_ARY_FLAG = 128,
                    WRAP_REARG_FLAG = 256,
                    WRAP_FLIP_FLAG = 512;

                /** Used as default options for `_.truncate`. */
                var DEFAULT_TRUNC_LENGTH = 30,
                    DEFAULT_TRUNC_OMISSION = '...';

                /** Used to detect hot functions by number of calls within a span of milliseconds. */
                var HOT_COUNT = 800,
                    HOT_SPAN = 16;

                /** Used to indicate the type of lazy iteratees. */
                var LAZY_FILTER_FLAG = 1,
                    LAZY_MAP_FLAG = 2,
                    LAZY_WHILE_FLAG = 3;

                /** Used as references for various `Number` constants. */
                var INFINITY = 1 / 0,
                    MAX_SAFE_INTEGER = 9007199254740991,
                    MAX_INTEGER = 1.7976931348623157e+308,
                    NAN = 0 / 0;

                /** Used as references for the maximum length and index of an array. */
                var MAX_ARRAY_LENGTH = 4294967295,
                    MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
                    HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

                /** Used to associate wrap methods with their bit flags. */
                var wrapFlags = [
                    ['ary', WRAP_ARY_FLAG],
                    ['bind', WRAP_BIND_FLAG],
                    ['bindKey', WRAP_BIND_KEY_FLAG],
                    ['curry', WRAP_CURRY_FLAG],
                    ['curryRight', WRAP_CURRY_RIGHT_FLAG],
                    ['flip', WRAP_FLIP_FLAG],
                    ['partial', WRAP_PARTIAL_FLAG],
                    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
                    ['rearg', WRAP_REARG_FLAG]
                ];

                /** `Object#toString` result references. */
                var argsTag = '[object Arguments]',
                    arrayTag = '[object Array]',
                    asyncTag = '[object AsyncFunction]',
                    boolTag = '[object Boolean]',
                    dateTag = '[object Date]',
                    domExcTag = '[object DOMException]',
                    errorTag = '[object Error]',
                    funcTag = '[object Function]',
                    genTag = '[object GeneratorFunction]',
                    mapTag = '[object Map]',
                    numberTag = '[object Number]',
                    nullTag = '[object Null]',
                    objectTag = '[object Object]',
                    promiseTag = '[object Promise]',
                    proxyTag = '[object Proxy]',
                    regexpTag = '[object RegExp]',
                    setTag = '[object Set]',
                    stringTag = '[object String]',
                    symbolTag = '[object Symbol]',
                    undefinedTag = '[object Undefined]',
                    weakMapTag = '[object WeakMap]',
                    weakSetTag = '[object WeakSet]';

                var arrayBufferTag = '[object ArrayBuffer]',
                    dataViewTag = '[object DataView]',
                    float32Tag = '[object Float32Array]',
                    float64Tag = '[object Float64Array]',
                    int8Tag = '[object Int8Array]',
                    int16Tag = '[object Int16Array]',
                    int32Tag = '[object Int32Array]',
                    uint8Tag = '[object Uint8Array]',
                    uint8ClampedTag = '[object Uint8ClampedArray]',
                    uint16Tag = '[object Uint16Array]',
                    uint32Tag = '[object Uint32Array]';

                /** Used to match empty string literals in compiled template source. */
                var reEmptyStringLeading = /\b__p \+= '';/g,
                    reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
                    reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

                /** Used to match HTML entities and HTML characters. */
                var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
                    reUnescapedHtml = /[&<>"']/g,
                    reHasEscapedHtml = RegExp(reEscapedHtml.source),
                    reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

                /** Used to match template delimiters. */
                var reEscape = /<%-([\s\S]+?)%>/g,
                    reEvaluate = /<%([\s\S]+?)%>/g,
                    reInterpolate = /<%=([\s\S]+?)%>/g;

                /** Used to match property names within property paths. */
                var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
                    reIsPlainProp = /^\w*$/,
                    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

                /**
                 * Used to match `RegExp`
                 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
                 */
                var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
                    reHasRegExpChar = RegExp(reRegExpChar.source);

                /** Used to match leading whitespace. */
                var reTrimStart = /^\s+/;

                /** Used to match a single whitespace character. */
                var reWhitespace = /\s/;

                /** Used to match wrap detail comments. */
                var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
                    reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
                    reSplitDetails = /,? & /;

                /** Used to match words composed of alphanumeric characters. */
                var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

                /**
                 * Used to validate the `validate` option in `_.template` variable.
                 *
                 * Forbids characters which could potentially change the meaning of the function argument definition:
                 * - "()," (modification of function parameters)
                 * - "=" (default value)
                 * - "[]{}" (destructuring of function parameters)
                 * - "/" (beginning of a comment)
                 * - whitespace
                 */
                var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;

                /** Used to match backslashes in property paths. */
                var reEscapeChar = /\\(\\)?/g;

                /**
                 * Used to match
                 * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
                 */
                var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

                /** Used to match `RegExp` flags from their coerced string values. */
                var reFlags = /\w*$/;

                /** Used to detect bad signed hexadecimal string values. */
                var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

                /** Used to detect binary string values. */
                var reIsBinary = /^0b[01]+$/i;

                /** Used to detect host constructors (Safari). */
                var reIsHostCtor = /^\[object .+?Constructor\]$/;

                /** Used to detect octal string values. */
                var reIsOctal = /^0o[0-7]+$/i;

                /** Used to detect unsigned integer values. */
                var reIsUint = /^(?:0|[1-9]\d*)$/;

                /** Used to match Latin Unicode letters (excluding mathematical operators). */
                var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

                /** Used to ensure capturing order of template delimiters. */
                var reNoMatch = /($^)/;

                /** Used to match unescaped characters in compiled string literals. */
                var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

                /** Used to compose unicode character classes. */
                var rsAstralRange = '\\ud800-\\udfff',
                    rsComboMarksRange = '\\u0300-\\u036f',
                    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
                    rsComboSymbolsRange = '\\u20d0-\\u20ff',
                    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
                    rsDingbatRange = '\\u2700-\\u27bf',
                    rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
                    rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
                    rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
                    rsPunctuationRange = '\\u2000-\\u206f',
                    rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
                    rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
                    rsVarRange = '\\ufe0e\\ufe0f',
                    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

                /** Used to compose unicode capture groups. */
                var rsApos = "['\u2019]",
                    rsAstral = '[' + rsAstralRange + ']',
                    rsBreak = '[' + rsBreakRange + ']',
                    rsCombo = '[' + rsComboRange + ']',
                    rsDigits = '\\d+',
                    rsDingbat = '[' + rsDingbatRange + ']',
                    rsLower = '[' + rsLowerRange + ']',
                    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
                    rsFitz = '\\ud83c[\\udffb-\\udfff]',
                    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
                    rsNonAstral = '[^' + rsAstralRange + ']',
                    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
                    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
                    rsUpper = '[' + rsUpperRange + ']',
                    rsZWJ = '\\u200d';

                /** Used to compose unicode regexes. */
                var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
                    rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
                    rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
                    rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
                    reOptMod = rsModifier + '?',
                    rsOptVar = '[' + rsVarRange + ']?',
                    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
                    rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
                    rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
                    rsSeq = rsOptVar + reOptMod + rsOptJoin,
                    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
                    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

                /** Used to match apostrophes. */
                var reApos = RegExp(rsApos, 'g');

                /**
                 * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
                 * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
                 */
                var reComboMark = RegExp(rsCombo, 'g');

                /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
                var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

                /** Used to match complex or compound words. */
                var reUnicodeWord = RegExp([
                    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
                    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
                    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
                    rsUpper + '+' + rsOptContrUpper,
                    rsOrdUpper,
                    rsOrdLower,
                    rsDigits,
                    rsEmoji
                ].join('|'), 'g');

                /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
                var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

                /** Used to detect strings that need a more robust regexp to match words. */
                var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

                /** Used to assign default `context` object properties. */
                var contextProps = [
                    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
                    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
                    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
                    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
                    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
                ];

                /** Used to make template sourceURLs easier to identify. */
                var templateCounter = -1;

                /** Used to identify `toStringTag` values of typed arrays. */
                var typedArrayTags = {};
                typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
                    typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
                        typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
                            typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
                                typedArrayTags[uint32Tag] = true;
                typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
                    typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
                        typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
                            typedArrayTags[errorTag] = typedArrayTags[funcTag] =
                                typedArrayTags[mapTag] = typedArrayTags[numberTag] =
                                    typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
                                        typedArrayTags[setTag] = typedArrayTags[stringTag] =
                                            typedArrayTags[weakMapTag] = false;

                /** Used to identify `toStringTag` values supported by `_.clone`. */
                var cloneableTags = {};
                cloneableTags[argsTag] = cloneableTags[arrayTag] =
                    cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
                        cloneableTags[boolTag] = cloneableTags[dateTag] =
                            cloneableTags[float32Tag] = cloneableTags[float64Tag] =
                                cloneableTags[int8Tag] = cloneableTags[int16Tag] =
                                    cloneableTags[int32Tag] = cloneableTags[mapTag] =
                                        cloneableTags[numberTag] = cloneableTags[objectTag] =
                                            cloneableTags[regexpTag] = cloneableTags[setTag] =
                                                cloneableTags[stringTag] = cloneableTags[symbolTag] =
                                                    cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
                                                        cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
                cloneableTags[errorTag] = cloneableTags[funcTag] =
                    cloneableTags[weakMapTag] = false;

                /** Used to map Latin Unicode letters to basic Latin letters. */
                var deburredLetters = {
                    // Latin-1 Supplement block.
                    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
                    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
                    '\xc7': 'C',  '\xe7': 'c',
                    '\xd0': 'D',  '\xf0': 'd',
                    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
                    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
                    '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
                    '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
                    '\xd1': 'N',  '\xf1': 'n',
                    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
                    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
                    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
                    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
                    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
                    '\xc6': 'Ae', '\xe6': 'ae',
                    '\xde': 'Th', '\xfe': 'th',
                    '\xdf': 'ss',
                    // Latin Extended-A block.
                    '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
                    '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
                    '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
                    '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
                    '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
                    '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
                    '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
                    '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
                    '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
                    '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
                    '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
                    '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
                    '\u0134': 'J',  '\u0135': 'j',
                    '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
                    '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
                    '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
                    '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
                    '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
                    '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
                    '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
                    '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
                    '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
                    '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
                    '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
                    '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
                    '\u0163': 't',  '\u0165': 't', '\u0167': 't',
                    '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
                    '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
                    '\u0174': 'W',  '\u0175': 'w',
                    '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
                    '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
                    '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
                    '\u0132': 'IJ', '\u0133': 'ij',
                    '\u0152': 'Oe', '\u0153': 'oe',
                    '\u0149': "'n", '\u017f': 's'
                };

                /** Used to map characters to HTML entities. */
                var htmlEscapes = {
                    '&': '&amp;',
                    '<': '&lt;',
                    '>': '&gt;',
                    '"': '&quot;',
                    "'": '&#39;'
                };

                /** Used to map HTML entities to characters. */
                var htmlUnescapes = {
                    '&amp;': '&',
                    '&lt;': '<',
                    '&gt;': '>',
                    '&quot;': '"',
                    '&#39;': "'"
                };

                /** Used to escape characters for inclusion in compiled string literals. */
                var stringEscapes = {
                    '\\': '\\',
                    "'": "'",
                    '\n': 'n',
                    '\r': 'r',
                    '\u2028': 'u2028',
                    '\u2029': 'u2029'
                };

                /** Built-in method references without a dependency on `root`. */
                var freeParseFloat = parseFloat,
                    freeParseInt = parseInt;

                /** Detect free variable `global` from Node.js. */
                var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

                /** Detect free variable `self`. */
                var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

                /** Used as a reference to the global object. */
                var root = freeGlobal || freeSelf || Function('return this')();

                /** Detect free variable `exports`. */
                var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;

                /** Detect free variable `module`. */
                var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;

                /** Detect the popular CommonJS extension `module.exports`. */
                var moduleExports = freeModule && freeModule.exports === freeExports;

                /** Detect free variable `process` from Node.js. */
                var freeProcess = moduleExports && freeGlobal.process;

                /** Used to access faster Node.js helpers. */
                var nodeUtil = (function() {
                    try {
                        // Use `util.types` for Node.js 10+.
                        var types = freeModule && freeModule.require && freeModule.require('util').types;

                        if (types) {
                            return types;
                        }

                        // Legacy `process.binding('util')` for Node.js < 10.
                        return freeProcess && freeProcess.binding && freeProcess.binding('util');
                    } catch (e) {}
                }());

                /* Node.js helper references. */
                var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
                    nodeIsDate = nodeUtil && nodeUtil.isDate,
                    nodeIsMap = nodeUtil && nodeUtil.isMap,
                    nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
                    nodeIsSet = nodeUtil && nodeUtil.isSet,
                    nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

                /*--------------------------------------------------------------------------*/

                /**
                 * A faster alternative to `Function#apply`, this function invokes `func`
                 * with the `this` binding of `thisArg` and the arguments of `args`.
                 *
                 * @private
                 * @param {Function} func The function to invoke.
                 * @param {*} thisArg The `this` binding of `func`.
                 * @param {Array} args The arguments to invoke `func` with.
                 * @returns {*} Returns the result of `func`.
                 */
                function apply(func, thisArg, args) {
                    switch (args.length) {
                        case 0: return func.call(thisArg);
                        case 1: return func.call(thisArg, args[0]);
                        case 2: return func.call(thisArg, args[0], args[1]);
                        case 3: return func.call(thisArg, args[0], args[1], args[2]);
                    }
                    return func.apply(thisArg, args);
                }

                /**
                 * A specialized version of `baseAggregator` for arrays.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} setter The function to set `accumulator` values.
                 * @param {Function} iteratee The iteratee to transform keys.
                 * @param {Object} accumulator The initial aggregated object.
                 * @returns {Function} Returns `accumulator`.
                 */
                function arrayAggregator(array, setter, iteratee, accumulator) {
                    var index = -1,
                        length = array == null ? 0 : array.length;

                    while (++index < length) {
                        var value = array[index];
                        setter(accumulator, value, iteratee(value), array);
                    }
                    return accumulator;
                }

                /**
                 * A specialized version of `_.forEach` for arrays without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @returns {Array} Returns `array`.
                 */
                function arrayEach(array, iteratee) {
                    var index = -1,
                        length = array == null ? 0 : array.length;

                    while (++index < length) {
                        if (iteratee(array[index], index, array) === false) {
                            break;
                        }
                    }
                    return array;
                }

                /**
                 * A specialized version of `_.forEachRight` for arrays without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @returns {Array} Returns `array`.
                 */
                function arrayEachRight(array, iteratee) {
                    var length = array == null ? 0 : array.length;

                    while (length--) {
                        if (iteratee(array[length], length, array) === false) {
                            break;
                        }
                    }
                    return array;
                }

                /**
                 * A specialized version of `_.every` for arrays without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} predicate The function invoked per iteration.
                 * @returns {boolean} Returns `true` if all elements pass the predicate check,
                 *  else `false`.
                 */
                function arrayEvery(array, predicate) {
                    var index = -1,
                        length = array == null ? 0 : array.length;

                    while (++index < length) {
                        if (!predicate(array[index], index, array)) {
                            return false;
                        }
                    }
                    return true;
                }

                /**
                 * A specialized version of `_.filter` for arrays without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} predicate The function invoked per iteration.
                 * @returns {Array} Returns the new filtered array.
                 */
                function arrayFilter(array, predicate) {
                    var index = -1,
                        length = array == null ? 0 : array.length,
                        resIndex = 0,
                        result = [];

                    while (++index < length) {
                        var value = array[index];
                        if (predicate(value, index, array)) {
                            result[resIndex++] = value;
                        }
                    }
                    return result;
                }

                /**
                 * A specialized version of `_.includes` for arrays without support for
                 * specifying an index to search from.
                 *
                 * @private
                 * @param {Array} [array] The array to inspect.
                 * @param {*} target The value to search for.
                 * @returns {boolean} Returns `true` if `target` is found, else `false`.
                 */
                function arrayIncludes(array, value) {
                    var length = array == null ? 0 : array.length;
                    return !!length && baseIndexOf(array, value, 0) > -1;
                }

                /**
                 * This function is like `arrayIncludes` except that it accepts a comparator.
                 *
                 * @private
                 * @param {Array} [array] The array to inspect.
                 * @param {*} target The value to search for.
                 * @param {Function} comparator The comparator invoked per element.
                 * @returns {boolean} Returns `true` if `target` is found, else `false`.
                 */
                function arrayIncludesWith(array, value, comparator) {
                    var index = -1,
                        length = array == null ? 0 : array.length;

                    while (++index < length) {
                        if (comparator(value, array[index])) {
                            return true;
                        }
                    }
                    return false;
                }

                /**
                 * A specialized version of `_.map` for arrays without support for iteratee
                 * shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @returns {Array} Returns the new mapped array.
                 */
                function arrayMap(array, iteratee) {
                    var index = -1,
                        length = array == null ? 0 : array.length,
                        result = Array(length);

                    while (++index < length) {
                        result[index] = iteratee(array[index], index, array);
                    }
                    return result;
                }

                /**
                 * Appends the elements of `values` to `array`.
                 *
                 * @private
                 * @param {Array} array The array to modify.
                 * @param {Array} values The values to append.
                 * @returns {Array} Returns `array`.
                 */
                function arrayPush(array, values) {
                    var index = -1,
                        length = values.length,
                        offset = array.length;

                    while (++index < length) {
                        array[offset + index] = values[index];
                    }
                    return array;
                }

                /**
                 * A specialized version of `_.reduce` for arrays without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @param {*} [accumulator] The initial value.
                 * @param {boolean} [initAccum] Specify using the first element of `array` as
                 *  the initial value.
                 * @returns {*} Returns the accumulated value.
                 */
                function arrayReduce(array, iteratee, accumulator, initAccum) {
                    var index = -1,
                        length = array == null ? 0 : array.length;

                    if (initAccum && length) {
                        accumulator = array[++index];
                    }
                    while (++index < length) {
                        accumulator = iteratee(accumulator, array[index], index, array);
                    }
                    return accumulator;
                }

                /**
                 * A specialized version of `_.reduceRight` for arrays without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @param {*} [accumulator] The initial value.
                 * @param {boolean} [initAccum] Specify using the last element of `array` as
                 *  the initial value.
                 * @returns {*} Returns the accumulated value.
                 */
                function arrayReduceRight(array, iteratee, accumulator, initAccum) {
                    var length = array == null ? 0 : array.length;
                    if (initAccum && length) {
                        accumulator = array[--length];
                    }
                    while (length--) {
                        accumulator = iteratee(accumulator, array[length], length, array);
                    }
                    return accumulator;
                }

                /**
                 * A specialized version of `_.some` for arrays without support for iteratee
                 * shorthands.
                 *
                 * @private
                 * @param {Array} [array] The array to iterate over.
                 * @param {Function} predicate The function invoked per iteration.
                 * @returns {boolean} Returns `true` if any element passes the predicate check,
                 *  else `false`.
                 */
                function arraySome(array, predicate) {
                    var index = -1,
                        length = array == null ? 0 : array.length;

                    while (++index < length) {
                        if (predicate(array[index], index, array)) {
                            return true;
                        }
                    }
                    return false;
                }

                /**
                 * Gets the size of an ASCII `string`.
                 *
                 * @private
                 * @param {string} string The string inspect.
                 * @returns {number} Returns the string size.
                 */
                var asciiSize = baseProperty('length');

                /**
                 * Converts an ASCII `string` to an array.
                 *
                 * @private
                 * @param {string} string The string to convert.
                 * @returns {Array} Returns the converted array.
                 */
                function asciiToArray(string) {
                    return string.split('');
                }

                /**
                 * Splits an ASCII `string` into an array of its words.
                 *
                 * @private
                 * @param {string} The string to inspect.
                 * @returns {Array} Returns the words of `string`.
                 */
                function asciiWords(string) {
                    return string.match(reAsciiWord) || [];
                }

                /**
                 * The base implementation of methods like `_.findKey` and `_.findLastKey`,
                 * without support for iteratee shorthands, which iterates over `collection`
                 * using `eachFunc`.
                 *
                 * @private
                 * @param {Array|Object} collection The collection to inspect.
                 * @param {Function} predicate The function invoked per iteration.
                 * @param {Function} eachFunc The function to iterate over `collection`.
                 * @returns {*} Returns the found element or its key, else `undefined`.
                 */
                function baseFindKey(collection, predicate, eachFunc) {
                    var result;
                    eachFunc(collection, function(value, key, collection) {
                        if (predicate(value, key, collection)) {
                            result = key;
                            return false;
                        }
                    });
                    return result;
                }

                /**
                 * The base implementation of `_.findIndex` and `_.findLastIndex` without
                 * support for iteratee shorthands.
                 *
                 * @private
                 * @param {Array} array The array to inspect.
                 * @param {Function} predicate The function invoked per iteration.
                 * @param {number} fromIndex The index to search from.
                 * @param {boolean} [fromRight] Specify iterating from right to left.
                 * @returns {number} Returns the index of the matched value, else `-1`.
                 */
                function baseFindIndex(array, predicate, fromIndex, fromRight) {
                    var length = array.length,
                        index = fromIndex + (fromRight ? 1 : -1);

                    while ((fromRight ? index-- : ++index < length)) {
                        if (predicate(array[index], index, array)) {
                            return index;
                        }
                    }
                    return -1;
                }

                /**
                 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
                 *
                 * @private
                 * @param {Array} array The array to inspect.
                 * @param {*} value The value to search for.
                 * @param {number} fromIndex The index to search from.
                 * @returns {number} Returns the index of the matched value, else `-1`.
                 */
                function baseIndexOf(array, value, fromIndex) {
                    return value === value
                        ? strictIndexOf(array, value, fromIndex)
                        : baseFindIndex(array, baseIsNaN, fromIndex);
                }

                /**
                 * This function is like `baseIndexOf` except that it accepts a comparator.
                 *
                 * @private
                 * @param {Array} array The array to inspect.
                 * @param {*} value The value to search for.
                 * @param {number} fromIndex The index to search from.
                 * @param {Function} comparator The comparator invoked per element.
                 * @returns {number} Returns the index of the matched value, else `-1`.
                 */
                function baseIndexOfWith(array, value, fromIndex, comparator) {
                    var index = fromIndex - 1,
                        length = array.length;

                    while (++index < length) {
                        if (comparator(array[index], value)) {
                            return index;
                        }
                    }
                    return -1;
                }

                /**
                 * The base implementation of `_.isNaN` without support for number objects.
                 *
                 * @private
                 * @param {*} value The value to check.
                 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
                 */
                function baseIsNaN(value) {
                    return value !== value;
                }

                /**
                 * The base implementation of `_.mean` and `_.meanBy` without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} array The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @returns {number} Returns the mean.
                 */
                function baseMean(array, iteratee) {
                    var length = array == null ? 0 : array.length;
                    return length ? (baseSum(array, iteratee) / length) : NAN;
                }

                /**
                 * The base implementation of `_.property` without support for deep paths.
                 *
                 * @private
                 * @param {string} key The key of the property to get.
                 * @returns {Function} Returns the new accessor function.
                 */
                function baseProperty(key) {
                    return function(object) {
                        return object == null ? undefined : object[key];
                    };
                }

                /**
                 * The base implementation of `_.propertyOf` without support for deep paths.
                 *
                 * @private
                 * @param {Object} object The object to query.
                 * @returns {Function} Returns the new accessor function.
                 */
                function basePropertyOf(object) {
                    return function(key) {
                        return object == null ? undefined : object[key];
                    };
                }

                /**
                 * The base implementation of `_.reduce` and `_.reduceRight`, without support
                 * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
                 *
                 * @private
                 * @param {Array|Object} collection The collection to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @param {*} accumulator The initial value.
                 * @param {boolean} initAccum Specify using the first or last element of
                 *  `collection` as the initial value.
                 * @param {Function} eachFunc The function to iterate over `collection`.
                 * @returns {*} Returns the accumulated value.
                 */
                function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
                    eachFunc(collection, function(value, index, collection) {
                        accumulator = initAccum
                            ? (initAccum = false, value)
                            : iteratee(accumulator, value, index, collection);
                    });
                    return accumulator;
                }

                /**
                 * The base implementation of `_.sortBy` which uses `comparer` to define the
                 * sort order of `array` and replaces criteria objects with their corresponding
                 * values.
                 *
                 * @private
                 * @param {Array} array The array to sort.
                 * @param {Function} comparer The function to define sort order.
                 * @returns {Array} Returns `array`.
                 */
                function baseSortBy(array, comparer) {
                    var length = array.length;

                    array.sort(comparer);
                    while (length--) {
                        array[length] = array[length].value;
                    }
                    return array;
                }

                /**
                 * The base implementation of `_.sum` and `_.sumBy` without support for
                 * iteratee shorthands.
                 *
                 * @private
                 * @param {Array} array The array to iterate over.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @returns {number} Returns the sum.
                 */
                function baseSum(array, iteratee) {
                    var result,
                        index = -1,
                        length = array.length;

                    while (++index < length) {
                        var current = iteratee(array[index]);
                        if (current !== undefined) {
                            result = result === undefined ? current : (result + current);
                        }
                    }
                    return result;
                }

                /**
                 * The base implementation of `_.times` without support for iteratee shorthands
                 * or max array length checks.
                 *
                 * @private
                 * @param {number} n The number of times to invoke `iteratee`.
                 * @param {Function} iteratee The function invoked per iteration.
                 * @returns {Array} Returns the array of results.
                 */
                function baseTimes(n, iteratee) {
                    var index = -1,
                        result = Array(n);

                    while (++index < n) {
                        result[index] = iteratee(index);
                    }
                    return result;
                }

                /**
                 * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
                 * of key-value pairs for `object` corresponding to the property names of `props`.
                 *
                 * @private
                 * @param {Object} object The object to query.
                 * @param {Array} props The property names to get values for.
                 * @returns {Object} Returns the key-value pairs.
                 */
                function baseToPairs(object, props) {
                    return arrayMap(props, function(key) {
                        return [key, object[key]];
                    });
                }

                /**
                 * The base implementation of `_.trim`.
                 *
                 * @private
                 * @param {string} string The string to trim.
                 * @returns {string} Returns the trimmed string.
                 */
                function baseTrim(string) {
                    return string
                        ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
                        : string;
                }

                /**
                 * The base implementation of `_.unary` without support for storing metadata.
                 *
                 * @private
                 * @param {Function} func The function to cap arguments for.
                 * @returns {Function} Returns the new capped function.
                 */
                function baseUnary(func) {
                    return function(value) {
                        return func(value);
                    };
                }

                /**
                 * The base implementation of `_.values` and `_.valuesIn` which creates an
                 * array of `object` property values corresponding to the property names
                 * of `props`.
                 *
                 * @private
                 * @param {Object} object The object to query.
                 * @param {Array} props The property names to get values for.
                 * @returns {Object} Returns the array of property values.
                 */
                function baseValues(object, props) {
                    return arrayMap(props, function(key) {
                        return object[key];
                    });
                }

                /**
                 * Checks if a `cache` value for `key` exists.
                 *
                 * @private
                 * @param {Object} cache The cache to query.
                 * @param {string} key The key of the entry to check.
                 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
                 */
                function cacheHas(cache, key) {
                    return cache.has(key);
                }

                /**
                 * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
                 * that is not found in the character symbols.
                 *
                 * @private
                 * @param {Array} strSymbols The string symbols to inspect.
                 * @param {Array} chrSymbols The character symbols to find.
                 * @returns {number} Returns the index of the first unmatched string symbol.
                 */
                function charsStartIndex(strSymbols, chrSymbols) {
                    var index = -1,
                        length = strSymbols.length;

                    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
                    return index;
                }

                /**
                 * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
                 * that is not found in the character symbols.
                 *
                 * @private
                 * @param {Array} strSymbols The string symbols to inspect.
                 * @param {Array} chrSymbols The character symbols to find.
                 * @returns {number} Returns the index of the last unmatched string symbol.
                 */
                function charsEndIndex(strSymbols, chrSymbols) {
                    var index = strSymbols.length;

                    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
                    return index;
                }

                /**
                 * Gets the number of `placeholder` occurrences in `array`.
                 *
                 * @private
                 * @param {Array} array The array to inspect.
                 * @param {*} placeholder The placeholder to search for.
                 * @returns {number} Returns the placeholder count.
                 */
                function countHolders(array, placeholder) {
                    var length = array.length,
                        result = 0;

                    while (length--) {
                        if (array[length] === placeholder) {
                            ++result;
                        }
                    }
                    return result;
                }

                /**
                 * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
                 * letters to basic Latin letters.
                 *
                 * @private
                 * @param {string} letter The matched letter to deburr.
                 * @returns {string} Returns the deburred letter.
                 */
                var deburrLetter = basePropertyOf(deburredLetters);

                /**
                 * Used by `_.escape` to convert characters to HTML entities.
                 *
                 * @private
                 * @param {string} chr The matched character to escape.
                 * @returns {string} Returns the escaped character.
                 */
                var escapeHtmlChar = basePropertyOf(htmlEscapes);

                /**
                 * Used by `_.template` to escape characters for inclusion in compiled string literals.
                 *
                 * @private
                 * @param {string} chr The matched character to escape.
                 * @returns {string} Returns the escaped character.
                 */
                function escapeStringChar(chr) {
                    return '\\' + stringEscapes[chr];
                }

                /**
                 * Gets the value at `key` of `object`.
                 *
                 * @private
                 * @param {Object} [object] The object to query.
                 * @param {string} key The key of the property to get.
                 * @returns {*} Returns the property value.
                 */
                function getValue(object, key) {
                    return object == null ? undefined : object[key];
                }

                /**
                 * Checks if `string` contains Unicode symbols.
                 *
                 * @private
                 * @param {string} string The string to inspect.
                 * @returns {boolean} Returns `true` if a symbol is found, else `false`.
                 */
                function hasUnicode(string) {
                    return reHasUnicode.test(string);
                }

                /**
                 * Checks if `string` contains a word composed of Unicode symbols.
                 *
                 * @private
                 * @param {string} string The string to inspect.
                 * @returns {boolean} Returns `true` if a word is found, else `false`.
                 */
                function hasUnicodeWord(string) {
                    return reHasUnicodeWord.test(string);
                }

                /**
                 * Converts `iterator` to an array.
                 *
                 * @private
                 * @param {Object} iterator The iterator to convert.
                 * @returns {Array} Returns the converted array.
                 */
                function iteratorToArray(iterator) {
                    var data,
                        result = [];

                    while (!(data = iterator.next()).done) {
                        result.push(data.value);
                    }
                    return result;
                }

                /**
                 * Converts `map` to its key-value pairs.
                 *
                 * @private
                 * @param {Object} map The map to convert.
                 * @returns {Array} Returns the key-value pairs.
                 */
                function mapToArray(map) {
                    var index = -1,
                        result = Array(map.size);

                    map.forEach(function(value, key) {
                        result[++index] = [key, value];
                    });
                    return result;
                }

                /**
                 * Creates a unary function that invokes `func` with its argument transformed.
                 *
                 * @private
                 * @param {Function} func The function to wrap.
                 * @param {Function} transform The argument transform.
                 * @returns {Function} Returns the new function.
                 */
                function overArg(func, transform) {
                    return function(arg) {
                        return func(transform(arg));
                    };
                }

                /**
                 * Replaces all `placeholder` elements in `array` with an internal placeholder
                 * and returns an array of their indexes.
                 *
                 * @private
                 * @param {Array} array The array to modify.
                 * @param {*} placeholder The placeholder to replace.
                 * @returns {Array} Returns the new array of placeholder indexes.
                 */
                function replaceHolders(array, placeholder) {
                    var index = -1,
                        length = array.length,
                        resIndex = 0,
                        result = [];

                    while (++index < length) {
                        var value = array[index];
                        if (value === placeholder || value === PLACEHOLDER) {
                            array[index] = PLACEHOLDER;
                            result[resIndex++] = index;
                        }
                    }
                    return result;
                }

                /**
                 * Converts `set` to an array of its values.
                 *
                 * @private
                 * @param {Object} set The set to convert.
                 * @returns {Array} Returns the values.
                 */
                function setToArray(set) {
                    var index = -1,
                        result = Array(set.size);

                    set.forEach(function(value) {
                        result[++index] = value;
                    });
                    return result;
                }

                /**
                 * Converts `set` to its value-value pairs.
                 *
                 * @private
                 * @param {Object} set The set to convert.
                 * @returns {Array} Returns the value-value pairs.
                 */
                function setToPairs(set) {
                    var index = -1,
                        result = Array(set.size);

                    set.forEach(function(value) {
                        result[++index] = [value, value];
                    });
                    return result;
                }

                /**
                 * A specialized version of `_.indexOf` which performs strict equality
                 * comparisons of values, i.e. `===`.
                 *
                 * @private
                 * @param {Array} array The array to inspect.
                 * @param {*} value The value to search for.
                 * @param {number} fromIndex The index to search from.
                 * @returns {number} Returns the index of the matched value, else `-1`.
                 */
                function strictIndexOf(array, value, fromIndex) {
                    var index = fromIndex - 1,
                        length = array.length;

                    while (++index < length) {
                        if (array[index] === value) {
                            return index;
                        }
                    }
                    return -1;
                }

                /**
                 * A specialized version of `_.lastIndexOf` which performs strict equality
                 * comparisons of values, i.e. `===`.
                 *
                 * @private
                 * @param {Array} array The array to inspect.
                 * @param {*} value The value to search for.
                 * @param {number} fromIndex The index to search from.
                 * @returns {number} Returns the index of the matched value, else `-1`.
                 */
                function strictLastIndexOf(array, value, fromIndex) {
                    var index = fromIndex + 1;
                    while (index--) {
                        if (array[index] === value) {
                            return index;
                        }
                    }
                    return index;
                }

                /**
                 * Gets the number of symbols in `string`.
                 *
                 * @private
                 * @param {string} string The string to inspect.
                 * @returns {number} Returns the string size.
                 */
                function stringSize(string) {
                    return hasUnicode(string)
                        ? unicodeSize(string)
                        : asciiSize(string);
                }

                /**
                 * Converts `string` to an array.
                 *
                 * @private
                 * @param {string} string The string to convert.
                 * @returns {Array} Returns the converted array.
                 */
                function stringToArray(string) {
                    return hasUnicode(string)
                        ? unicodeToArray(string)
                        : asciiToArray(string);
                }

                /**
                 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
                 * character of `string`.
                 *
                 * @private
                 * @param {string} string The string to inspect.
                 * @returns {number} Returns the index of the last non-whitespace character.
                 */
                function trimmedEndIndex(string) {
                    var index = string.length;

                    while (index-- && reWhitespace.test(string.charAt(index))) {}
                    return index;
                }

                /**
                 * Used by `_.unescape` to convert HTML entities to characters.
                 *
                 * @private
                 * @param {string} chr The matched character to unescape.
                 * @returns {string} Returns the unescaped character.
                 */
                var unescapeHtmlChar = basePropertyOf(htmlUnescapes);

                /**
                 * Gets the size of a Unicode `string`.
                 *
                 * @private
                 * @param {string} string The string inspect.
                 * @returns {number} Returns the string size.
                 */
                function unicodeSize(string) {
                    var result = reUnicode.lastIndex = 0;
                    while (reUnicode.test(string)) {
                        ++result;
                    }
                    return result;
                }

                /**
                 * Converts a Unicode `string` to an array.
                 *
                 * @private
                 * @param {string} string The string to convert.
                 * @returns {Array} Returns the converted array.
                 */
                function unicodeToArray(string) {
                    return string.match(reUnicode) || [];
                }

                /**
                 * Splits a Unicode `string` into an array of its words.
                 *
                 * @private
                 * @param {string} The string to inspect.
                 * @returns {Array} Returns the words of `string`.
                 */
                function unicodeWords(string) {
                    return string.match(reUnicodeWord) || [];
                }

                /*--------------------------------------------------------------------------*/

                /**
                 * Create a new pristine `lodash` function using the `context` object.
                 *
                 * @static
                 * @memberOf _
                 * @since 1.1.0
                 * @category Util
                 * @param {Object} [context=root] The context object.
                 * @returns {Function} Returns a new `lodash` function.
                 * @example
                 *
                 * _.mixin({ 'foo': _.constant('foo') });
                 *
                 * var lodash = _.runInContext();
                 * lodash.mixin({ 'bar': lodash.constant('bar') });
                 *
                 * _.isFunction(_.foo);
                 * // => true
                 * _.isFunction(_.bar);
                 * // => false
                 *
                 * lodash.isFunction(lodash.foo);
                 * // => false
                 * lodash.isFunction(lodash.bar);
                 * // => true
                 *
                 * // Create a suped-up `defer` in Node.js.
                 * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
                 */
                var runInContext = (function runInContext(context) {
                    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));

                    /** Built-in constructor references. */
                    var Array = context.Array,
                        Date = context.Date,
                        Error = context.Error,
                        Function = context.Function,
                        Math = context.Math,
                        Object = context.Object,
                        RegExp = context.RegExp,
                        String = context.String,
                        TypeError = context.TypeError;

                    /** Used for built-in method references. */
                    var arrayProto = Array.prototype,
                        funcProto = Function.prototype,
                        objectProto = Object.prototype;

                    /** Used to detect overreaching core-js shims. */
                    var coreJsData = context['__core-js_shared__'];

                    /** Used to resolve the decompiled source of functions. */
                    var funcToString = funcProto.toString;

                    /** Used to check objects for own properties. */
                    var hasOwnProperty = objectProto.hasOwnProperty;

                    /** Used to generate unique IDs. */
                    var idCounter = 0;

                    /** Used to detect methods masquerading as native. */
                    var maskSrcKey = (function() {
                        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
                        return uid ? ('Symbol(src)_1.' + uid) : '';
                    }());

                    /**
                     * Used to resolve the
                     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
                     * of values.
                     */
                    var nativeObjectToString = objectProto.toString;

                    /** Used to infer the `Object` constructor. */
                    var objectCtorString = funcToString.call(Object);

                    /** Used to restore the original `_` reference in `_.noConflict`. */
                    var oldDash = root._;

                    /** Used to detect if a method is native. */
                    var reIsNative = RegExp('^' +
                        funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
                            .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
                    );

                    /** Built-in value references. */
                    var Buffer = moduleExports ? context.Buffer : undefined,
                        Symbol = context.Symbol,
                        Uint8Array = context.Uint8Array,
                        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
                        getPrototype = overArg(Object.getPrototypeOf, Object),
                        objectCreate = Object.create,
                        propertyIsEnumerable = objectProto.propertyIsEnumerable,
                        splice = arrayProto.splice,
                        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
                        symIterator = Symbol ? Symbol.iterator : undefined,
                        symToStringTag = Symbol ? Symbol.toStringTag : undefined;

                    var defineProperty = (function() {
                        try {
                            var func = getNative(Object, 'defineProperty');
                            func({}, '', {});
                            return func;
                        } catch (e) {}
                    }());

                    /** Mocked built-ins. */
                    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
                        ctxNow = Date && Date.now !== root.Date.now && Date.now,
                        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;

                    /* Built-in method references for those with the same name as other `lodash` methods. */
                    var nativeCeil = Math.ceil,
                        nativeFloor = Math.floor,
                        nativeGetSymbols = Object.getOwnPropertySymbols,
                        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
                        nativeIsFinite = context.isFinite,
                        nativeJoin = arrayProto.join,
                        nativeKeys = overArg(Object.keys, Object),
                        nativeMax = Math.max,
                        nativeMin = Math.min,
                        nativeNow = Date.now,
                        nativeParseInt = context.parseInt,
                        nativeRandom = Math.random,
                        nativeReverse = arrayProto.reverse;

                    /* Built-in method references that are verified to be native. */
                    var DataView = getNative(context, 'DataView'),
                        Map = getNative(context, 'Map'),
                        Promise = getNative(context, 'Promise'),
                        Set = getNative(context, 'Set'),
                        WeakMap = getNative(context, 'WeakMap'),
                        nativeCreate = getNative(Object, 'create');

                    /** Used to store function metadata. */
                    var metaMap = WeakMap && new WeakMap;

                    /** Used to lookup unminified function names. */
                    var realNames = {};

                    /** Used to detect maps, sets, and weakmaps. */
                    var dataViewCtorString = toSource(DataView),
                        mapCtorString = toSource(Map),
                        promiseCtorString = toSource(Promise),
                        setCtorString = toSource(Set),
                        weakMapCtorString = toSource(WeakMap);

                    /** Used to convert symbols to primitives and strings. */
                    var symbolProto = Symbol ? Symbol.prototype : undefined,
                        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
                        symbolToString = symbolProto ? symbolProto.toString : undefined;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates a `lodash` object which wraps `value` to enable implicit method
                     * chain sequences. Methods that operate on and return arrays, collections,
                     * and functions can be chained together. Methods that retrieve a single value
                     * or may return a primitive value will automatically end the chain sequence
                     * and return the unwrapped value. Otherwise, the value must be unwrapped
                     * with `_#value`.
                     *
                     * Explicit chain sequences, which must be unwrapped with `_#value`, may be
                     * enabled using `_.chain`.
                     *
                     * The execution of chained methods is lazy, that is, it's deferred until
                     * `_#value` is implicitly or explicitly called.
                     *
                     * Lazy evaluation allows several methods to support shortcut fusion.
                     * Shortcut fusion is an optimization to merge iteratee calls; this avoids
                     * the creation of intermediate arrays and can greatly reduce the number of
                     * iteratee executions. Sections of a chain sequence qualify for shortcut
                     * fusion if the section is applied to an array and iteratees accept only
                     * one argument. The heuristic for whether a section qualifies for shortcut
                     * fusion is subject to change.
                     *
                     * Chaining is supported in custom builds as long as the `_#value` method is
                     * directly or indirectly included in the build.
                     *
                     * In addition to lodash methods, wrappers have `Array` and `String` methods.
                     *
                     * The wrapper `Array` methods are:
                     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
                     *
                     * The wrapper `String` methods are:
                     * `replace` and `split`
                     *
                     * The wrapper methods that support shortcut fusion are:
                     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
                     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
                     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
                     *
                     * The chainable wrapper methods are:
                     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
                     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
                     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
                     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
                     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
                     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
                     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
                     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
                     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
                     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
                     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
                     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
                     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
                     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
                     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
                     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
                     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
                     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
                     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
                     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
                     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
                     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
                     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
                     * `zipObject`, `zipObjectDeep`, and `zipWith`
                     *
                     * The wrapper methods that are **not** chainable by default are:
                     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
                     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
                     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
                     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
                     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
                     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
                     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
                     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
                     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
                     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
                     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
                     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
                     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
                     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
                     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
                     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
                     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
                     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
                     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
                     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
                     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
                     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
                     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
                     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
                     * `upperFirst`, `value`, and `words`
                     *
                     * @name _
                     * @constructor
                     * @category Seq
                     * @param {*} value The value to wrap in a `lodash` instance.
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * function square(n) {
                     *   return n * n;
                     * }
                     *
                     * var wrapped = _([1, 2, 3]);
                     *
                     * // Returns an unwrapped value.
                     * wrapped.reduce(_.add);
                     * // => 6
                     *
                     * // Returns a wrapped value.
                     * var squares = wrapped.map(square);
                     *
                     * _.isArray(squares);
                     * // => false
                     *
                     * _.isArray(squares.value());
                     * // => true
                     */
                    function lodash(value) {
                        if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
                            if (value instanceof LodashWrapper) {
                                return value;
                            }
                            if (hasOwnProperty.call(value, '__wrapped__')) {
                                return wrapperClone(value);
                            }
                        }
                        return new LodashWrapper(value);
                    }

                    /**
                     * The base implementation of `_.create` without support for assigning
                     * properties to the created object.
                     *
                     * @private
                     * @param {Object} proto The object to inherit from.
                     * @returns {Object} Returns the new object.
                     */
                    var baseCreate = (function() {
                        function object() {}
                        return function(proto) {
                            if (!isObject(proto)) {
                                return {};
                            }
                            if (objectCreate) {
                                return objectCreate(proto);
                            }
                            object.prototype = proto;
                            var result = new object;
                            object.prototype = undefined;
                            return result;
                        };
                    }());

                    /**
                     * The function whose prototype chain sequence wrappers inherit from.
                     *
                     * @private
                     */
                    function baseLodash() {
                        // No operation performed.
                    }

                    /**
                     * The base constructor for creating `lodash` wrapper objects.
                     *
                     * @private
                     * @param {*} value The value to wrap.
                     * @param {boolean} [chainAll] Enable explicit method chain sequences.
                     */
                    function LodashWrapper(value, chainAll) {
                        this.__wrapped__ = value;
                        this.__actions__ = [];
                        this.__chain__ = !!chainAll;
                        this.__index__ = 0;
                        this.__values__ = undefined;
                    }

                    /**
                     * By default, the template delimiters used by lodash are like those in
                     * embedded Ruby (ERB) as well as ES2015 template strings. Change the
                     * following template settings to use alternative delimiters.
                     *
                     * @static
                     * @memberOf _
                     * @type {Object}
                     */
                    lodash.templateSettings = {

                        /**
                         * Used to detect `data` property values to be HTML-escaped.
                         *
                         * @memberOf _.templateSettings
                         * @type {RegExp}
                         */
                        'escape': reEscape,

                        /**
                         * Used to detect code to be evaluated.
                         *
                         * @memberOf _.templateSettings
                         * @type {RegExp}
                         */
                        'evaluate': reEvaluate,

                        /**
                         * Used to detect `data` property values to inject.
                         *
                         * @memberOf _.templateSettings
                         * @type {RegExp}
                         */
                        'interpolate': reInterpolate,

                        /**
                         * Used to reference the data object in the template text.
                         *
                         * @memberOf _.templateSettings
                         * @type {string}
                         */
                        'variable': '',

                        /**
                         * Used to import variables into the compiled template.
                         *
                         * @memberOf _.templateSettings
                         * @type {Object}
                         */
                        'imports': {

                            /**
                             * A reference to the `lodash` function.
                             *
                             * @memberOf _.templateSettings.imports
                             * @type {Function}
                             */
                            '_': lodash
                        }
                    };

                    // Ensure wrappers are instances of `baseLodash`.
                    lodash.prototype = baseLodash.prototype;
                    lodash.prototype.constructor = lodash;

                    LodashWrapper.prototype = baseCreate(baseLodash.prototype);
                    LodashWrapper.prototype.constructor = LodashWrapper;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
                     *
                     * @private
                     * @constructor
                     * @param {*} value The value to wrap.
                     */
                    function LazyWrapper(value) {
                        this.__wrapped__ = value;
                        this.__actions__ = [];
                        this.__dir__ = 1;
                        this.__filtered__ = false;
                        this.__iteratees__ = [];
                        this.__takeCount__ = MAX_ARRAY_LENGTH;
                        this.__views__ = [];
                    }

                    /**
                     * Creates a clone of the lazy wrapper object.
                     *
                     * @private
                     * @name clone
                     * @memberOf LazyWrapper
                     * @returns {Object} Returns the cloned `LazyWrapper` object.
                     */
                    function lazyClone() {
                        var result = new LazyWrapper(this.__wrapped__);
                        result.__actions__ = copyArray(this.__actions__);
                        result.__dir__ = this.__dir__;
                        result.__filtered__ = this.__filtered__;
                        result.__iteratees__ = copyArray(this.__iteratees__);
                        result.__takeCount__ = this.__takeCount__;
                        result.__views__ = copyArray(this.__views__);
                        return result;
                    }

                    /**
                     * Reverses the direction of lazy iteration.
                     *
                     * @private
                     * @name reverse
                     * @memberOf LazyWrapper
                     * @returns {Object} Returns the new reversed `LazyWrapper` object.
                     */
                    function lazyReverse() {
                        if (this.__filtered__) {
                            var result = new LazyWrapper(this);
                            result.__dir__ = -1;
                            result.__filtered__ = true;
                        } else {
                            result = this.clone();
                            result.__dir__ *= -1;
                        }
                        return result;
                    }

                    /**
                     * Extracts the unwrapped value from its lazy wrapper.
                     *
                     * @private
                     * @name value
                     * @memberOf LazyWrapper
                     * @returns {*} Returns the unwrapped value.
                     */
                    function lazyValue() {
                        var array = this.__wrapped__.value(),
                            dir = this.__dir__,
                            isArr = isArray(array),
                            isRight = dir < 0,
                            arrLength = isArr ? array.length : 0,
                            view = getView(0, arrLength, this.__views__),
                            start = view.start,
                            end = view.end,
                            length = end - start,
                            index = isRight ? end : (start - 1),
                            iteratees = this.__iteratees__,
                            iterLength = iteratees.length,
                            resIndex = 0,
                            takeCount = nativeMin(length, this.__takeCount__);

                        if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
                            return baseWrapperValue(array, this.__actions__);
                        }
                        var result = [];

                        outer:
                            while (length-- && resIndex < takeCount) {
                                index += dir;

                                var iterIndex = -1,
                                    value = array[index];

                                while (++iterIndex < iterLength) {
                                    var data = iteratees[iterIndex],
                                        iteratee = data.iteratee,
                                        type = data.type,
                                        computed = iteratee(value);

                                    if (type == LAZY_MAP_FLAG) {
                                        value = computed;
                                    } else if (!computed) {
                                        if (type == LAZY_FILTER_FLAG) {
                                            continue outer;
                                        } else {
                                            break outer;
                                        }
                                    }
                                }
                                result[resIndex++] = value;
                            }
                        return result;
                    }

                    // Ensure `LazyWrapper` is an instance of `baseLodash`.
                    LazyWrapper.prototype = baseCreate(baseLodash.prototype);
                    LazyWrapper.prototype.constructor = LazyWrapper;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates a hash object.
                     *
                     * @private
                     * @constructor
                     * @param {Array} [entries] The key-value pairs to cache.
                     */
                    function Hash(entries) {
                        var index = -1,
                            length = entries == null ? 0 : entries.length;

                        this.clear();
                        while (++index < length) {
                            var entry = entries[index];
                            this.set(entry[0], entry[1]);
                        }
                    }

                    /**
                     * Removes all key-value entries from the hash.
                     *
                     * @private
                     * @name clear
                     * @memberOf Hash
                     */
                    function hashClear() {
                        this.__data__ = nativeCreate ? nativeCreate(null) : {};
                        this.size = 0;
                    }

                    /**
                     * Removes `key` and its value from the hash.
                     *
                     * @private
                     * @name delete
                     * @memberOf Hash
                     * @param {Object} hash The hash to modify.
                     * @param {string} key The key of the value to remove.
                     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
                     */
                    function hashDelete(key) {
                        var result = this.has(key) && delete this.__data__[key];
                        this.size -= result ? 1 : 0;
                        return result;
                    }

                    /**
                     * Gets the hash value for `key`.
                     *
                     * @private
                     * @name get
                     * @memberOf Hash
                     * @param {string} key The key of the value to get.
                     * @returns {*} Returns the entry value.
                     */
                    function hashGet(key) {
                        var data = this.__data__;
                        if (nativeCreate) {
                            var result = data[key];
                            return result === HASH_UNDEFINED ? undefined : result;
                        }
                        return hasOwnProperty.call(data, key) ? data[key] : undefined;
                    }

                    /**
                     * Checks if a hash value for `key` exists.
                     *
                     * @private
                     * @name has
                     * @memberOf Hash
                     * @param {string} key The key of the entry to check.
                     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
                     */
                    function hashHas(key) {
                        var data = this.__data__;
                        return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
                    }

                    /**
                     * Sets the hash `key` to `value`.
                     *
                     * @private
                     * @name set
                     * @memberOf Hash
                     * @param {string} key The key of the value to set.
                     * @param {*} value The value to set.
                     * @returns {Object} Returns the hash instance.
                     */
                    function hashSet(key, value) {
                        var data = this.__data__;
                        this.size += this.has(key) ? 0 : 1;
                        data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
                        return this;
                    }

                    // Add methods to `Hash`.
                    Hash.prototype.clear = hashClear;
                    Hash.prototype['delete'] = hashDelete;
                    Hash.prototype.get = hashGet;
                    Hash.prototype.has = hashHas;
                    Hash.prototype.set = hashSet;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates an list cache object.
                     *
                     * @private
                     * @constructor
                     * @param {Array} [entries] The key-value pairs to cache.
                     */
                    function ListCache(entries) {
                        var index = -1,
                            length = entries == null ? 0 : entries.length;

                        this.clear();
                        while (++index < length) {
                            var entry = entries[index];
                            this.set(entry[0], entry[1]);
                        }
                    }

                    /**
                     * Removes all key-value entries from the list cache.
                     *
                     * @private
                     * @name clear
                     * @memberOf ListCache
                     */
                    function listCacheClear() {
                        this.__data__ = [];
                        this.size = 0;
                    }

                    /**
                     * Removes `key` and its value from the list cache.
                     *
                     * @private
                     * @name delete
                     * @memberOf ListCache
                     * @param {string} key The key of the value to remove.
                     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
                     */
                    function listCacheDelete(key) {
                        var data = this.__data__,
                            index = assocIndexOf(data, key);

                        if (index < 0) {
                            return false;
                        }
                        var lastIndex = data.length - 1;
                        if (index == lastIndex) {
                            data.pop();
                        } else {
                            splice.call(data, index, 1);
                        }
                        --this.size;
                        return true;
                    }

                    /**
                     * Gets the list cache value for `key`.
                     *
                     * @private
                     * @name get
                     * @memberOf ListCache
                     * @param {string} key The key of the value to get.
                     * @returns {*} Returns the entry value.
                     */
                    function listCacheGet(key) {
                        var data = this.__data__,
                            index = assocIndexOf(data, key);

                        return index < 0 ? undefined : data[index][1];
                    }

                    /**
                     * Checks if a list cache value for `key` exists.
                     *
                     * @private
                     * @name has
                     * @memberOf ListCache
                     * @param {string} key The key of the entry to check.
                     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
                     */
                    function listCacheHas(key) {
                        return assocIndexOf(this.__data__, key) > -1;
                    }

                    /**
                     * Sets the list cache `key` to `value`.
                     *
                     * @private
                     * @name set
                     * @memberOf ListCache
                     * @param {string} key The key of the value to set.
                     * @param {*} value The value to set.
                     * @returns {Object} Returns the list cache instance.
                     */
                    function listCacheSet(key, value) {
                        var data = this.__data__,
                            index = assocIndexOf(data, key);

                        if (index < 0) {
                            ++this.size;
                            data.push([key, value]);
                        } else {
                            data[index][1] = value;
                        }
                        return this;
                    }

                    // Add methods to `ListCache`.
                    ListCache.prototype.clear = listCacheClear;
                    ListCache.prototype['delete'] = listCacheDelete;
                    ListCache.prototype.get = listCacheGet;
                    ListCache.prototype.has = listCacheHas;
                    ListCache.prototype.set = listCacheSet;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates a map cache object to store key-value pairs.
                     *
                     * @private
                     * @constructor
                     * @param {Array} [entries] The key-value pairs to cache.
                     */
                    function MapCache(entries) {
                        var index = -1,
                            length = entries == null ? 0 : entries.length;

                        this.clear();
                        while (++index < length) {
                            var entry = entries[index];
                            this.set(entry[0], entry[1]);
                        }
                    }

                    /**
                     * Removes all key-value entries from the map.
                     *
                     * @private
                     * @name clear
                     * @memberOf MapCache
                     */
                    function mapCacheClear() {
                        this.size = 0;
                        this.__data__ = {
                            'hash': new Hash,
                            'map': new (Map || ListCache),
                            'string': new Hash
                        };
                    }

                    /**
                     * Removes `key` and its value from the map.
                     *
                     * @private
                     * @name delete
                     * @memberOf MapCache
                     * @param {string} key The key of the value to remove.
                     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
                     */
                    function mapCacheDelete(key) {
                        var result = getMapData(this, key)['delete'](key);
                        this.size -= result ? 1 : 0;
                        return result;
                    }

                    /**
                     * Gets the map value for `key`.
                     *
                     * @private
                     * @name get
                     * @memberOf MapCache
                     * @param {string} key The key of the value to get.
                     * @returns {*} Returns the entry value.
                     */
                    function mapCacheGet(key) {
                        return getMapData(this, key).get(key);
                    }

                    /**
                     * Checks if a map value for `key` exists.
                     *
                     * @private
                     * @name has
                     * @memberOf MapCache
                     * @param {string} key The key of the entry to check.
                     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
                     */
                    function mapCacheHas(key) {
                        return getMapData(this, key).has(key);
                    }

                    /**
                     * Sets the map `key` to `value`.
                     *
                     * @private
                     * @name set
                     * @memberOf MapCache
                     * @param {string} key The key of the value to set.
                     * @param {*} value The value to set.
                     * @returns {Object} Returns the map cache instance.
                     */
                    function mapCacheSet(key, value) {
                        var data = getMapData(this, key),
                            size = data.size;

                        data.set(key, value);
                        this.size += data.size == size ? 0 : 1;
                        return this;
                    }

                    // Add methods to `MapCache`.
                    MapCache.prototype.clear = mapCacheClear;
                    MapCache.prototype['delete'] = mapCacheDelete;
                    MapCache.prototype.get = mapCacheGet;
                    MapCache.prototype.has = mapCacheHas;
                    MapCache.prototype.set = mapCacheSet;

                    /*------------------------------------------------------------------------*/

                    /**
                     *
                     * Creates an array cache object to store unique values.
                     *
                     * @private
                     * @constructor
                     * @param {Array} [values] The values to cache.
                     */
                    function SetCache(values) {
                        var index = -1,
                            length = values == null ? 0 : values.length;

                        this.__data__ = new MapCache;
                        while (++index < length) {
                            this.add(values[index]);
                        }
                    }

                    /**
                     * Adds `value` to the array cache.
                     *
                     * @private
                     * @name add
                     * @memberOf SetCache
                     * @alias push
                     * @param {*} value The value to cache.
                     * @returns {Object} Returns the cache instance.
                     */
                    function setCacheAdd(value) {
                        this.__data__.set(value, HASH_UNDEFINED);
                        return this;
                    }

                    /**
                     * Checks if `value` is in the array cache.
                     *
                     * @private
                     * @name has
                     * @memberOf SetCache
                     * @param {*} value The value to search for.
                     * @returns {number} Returns `true` if `value` is found, else `false`.
                     */
                    function setCacheHas(value) {
                        return this.__data__.has(value);
                    }

                    // Add methods to `SetCache`.
                    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
                    SetCache.prototype.has = setCacheHas;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates a stack cache object to store key-value pairs.
                     *
                     * @private
                     * @constructor
                     * @param {Array} [entries] The key-value pairs to cache.
                     */
                    function Stack(entries) {
                        var data = this.__data__ = new ListCache(entries);
                        this.size = data.size;
                    }

                    /**
                     * Removes all key-value entries from the stack.
                     *
                     * @private
                     * @name clear
                     * @memberOf Stack
                     */
                    function stackClear() {
                        this.__data__ = new ListCache;
                        this.size = 0;
                    }

                    /**
                     * Removes `key` and its value from the stack.
                     *
                     * @private
                     * @name delete
                     * @memberOf Stack
                     * @param {string} key The key of the value to remove.
                     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
                     */
                    function stackDelete(key) {
                        var data = this.__data__,
                            result = data['delete'](key);

                        this.size = data.size;
                        return result;
                    }

                    /**
                     * Gets the stack value for `key`.
                     *
                     * @private
                     * @name get
                     * @memberOf Stack
                     * @param {string} key The key of the value to get.
                     * @returns {*} Returns the entry value.
                     */
                    function stackGet(key) {
                        return this.__data__.get(key);
                    }

                    /**
                     * Checks if a stack value for `key` exists.
                     *
                     * @private
                     * @name has
                     * @memberOf Stack
                     * @param {string} key The key of the entry to check.
                     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
                     */
                    function stackHas(key) {
                        return this.__data__.has(key);
                    }

                    /**
                     * Sets the stack `key` to `value`.
                     *
                     * @private
                     * @name set
                     * @memberOf Stack
                     * @param {string} key The key of the value to set.
                     * @param {*} value The value to set.
                     * @returns {Object} Returns the stack cache instance.
                     */
                    function stackSet(key, value) {
                        var data = this.__data__;
                        if (data instanceof ListCache) {
                            var pairs = data.__data__;
                            if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
                                pairs.push([key, value]);
                                this.size = ++data.size;
                                return this;
                            }
                            data = this.__data__ = new MapCache(pairs);
                        }
                        data.set(key, value);
                        this.size = data.size;
                        return this;
                    }

                    // Add methods to `Stack`.
                    Stack.prototype.clear = stackClear;
                    Stack.prototype['delete'] = stackDelete;
                    Stack.prototype.get = stackGet;
                    Stack.prototype.has = stackHas;
                    Stack.prototype.set = stackSet;

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates an array of the enumerable property names of the array-like `value`.
                     *
                     * @private
                     * @param {*} value The value to query.
                     * @param {boolean} inherited Specify returning inherited property names.
                     * @returns {Array} Returns the array of property names.
                     */
                    function arrayLikeKeys(value, inherited) {
                        var isArr = isArray(value),
                            isArg = !isArr && isArguments(value),
                            isBuff = !isArr && !isArg && isBuffer(value),
                            isType = !isArr && !isArg && !isBuff && isTypedArray(value),
                            skipIndexes = isArr || isArg || isBuff || isType,
                            result = skipIndexes ? baseTimes(value.length, String) : [],
                            length = result.length;

                        for (var key in value) {
                            if ((inherited || hasOwnProperty.call(value, key)) &&
                                !(skipIndexes && (
                                    // Safari 9 has enumerable `arguments.length` in strict mode.
                                    key == 'length' ||
                                    // Node.js 0.10 has enumerable non-index properties on buffers.
                                    (isBuff && (key == 'offset' || key == 'parent')) ||
                                    // PhantomJS 2 has enumerable non-index properties on typed arrays.
                                    (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
                                    // Skip index properties.
                                    isIndex(key, length)
                                ))) {
                                result.push(key);
                            }
                        }
                        return result;
                    }

                    /**
                     * A specialized version of `_.sample` for arrays.
                     *
                     * @private
                     * @param {Array} array The array to sample.
                     * @returns {*} Returns the random element.
                     */
                    function arraySample(array) {
                        var length = array.length;
                        return length ? array[baseRandom(0, length - 1)] : undefined;
                    }

                    /**
                     * A specialized version of `_.sampleSize` for arrays.
                     *
                     * @private
                     * @param {Array} array The array to sample.
                     * @param {number} n The number of elements to sample.
                     * @returns {Array} Returns the random elements.
                     */
                    function arraySampleSize(array, n) {
                        return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
                    }

                    /**
                     * A specialized version of `_.shuffle` for arrays.
                     *
                     * @private
                     * @param {Array} array The array to shuffle.
                     * @returns {Array} Returns the new shuffled array.
                     */
                    function arrayShuffle(array) {
                        return shuffleSelf(copyArray(array));
                    }

                    /**
                     * This function is like `assignValue` except that it doesn't assign
                     * `undefined` values.
                     *
                     * @private
                     * @param {Object} object The object to modify.
                     * @param {string} key The key of the property to assign.
                     * @param {*} value The value to assign.
                     */
                    function assignMergeValue(object, key, value) {
                        if ((value !== undefined && !eq(object[key], value)) ||
                            (value === undefined && !(key in object))) {
                            baseAssignValue(object, key, value);
                        }
                    }

                    /**
                     * Assigns `value` to `key` of `object` if the existing value is not equivalent
                     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons.
                     *
                     * @private
                     * @param {Object} object The object to modify.
                     * @param {string} key The key of the property to assign.
                     * @param {*} value The value to assign.
                     */
                    function assignValue(object, key, value) {
                        var objValue = object[key];
                        if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
                            (value === undefined && !(key in object))) {
                            baseAssignValue(object, key, value);
                        }
                    }

                    /**
                     * Gets the index at which the `key` is found in `array` of key-value pairs.
                     *
                     * @private
                     * @param {Array} array The array to inspect.
                     * @param {*} key The key to search for.
                     * @returns {number} Returns the index of the matched value, else `-1`.
                     */
                    function assocIndexOf(array, key) {
                        var length = array.length;
                        while (length--) {
                            if (eq(array[length][0], key)) {
                                return length;
                            }
                        }
                        return -1;
                    }

                    /**
                     * Aggregates elements of `collection` on `accumulator` with keys transformed
                     * by `iteratee` and values set by `setter`.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} setter The function to set `accumulator` values.
                     * @param {Function} iteratee The iteratee to transform keys.
                     * @param {Object} accumulator The initial aggregated object.
                     * @returns {Function} Returns `accumulator`.
                     */
                    function baseAggregator(collection, setter, iteratee, accumulator) {
                        baseEach(collection, function(value, key, collection) {
                            setter(accumulator, value, iteratee(value), collection);
                        });
                        return accumulator;
                    }

                    /**
                     * The base implementation of `_.assign` without support for multiple sources
                     * or `customizer` functions.
                     *
                     * @private
                     * @param {Object} object The destination object.
                     * @param {Object} source The source object.
                     * @returns {Object} Returns `object`.
                     */
                    function baseAssign(object, source) {
                        return object && copyObject(source, keys(source), object);
                    }

                    /**
                     * The base implementation of `_.assignIn` without support for multiple sources
                     * or `customizer` functions.
                     *
                     * @private
                     * @param {Object} object The destination object.
                     * @param {Object} source The source object.
                     * @returns {Object} Returns `object`.
                     */
                    function baseAssignIn(object, source) {
                        return object && copyObject(source, keysIn(source), object);
                    }

                    /**
                     * The base implementation of `assignValue` and `assignMergeValue` without
                     * value checks.
                     *
                     * @private
                     * @param {Object} object The object to modify.
                     * @param {string} key The key of the property to assign.
                     * @param {*} value The value to assign.
                     */
                    function baseAssignValue(object, key, value) {
                        if (key == '__proto__' && defineProperty) {
                            defineProperty(object, key, {
                                'configurable': true,
                                'enumerable': true,
                                'value': value,
                                'writable': true
                            });
                        } else {
                            object[key] = value;
                        }
                    }

                    /**
                     * The base implementation of `_.at` without support for individual paths.
                     *
                     * @private
                     * @param {Object} object The object to iterate over.
                     * @param {string[]} paths The property paths to pick.
                     * @returns {Array} Returns the picked elements.
                     */
                    function baseAt(object, paths) {
                        var index = -1,
                            length = paths.length,
                            result = Array(length),
                            skip = object == null;

                        while (++index < length) {
                            result[index] = skip ? undefined : get(object, paths[index]);
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.clamp` which doesn't coerce arguments.
                     *
                     * @private
                     * @param {number} number The number to clamp.
                     * @param {number} [lower] The lower bound.
                     * @param {number} upper The upper bound.
                     * @returns {number} Returns the clamped number.
                     */
                    function baseClamp(number, lower, upper) {
                        if (number === number) {
                            if (upper !== undefined) {
                                number = number <= upper ? number : upper;
                            }
                            if (lower !== undefined) {
                                number = number >= lower ? number : lower;
                            }
                        }
                        return number;
                    }

                    /**
                     * The base implementation of `_.clone` and `_.cloneDeep` which tracks
                     * traversed objects.
                     *
                     * @private
                     * @param {*} value The value to clone.
                     * @param {boolean} bitmask The bitmask flags.
                     *  1 - Deep clone
                     *  2 - Flatten inherited properties
                     *  4 - Clone symbols
                     * @param {Function} [customizer] The function to customize cloning.
                     * @param {string} [key] The key of `value`.
                     * @param {Object} [object] The parent object of `value`.
                     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
                     * @returns {*} Returns the cloned value.
                     */
                    function baseClone(value, bitmask, customizer, key, object, stack) {
                        var result,
                            isDeep = bitmask & CLONE_DEEP_FLAG,
                            isFlat = bitmask & CLONE_FLAT_FLAG,
                            isFull = bitmask & CLONE_SYMBOLS_FLAG;

                        if (customizer) {
                            result = object ? customizer(value, key, object, stack) : customizer(value);
                        }
                        if (result !== undefined) {
                            return result;
                        }
                        if (!isObject(value)) {
                            return value;
                        }
                        var isArr = isArray(value);
                        if (isArr) {
                            result = initCloneArray(value);
                            if (!isDeep) {
                                return copyArray(value, result);
                            }
                        } else {
                            var tag = getTag(value),
                                isFunc = tag == funcTag || tag == genTag;

                            if (isBuffer(value)) {
                                return cloneBuffer(value, isDeep);
                            }
                            if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
                                result = (isFlat || isFunc) ? {} : initCloneObject(value);
                                if (!isDeep) {
                                    return isFlat
                                        ? copySymbolsIn(value, baseAssignIn(result, value))
                                        : copySymbols(value, baseAssign(result, value));
                                }
                            } else {
                                if (!cloneableTags[tag]) {
                                    return object ? value : {};
                                }
                                result = initCloneByTag(value, tag, isDeep);
                            }
                        }
                        // Check for circular references and return its corresponding clone.
                        stack || (stack = new Stack);
                        var stacked = stack.get(value);
                        if (stacked) {
                            return stacked;
                        }
                        stack.set(value, result);

                        if (isSet(value)) {
                            value.forEach(function(subValue) {
                                result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
                            });
                        } else if (isMap(value)) {
                            value.forEach(function(subValue, key) {
                                result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
                            });
                        }

                        var keysFunc = isFull
                            ? (isFlat ? getAllKeysIn : getAllKeys)
                            : (isFlat ? keysIn : keys);

                        var props = isArr ? undefined : keysFunc(value);
                        arrayEach(props || value, function(subValue, key) {
                            if (props) {
                                key = subValue;
                                subValue = value[key];
                            }
                            // Recursively populate clone (susceptible to call stack limits).
                            assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
                        });
                        return result;
                    }

                    /**
                     * The base implementation of `_.conforms` which doesn't clone `source`.
                     *
                     * @private
                     * @param {Object} source The object of property predicates to conform to.
                     * @returns {Function} Returns the new spec function.
                     */
                    function baseConforms(source) {
                        var props = keys(source);
                        return function(object) {
                            return baseConformsTo(object, source, props);
                        };
                    }

                    /**
                     * The base implementation of `_.conformsTo` which accepts `props` to check.
                     *
                     * @private
                     * @param {Object} object The object to inspect.
                     * @param {Object} source The object of property predicates to conform to.
                     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
                     */
                    function baseConformsTo(object, source, props) {
                        var length = props.length;
                        if (object == null) {
                            return !length;
                        }
                        object = Object(object);
                        while (length--) {
                            var key = props[length],
                                predicate = source[key],
                                value = object[key];

                            if ((value === undefined && !(key in object)) || !predicate(value)) {
                                return false;
                            }
                        }
                        return true;
                    }

                    /**
                     * The base implementation of `_.delay` and `_.defer` which accepts `args`
                     * to provide to `func`.
                     *
                     * @private
                     * @param {Function} func The function to delay.
                     * @param {number} wait The number of milliseconds to delay invocation.
                     * @param {Array} args The arguments to provide to `func`.
                     * @returns {number|Object} Returns the timer id or timeout object.
                     */
                    function baseDelay(func, wait, args) {
                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        return setTimeout(function() { func.apply(undefined, args); }, wait);
                    }

                    /**
                     * The base implementation of methods like `_.difference` without support
                     * for excluding multiple arrays or iteratee shorthands.
                     *
                     * @private
                     * @param {Array} array The array to inspect.
                     * @param {Array} values The values to exclude.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of filtered values.
                     */
                    function baseDifference(array, values, iteratee, comparator) {
                        var index = -1,
                            includes = arrayIncludes,
                            isCommon = true,
                            length = array.length,
                            result = [],
                            valuesLength = values.length;

                        if (!length) {
                            return result;
                        }
                        if (iteratee) {
                            values = arrayMap(values, baseUnary(iteratee));
                        }
                        if (comparator) {
                            includes = arrayIncludesWith;
                            isCommon = false;
                        }
                        else if (values.length >= LARGE_ARRAY_SIZE) {
                            includes = cacheHas;
                            isCommon = false;
                            values = new SetCache(values);
                        }
                        outer:
                            while (++index < length) {
                                var value = array[index],
                                    computed = iteratee == null ? value : iteratee(value);

                                value = (comparator || value !== 0) ? value : 0;
                                if (isCommon && computed === computed) {
                                    var valuesIndex = valuesLength;
                                    while (valuesIndex--) {
                                        if (values[valuesIndex] === computed) {
                                            continue outer;
                                        }
                                    }
                                    result.push(value);
                                }
                                else if (!includes(values, computed, comparator)) {
                                    result.push(value);
                                }
                            }
                        return result;
                    }

                    /**
                     * The base implementation of `_.forEach` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @returns {Array|Object} Returns `collection`.
                     */
                    var baseEach = createBaseEach(baseForOwn);

                    /**
                     * The base implementation of `_.forEachRight` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @returns {Array|Object} Returns `collection`.
                     */
                    var baseEachRight = createBaseEach(baseForOwnRight, true);

                    /**
                     * The base implementation of `_.every` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} predicate The function invoked per iteration.
                     * @returns {boolean} Returns `true` if all elements pass the predicate check,
                     *  else `false`
                     */
                    function baseEvery(collection, predicate) {
                        var result = true;
                        baseEach(collection, function(value, index, collection) {
                            result = !!predicate(value, index, collection);
                            return result;
                        });
                        return result;
                    }

                    /**
                     * The base implementation of methods like `_.max` and `_.min` which accepts a
                     * `comparator` to determine the extremum value.
                     *
                     * @private
                     * @param {Array} array The array to iterate over.
                     * @param {Function} iteratee The iteratee invoked per iteration.
                     * @param {Function} comparator The comparator used to compare values.
                     * @returns {*} Returns the extremum value.
                     */
                    function baseExtremum(array, iteratee, comparator) {
                        var index = -1,
                            length = array.length;

                        while (++index < length) {
                            var value = array[index],
                                current = iteratee(value);

                            if (current != null && (computed === undefined
                                    ? (current === current && !isSymbol(current))
                                    : comparator(current, computed)
                            )) {
                                var computed = current,
                                    result = value;
                            }
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.fill` without an iteratee call guard.
                     *
                     * @private
                     * @param {Array} array The array to fill.
                     * @param {*} value The value to fill `array` with.
                     * @param {number} [start=0] The start position.
                     * @param {number} [end=array.length] The end position.
                     * @returns {Array} Returns `array`.
                     */
                    function baseFill(array, value, start, end) {
                        var length = array.length;

                        start = toInteger(start);
                        if (start < 0) {
                            start = -start > length ? 0 : (length + start);
                        }
                        end = (end === undefined || end > length) ? length : toInteger(end);
                        if (end < 0) {
                            end += length;
                        }
                        end = start > end ? 0 : toLength(end);
                        while (start < end) {
                            array[start++] = value;
                        }
                        return array;
                    }

                    /**
                     * The base implementation of `_.filter` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} predicate The function invoked per iteration.
                     * @returns {Array} Returns the new filtered array.
                     */
                    function baseFilter(collection, predicate) {
                        var result = [];
                        baseEach(collection, function(value, index, collection) {
                            if (predicate(value, index, collection)) {
                                result.push(value);
                            }
                        });
                        return result;
                    }

                    /**
                     * The base implementation of `_.flatten` with support for restricting flattening.
                     *
                     * @private
                     * @param {Array} array The array to flatten.
                     * @param {number} depth The maximum recursion depth.
                     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
                     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
                     * @param {Array} [result=[]] The initial result value.
                     * @returns {Array} Returns the new flattened array.
                     */
                    function baseFlatten(array, depth, predicate, isStrict, result) {
                        var index = -1,
                            length = array.length;

                        predicate || (predicate = isFlattenable);
                        result || (result = []);

                        while (++index < length) {
                            var value = array[index];
                            if (depth > 0 && predicate(value)) {
                                if (depth > 1) {
                                    // Recursively flatten arrays (susceptible to call stack limits).
                                    baseFlatten(value, depth - 1, predicate, isStrict, result);
                                } else {
                                    arrayPush(result, value);
                                }
                            } else if (!isStrict) {
                                result[result.length] = value;
                            }
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `baseForOwn` which iterates over `object`
                     * properties returned by `keysFunc` and invokes `iteratee` for each property.
                     * Iteratee functions may exit iteration early by explicitly returning `false`.
                     *
                     * @private
                     * @param {Object} object The object to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @param {Function} keysFunc The function to get the keys of `object`.
                     * @returns {Object} Returns `object`.
                     */
                    var baseFor = createBaseFor();

                    /**
                     * This function is like `baseFor` except that it iterates over properties
                     * in the opposite order.
                     *
                     * @private
                     * @param {Object} object The object to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @param {Function} keysFunc The function to get the keys of `object`.
                     * @returns {Object} Returns `object`.
                     */
                    var baseForRight = createBaseFor(true);

                    /**
                     * The base implementation of `_.forOwn` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Object} object The object to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @returns {Object} Returns `object`.
                     */
                    function baseForOwn(object, iteratee) {
                        return object && baseFor(object, iteratee, keys);
                    }

                    /**
                     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Object} object The object to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @returns {Object} Returns `object`.
                     */
                    function baseForOwnRight(object, iteratee) {
                        return object && baseForRight(object, iteratee, keys);
                    }

                    /**
                     * The base implementation of `_.functions` which creates an array of
                     * `object` function property names filtered from `props`.
                     *
                     * @private
                     * @param {Object} object The object to inspect.
                     * @param {Array} props The property names to filter.
                     * @returns {Array} Returns the function names.
                     */
                    function baseFunctions(object, props) {
                        return arrayFilter(props, function(key) {
                            return isFunction(object[key]);
                        });
                    }

                    /**
                     * The base implementation of `_.get` without support for default values.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path of the property to get.
                     * @returns {*} Returns the resolved value.
                     */
                    function baseGet(object, path) {
                        path = castPath(path, object);

                        var index = 0,
                            length = path.length;

                        while (object != null && index < length) {
                            object = object[toKey(path[index++])];
                        }
                        return (index && index == length) ? object : undefined;
                    }

                    /**
                     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
                     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
                     * symbols of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {Function} keysFunc The function to get the keys of `object`.
                     * @param {Function} symbolsFunc The function to get the symbols of `object`.
                     * @returns {Array} Returns the array of property names and symbols.
                     */
                    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
                        var result = keysFunc(object);
                        return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
                    }

                    /**
                     * The base implementation of `getTag` without fallbacks for buggy environments.
                     *
                     * @private
                     * @param {*} value The value to query.
                     * @returns {string} Returns the `toStringTag`.
                     */
                    function baseGetTag(value) {
                        if (value == null) {
                            return value === undefined ? undefinedTag : nullTag;
                        }
                        return (symToStringTag && symToStringTag in Object(value))
                            ? getRawTag(value)
                            : objectToString(value);
                    }

                    /**
                     * The base implementation of `_.gt` which doesn't coerce arguments.
                     *
                     * @private
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if `value` is greater than `other`,
                     *  else `false`.
                     */
                    function baseGt(value, other) {
                        return value > other;
                    }

                    /**
                     * The base implementation of `_.has` without support for deep paths.
                     *
                     * @private
                     * @param {Object} [object] The object to query.
                     * @param {Array|string} key The key to check.
                     * @returns {boolean} Returns `true` if `key` exists, else `false`.
                     */
                    function baseHas(object, key) {
                        return object != null && hasOwnProperty.call(object, key);
                    }

                    /**
                     * The base implementation of `_.hasIn` without support for deep paths.
                     *
                     * @private
                     * @param {Object} [object] The object to query.
                     * @param {Array|string} key The key to check.
                     * @returns {boolean} Returns `true` if `key` exists, else `false`.
                     */
                    function baseHasIn(object, key) {
                        return object != null && key in Object(object);
                    }

                    /**
                     * The base implementation of `_.inRange` which doesn't coerce arguments.
                     *
                     * @private
                     * @param {number} number The number to check.
                     * @param {number} start The start of the range.
                     * @param {number} end The end of the range.
                     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
                     */
                    function baseInRange(number, start, end) {
                        return number >= nativeMin(start, end) && number < nativeMax(start, end);
                    }

                    /**
                     * The base implementation of methods like `_.intersection`, without support
                     * for iteratee shorthands, that accepts an array of arrays to inspect.
                     *
                     * @private
                     * @param {Array} arrays The arrays to inspect.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of shared values.
                     */
                    function baseIntersection(arrays, iteratee, comparator) {
                        var includes = comparator ? arrayIncludesWith : arrayIncludes,
                            length = arrays[0].length,
                            othLength = arrays.length,
                            othIndex = othLength,
                            caches = Array(othLength),
                            maxLength = Infinity,
                            result = [];

                        while (othIndex--) {
                            var array = arrays[othIndex];
                            if (othIndex && iteratee) {
                                array = arrayMap(array, baseUnary(iteratee));
                            }
                            maxLength = nativeMin(array.length, maxLength);
                            caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
                                ? new SetCache(othIndex && array)
                                : undefined;
                        }
                        array = arrays[0];

                        var index = -1,
                            seen = caches[0];

                        outer:
                            while (++index < length && result.length < maxLength) {
                                var value = array[index],
                                    computed = iteratee ? iteratee(value) : value;

                                value = (comparator || value !== 0) ? value : 0;
                                if (!(seen
                                        ? cacheHas(seen, computed)
                                        : includes(result, computed, comparator)
                                )) {
                                    othIndex = othLength;
                                    while (--othIndex) {
                                        var cache = caches[othIndex];
                                        if (!(cache
                                            ? cacheHas(cache, computed)
                                            : includes(arrays[othIndex], computed, comparator))
                                        ) {
                                            continue outer;
                                        }
                                    }
                                    if (seen) {
                                        seen.push(computed);
                                    }
                                    result.push(value);
                                }
                            }
                        return result;
                    }

                    /**
                     * The base implementation of `_.invert` and `_.invertBy` which inverts
                     * `object` with values transformed by `iteratee` and set by `setter`.
                     *
                     * @private
                     * @param {Object} object The object to iterate over.
                     * @param {Function} setter The function to set `accumulator` values.
                     * @param {Function} iteratee The iteratee to transform values.
                     * @param {Object} accumulator The initial inverted object.
                     * @returns {Function} Returns `accumulator`.
                     */
                    function baseInverter(object, setter, iteratee, accumulator) {
                        baseForOwn(object, function(value, key, object) {
                            setter(accumulator, iteratee(value), key, object);
                        });
                        return accumulator;
                    }

                    /**
                     * The base implementation of `_.invoke` without support for individual
                     * method arguments.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path of the method to invoke.
                     * @param {Array} args The arguments to invoke the method with.
                     * @returns {*} Returns the result of the invoked method.
                     */
                    function baseInvoke(object, path, args) {
                        path = castPath(path, object);
                        object = parent(object, path);
                        var func = object == null ? object : object[toKey(last(path))];
                        return func == null ? undefined : apply(func, object, args);
                    }

                    /**
                     * The base implementation of `_.isArguments`.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
                     */
                    function baseIsArguments(value) {
                        return isObjectLike(value) && baseGetTag(value) == argsTag;
                    }

                    /**
                     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
                     */
                    function baseIsArrayBuffer(value) {
                        return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
                    }

                    /**
                     * The base implementation of `_.isDate` without Node.js optimizations.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
                     */
                    function baseIsDate(value) {
                        return isObjectLike(value) && baseGetTag(value) == dateTag;
                    }

                    /**
                     * The base implementation of `_.isEqual` which supports partial comparisons
                     * and tracks traversed objects.
                     *
                     * @private
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @param {boolean} bitmask The bitmask flags.
                     *  1 - Unordered comparison
                     *  2 - Partial comparison
                     * @param {Function} [customizer] The function to customize comparisons.
                     * @param {Object} [stack] Tracks traversed `value` and `other` objects.
                     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
                     */
                    function baseIsEqual(value, other, bitmask, customizer, stack) {
                        if (value === other) {
                            return true;
                        }
                        if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
                            return value !== value && other !== other;
                        }
                        return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
                    }

                    /**
                     * A specialized version of `baseIsEqual` for arrays and objects which performs
                     * deep comparisons and tracks traversed objects enabling objects with circular
                     * references to be compared.
                     *
                     * @private
                     * @param {Object} object The object to compare.
                     * @param {Object} other The other object to compare.
                     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
                     * @param {Function} customizer The function to customize comparisons.
                     * @param {Function} equalFunc The function to determine equivalents of values.
                     * @param {Object} [stack] Tracks traversed `object` and `other` objects.
                     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
                     */
                    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
                        var objIsArr = isArray(object),
                            othIsArr = isArray(other),
                            objTag = objIsArr ? arrayTag : getTag(object),
                            othTag = othIsArr ? arrayTag : getTag(other);

                        objTag = objTag == argsTag ? objectTag : objTag;
                        othTag = othTag == argsTag ? objectTag : othTag;

                        var objIsObj = objTag == objectTag,
                            othIsObj = othTag == objectTag,
                            isSameTag = objTag == othTag;

                        if (isSameTag && isBuffer(object)) {
                            if (!isBuffer(other)) {
                                return false;
                            }
                            objIsArr = true;
                            objIsObj = false;
                        }
                        if (isSameTag && !objIsObj) {
                            stack || (stack = new Stack);
                            return (objIsArr || isTypedArray(object))
                                ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
                                : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
                        }
                        if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
                            var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
                                othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

                            if (objIsWrapped || othIsWrapped) {
                                var objUnwrapped = objIsWrapped ? object.value() : object,
                                    othUnwrapped = othIsWrapped ? other.value() : other;

                                stack || (stack = new Stack);
                                return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
                            }
                        }
                        if (!isSameTag) {
                            return false;
                        }
                        stack || (stack = new Stack);
                        return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
                    }

                    /**
                     * The base implementation of `_.isMap` without Node.js optimizations.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
                     */
                    function baseIsMap(value) {
                        return isObjectLike(value) && getTag(value) == mapTag;
                    }

                    /**
                     * The base implementation of `_.isMatch` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Object} object The object to inspect.
                     * @param {Object} source The object of property values to match.
                     * @param {Array} matchData The property names, values, and compare flags to match.
                     * @param {Function} [customizer] The function to customize comparisons.
                     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
                     */
                    function baseIsMatch(object, source, matchData, customizer) {
                        var index = matchData.length,
                            length = index,
                            noCustomizer = !customizer;

                        if (object == null) {
                            return !length;
                        }
                        object = Object(object);
                        while (index--) {
                            var data = matchData[index];
                            if ((noCustomizer && data[2])
                                ? data[1] !== object[data[0]]
                                : !(data[0] in object)
                            ) {
                                return false;
                            }
                        }
                        while (++index < length) {
                            data = matchData[index];
                            var key = data[0],
                                objValue = object[key],
                                srcValue = data[1];

                            if (noCustomizer && data[2]) {
                                if (objValue === undefined && !(key in object)) {
                                    return false;
                                }
                            } else {
                                var stack = new Stack;
                                if (customizer) {
                                    var result = customizer(objValue, srcValue, key, object, source, stack);
                                }
                                if (!(result === undefined
                                        ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
                                        : result
                                )) {
                                    return false;
                                }
                            }
                        }
                        return true;
                    }

                    /**
                     * The base implementation of `_.isNative` without bad shim checks.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a native function,
                     *  else `false`.
                     */
                    function baseIsNative(value) {
                        if (!isObject(value) || isMasked(value)) {
                            return false;
                        }
                        var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
                        return pattern.test(toSource(value));
                    }

                    /**
                     * The base implementation of `_.isRegExp` without Node.js optimizations.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
                     */
                    function baseIsRegExp(value) {
                        return isObjectLike(value) && baseGetTag(value) == regexpTag;
                    }

                    /**
                     * The base implementation of `_.isSet` without Node.js optimizations.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
                     */
                    function baseIsSet(value) {
                        return isObjectLike(value) && getTag(value) == setTag;
                    }

                    /**
                     * The base implementation of `_.isTypedArray` without Node.js optimizations.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
                     */
                    function baseIsTypedArray(value) {
                        return isObjectLike(value) &&
                            isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
                    }

                    /**
                     * The base implementation of `_.iteratee`.
                     *
                     * @private
                     * @param {*} [value=_.identity] The value to convert to an iteratee.
                     * @returns {Function} Returns the iteratee.
                     */
                    function baseIteratee(value) {
                        // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
                        // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
                        if (typeof value == 'function') {
                            return value;
                        }
                        if (value == null) {
                            return identity;
                        }
                        if (typeof value == 'object') {
                            return isArray(value)
                                ? baseMatchesProperty(value[0], value[1])
                                : baseMatches(value);
                        }
                        return property(value);
                    }

                    /**
                     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names.
                     */
                    function baseKeys(object) {
                        if (!isPrototype(object)) {
                            return nativeKeys(object);
                        }
                        var result = [];
                        for (var key in Object(object)) {
                            if (hasOwnProperty.call(object, key) && key != 'constructor') {
                                result.push(key);
                            }
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names.
                     */
                    function baseKeysIn(object) {
                        if (!isObject(object)) {
                            return nativeKeysIn(object);
                        }
                        var isProto = isPrototype(object),
                            result = [];

                        for (var key in object) {
                            if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
                                result.push(key);
                            }
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.lt` which doesn't coerce arguments.
                     *
                     * @private
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if `value` is less than `other`,
                     *  else `false`.
                     */
                    function baseLt(value, other) {
                        return value < other;
                    }

                    /**
                     * The base implementation of `_.map` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} iteratee The function invoked per iteration.
                     * @returns {Array} Returns the new mapped array.
                     */
                    function baseMap(collection, iteratee) {
                        var index = -1,
                            result = isArrayLike(collection) ? Array(collection.length) : [];

                        baseEach(collection, function(value, key, collection) {
                            result[++index] = iteratee(value, key, collection);
                        });
                        return result;
                    }

                    /**
                     * The base implementation of `_.matches` which doesn't clone `source`.
                     *
                     * @private
                     * @param {Object} source The object of property values to match.
                     * @returns {Function} Returns the new spec function.
                     */
                    function baseMatches(source) {
                        var matchData = getMatchData(source);
                        if (matchData.length == 1 && matchData[0][2]) {
                            return matchesStrictComparable(matchData[0][0], matchData[0][1]);
                        }
                        return function(object) {
                            return object === source || baseIsMatch(object, source, matchData);
                        };
                    }

                    /**
                     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
                     *
                     * @private
                     * @param {string} path The path of the property to get.
                     * @param {*} srcValue The value to match.
                     * @returns {Function} Returns the new spec function.
                     */
                    function baseMatchesProperty(path, srcValue) {
                        if (isKey(path) && isStrictComparable(srcValue)) {
                            return matchesStrictComparable(toKey(path), srcValue);
                        }
                        return function(object) {
                            var objValue = get(object, path);
                            return (objValue === undefined && objValue === srcValue)
                                ? hasIn(object, path)
                                : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
                        };
                    }

                    /**
                     * The base implementation of `_.merge` without support for multiple sources.
                     *
                     * @private
                     * @param {Object} object The destination object.
                     * @param {Object} source The source object.
                     * @param {number} srcIndex The index of `source`.
                     * @param {Function} [customizer] The function to customize merged values.
                     * @param {Object} [stack] Tracks traversed source values and their merged
                     *  counterparts.
                     */
                    function baseMerge(object, source, srcIndex, customizer, stack) {
                        if (object === source) {
                            return;
                        }
                        baseFor(source, function(srcValue, key) {
                            stack || (stack = new Stack);
                            if (isObject(srcValue)) {
                                baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
                            }
                            else {
                                var newValue = customizer
                                    ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
                                    : undefined;

                                if (newValue === undefined) {
                                    newValue = srcValue;
                                }
                                assignMergeValue(object, key, newValue);
                            }
                        }, keysIn);
                    }

                    /**
                     * A specialized version of `baseMerge` for arrays and objects which performs
                     * deep merges and tracks traversed objects enabling objects with circular
                     * references to be merged.
                     *
                     * @private
                     * @param {Object} object The destination object.
                     * @param {Object} source The source object.
                     * @param {string} key The key of the value to merge.
                     * @param {number} srcIndex The index of `source`.
                     * @param {Function} mergeFunc The function to merge values.
                     * @param {Function} [customizer] The function to customize assigned values.
                     * @param {Object} [stack] Tracks traversed source values and their merged
                     *  counterparts.
                     */
                    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
                        var objValue = safeGet(object, key),
                            srcValue = safeGet(source, key),
                            stacked = stack.get(srcValue);

                        if (stacked) {
                            assignMergeValue(object, key, stacked);
                            return;
                        }
                        var newValue = customizer
                            ? customizer(objValue, srcValue, (key + ''), object, source, stack)
                            : undefined;

                        var isCommon = newValue === undefined;

                        if (isCommon) {
                            var isArr = isArray(srcValue),
                                isBuff = !isArr && isBuffer(srcValue),
                                isTyped = !isArr && !isBuff && isTypedArray(srcValue);

                            newValue = srcValue;
                            if (isArr || isBuff || isTyped) {
                                if (isArray(objValue)) {
                                    newValue = objValue;
                                }
                                else if (isArrayLikeObject(objValue)) {
                                    newValue = copyArray(objValue);
                                }
                                else if (isBuff) {
                                    isCommon = false;
                                    newValue = cloneBuffer(srcValue, true);
                                }
                                else if (isTyped) {
                                    isCommon = false;
                                    newValue = cloneTypedArray(srcValue, true);
                                }
                                else {
                                    newValue = [];
                                }
                            }
                            else if (isPlainObject(srcValue) || isArguments(srcValue)) {
                                newValue = objValue;
                                if (isArguments(objValue)) {
                                    newValue = toPlainObject(objValue);
                                }
                                else if (!isObject(objValue) || isFunction(objValue)) {
                                    newValue = initCloneObject(srcValue);
                                }
                            }
                            else {
                                isCommon = false;
                            }
                        }
                        if (isCommon) {
                            // Recursively merge objects and arrays (susceptible to call stack limits).
                            stack.set(srcValue, newValue);
                            mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
                            stack['delete'](srcValue);
                        }
                        assignMergeValue(object, key, newValue);
                    }

                    /**
                     * The base implementation of `_.nth` which doesn't coerce arguments.
                     *
                     * @private
                     * @param {Array} array The array to query.
                     * @param {number} n The index of the element to return.
                     * @returns {*} Returns the nth element of `array`.
                     */
                    function baseNth(array, n) {
                        var length = array.length;
                        if (!length) {
                            return;
                        }
                        n += n < 0 ? length : 0;
                        return isIndex(n, length) ? array[n] : undefined;
                    }

                    /**
                     * The base implementation of `_.orderBy` without param guards.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
                     * @param {string[]} orders The sort orders of `iteratees`.
                     * @returns {Array} Returns the new sorted array.
                     */
                    function baseOrderBy(collection, iteratees, orders) {
                        if (iteratees.length) {
                            iteratees = arrayMap(iteratees, function(iteratee) {
                                if (isArray(iteratee)) {
                                    return function(value) {
                                        return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
                                    }
                                }
                                return iteratee;
                            });
                        } else {
                            iteratees = [identity];
                        }

                        var index = -1;
                        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));

                        var result = baseMap(collection, function(value, key, collection) {
                            var criteria = arrayMap(iteratees, function(iteratee) {
                                return iteratee(value);
                            });
                            return { 'criteria': criteria, 'index': ++index, 'value': value };
                        });

                        return baseSortBy(result, function(object, other) {
                            return compareMultiple(object, other, orders);
                        });
                    }

                    /**
                     * The base implementation of `_.pick` without support for individual
                     * property identifiers.
                     *
                     * @private
                     * @param {Object} object The source object.
                     * @param {string[]} paths The property paths to pick.
                     * @returns {Object} Returns the new object.
                     */
                    function basePick(object, paths) {
                        return basePickBy(object, paths, function(value, path) {
                            return hasIn(object, path);
                        });
                    }

                    /**
                     * The base implementation of  `_.pickBy` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Object} object The source object.
                     * @param {string[]} paths The property paths to pick.
                     * @param {Function} predicate The function invoked per property.
                     * @returns {Object} Returns the new object.
                     */
                    function basePickBy(object, paths, predicate) {
                        var index = -1,
                            length = paths.length,
                            result = {};

                        while (++index < length) {
                            var path = paths[index],
                                value = baseGet(object, path);

                            if (predicate(value, path)) {
                                baseSet(result, castPath(path, object), value);
                            }
                        }
                        return result;
                    }

                    /**
                     * A specialized version of `baseProperty` which supports deep paths.
                     *
                     * @private
                     * @param {Array|string} path The path of the property to get.
                     * @returns {Function} Returns the new accessor function.
                     */
                    function basePropertyDeep(path) {
                        return function(object) {
                            return baseGet(object, path);
                        };
                    }

                    /**
                     * The base implementation of `_.pullAllBy` without support for iteratee
                     * shorthands.
                     *
                     * @private
                     * @param {Array} array The array to modify.
                     * @param {Array} values The values to remove.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns `array`.
                     */
                    function basePullAll(array, values, iteratee, comparator) {
                        var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
                            index = -1,
                            length = values.length,
                            seen = array;

                        if (array === values) {
                            values = copyArray(values);
                        }
                        if (iteratee) {
                            seen = arrayMap(array, baseUnary(iteratee));
                        }
                        while (++index < length) {
                            var fromIndex = 0,
                                value = values[index],
                                computed = iteratee ? iteratee(value) : value;

                            while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
                                if (seen !== array) {
                                    splice.call(seen, fromIndex, 1);
                                }
                                splice.call(array, fromIndex, 1);
                            }
                        }
                        return array;
                    }

                    /**
                     * The base implementation of `_.pullAt` without support for individual
                     * indexes or capturing the removed elements.
                     *
                     * @private
                     * @param {Array} array The array to modify.
                     * @param {number[]} indexes The indexes of elements to remove.
                     * @returns {Array} Returns `array`.
                     */
                    function basePullAt(array, indexes) {
                        var length = array ? indexes.length : 0,
                            lastIndex = length - 1;

                        while (length--) {
                            var index = indexes[length];
                            if (length == lastIndex || index !== previous) {
                                var previous = index;
                                if (isIndex(index)) {
                                    splice.call(array, index, 1);
                                } else {
                                    baseUnset(array, index);
                                }
                            }
                        }
                        return array;
                    }

                    /**
                     * The base implementation of `_.random` without support for returning
                     * floating-point numbers.
                     *
                     * @private
                     * @param {number} lower The lower bound.
                     * @param {number} upper The upper bound.
                     * @returns {number} Returns the random number.
                     */
                    function baseRandom(lower, upper) {
                        return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
                    }

                    /**
                     * The base implementation of `_.range` and `_.rangeRight` which doesn't
                     * coerce arguments.
                     *
                     * @private
                     * @param {number} start The start of the range.
                     * @param {number} end The end of the range.
                     * @param {number} step The value to increment or decrement by.
                     * @param {boolean} [fromRight] Specify iterating from right to left.
                     * @returns {Array} Returns the range of numbers.
                     */
                    function baseRange(start, end, step, fromRight) {
                        var index = -1,
                            length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
                            result = Array(length);

                        while (length--) {
                            result[fromRight ? length : ++index] = start;
                            start += step;
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.repeat` which doesn't coerce arguments.
                     *
                     * @private
                     * @param {string} string The string to repeat.
                     * @param {number} n The number of times to repeat the string.
                     * @returns {string} Returns the repeated string.
                     */
                    function baseRepeat(string, n) {
                        var result = '';
                        if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
                            return result;
                        }
                        // Leverage the exponentiation by squaring algorithm for a faster repeat.
                        // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
                        do {
                            if (n % 2) {
                                result += string;
                            }
                            n = nativeFloor(n / 2);
                            if (n) {
                                string += string;
                            }
                        } while (n);

                        return result;
                    }

                    /**
                     * The base implementation of `_.rest` which doesn't validate or coerce arguments.
                     *
                     * @private
                     * @param {Function} func The function to apply a rest parameter to.
                     * @param {number} [start=func.length-1] The start position of the rest parameter.
                     * @returns {Function} Returns the new function.
                     */
                    function baseRest(func, start) {
                        return setToString(overRest(func, start, identity), func + '');
                    }

                    /**
                     * The base implementation of `_.sample`.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to sample.
                     * @returns {*} Returns the random element.
                     */
                    function baseSample(collection) {
                        return arraySample(values(collection));
                    }

                    /**
                     * The base implementation of `_.sampleSize` without param guards.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to sample.
                     * @param {number} n The number of elements to sample.
                     * @returns {Array} Returns the random elements.
                     */
                    function baseSampleSize(collection, n) {
                        var array = values(collection);
                        return shuffleSelf(array, baseClamp(n, 0, array.length));
                    }

                    /**
                     * The base implementation of `_.set`.
                     *
                     * @private
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to set.
                     * @param {*} value The value to set.
                     * @param {Function} [customizer] The function to customize path creation.
                     * @returns {Object} Returns `object`.
                     */
                    function baseSet(object, path, value, customizer) {
                        if (!isObject(object)) {
                            return object;
                        }
                        path = castPath(path, object);

                        var index = -1,
                            length = path.length,
                            lastIndex = length - 1,
                            nested = object;

                        while (nested != null && ++index < length) {
                            var key = toKey(path[index]),
                                newValue = value;

                            if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
                                return object;
                            }

                            if (index != lastIndex) {
                                var objValue = nested[key];
                                newValue = customizer ? customizer(objValue, key, nested) : undefined;
                                if (newValue === undefined) {
                                    newValue = isObject(objValue)
                                        ? objValue
                                        : (isIndex(path[index + 1]) ? [] : {});
                                }
                            }
                            assignValue(nested, key, newValue);
                            nested = nested[key];
                        }
                        return object;
                    }

                    /**
                     * The base implementation of `setData` without support for hot loop shorting.
                     *
                     * @private
                     * @param {Function} func The function to associate metadata with.
                     * @param {*} data The metadata.
                     * @returns {Function} Returns `func`.
                     */
                    var baseSetData = !metaMap ? identity : function(func, data) {
                        metaMap.set(func, data);
                        return func;
                    };

                    /**
                     * The base implementation of `setToString` without support for hot loop shorting.
                     *
                     * @private
                     * @param {Function} func The function to modify.
                     * @param {Function} string The `toString` result.
                     * @returns {Function} Returns `func`.
                     */
                    var baseSetToString = !defineProperty ? identity : function(func, string) {
                        return defineProperty(func, 'toString', {
                            'configurable': true,
                            'enumerable': false,
                            'value': constant(string),
                            'writable': true
                        });
                    };

                    /**
                     * The base implementation of `_.shuffle`.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to shuffle.
                     * @returns {Array} Returns the new shuffled array.
                     */
                    function baseShuffle(collection) {
                        return shuffleSelf(values(collection));
                    }

                    /**
                     * The base implementation of `_.slice` without an iteratee call guard.
                     *
                     * @private
                     * @param {Array} array The array to slice.
                     * @param {number} [start=0] The start position.
                     * @param {number} [end=array.length] The end position.
                     * @returns {Array} Returns the slice of `array`.
                     */
                    function baseSlice(array, start, end) {
                        var index = -1,
                            length = array.length;

                        if (start < 0) {
                            start = -start > length ? 0 : (length + start);
                        }
                        end = end > length ? length : end;
                        if (end < 0) {
                            end += length;
                        }
                        length = start > end ? 0 : ((end - start) >>> 0);
                        start >>>= 0;

                        var result = Array(length);
                        while (++index < length) {
                            result[index] = array[index + start];
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.some` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} predicate The function invoked per iteration.
                     * @returns {boolean} Returns `true` if any element passes the predicate check,
                     *  else `false`.
                     */
                    function baseSome(collection, predicate) {
                        var result;

                        baseEach(collection, function(value, index, collection) {
                            result = predicate(value, index, collection);
                            return !result;
                        });
                        return !!result;
                    }

                    /**
                     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
                     * performs a binary search of `array` to determine the index at which `value`
                     * should be inserted into `array` in order to maintain its sort order.
                     *
                     * @private
                     * @param {Array} array The sorted array to inspect.
                     * @param {*} value The value to evaluate.
                     * @param {boolean} [retHighest] Specify returning the highest qualified index.
                     * @returns {number} Returns the index at which `value` should be inserted
                     *  into `array`.
                     */
                    function baseSortedIndex(array, value, retHighest) {
                        var low = 0,
                            high = array == null ? low : array.length;

                        if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
                            while (low < high) {
                                var mid = (low + high) >>> 1,
                                    computed = array[mid];

                                if (computed !== null && !isSymbol(computed) &&
                                    (retHighest ? (computed <= value) : (computed < value))) {
                                    low = mid + 1;
                                } else {
                                    high = mid;
                                }
                            }
                            return high;
                        }
                        return baseSortedIndexBy(array, value, identity, retHighest);
                    }

                    /**
                     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
                     * which invokes `iteratee` for `value` and each element of `array` to compute
                     * their sort ranking. The iteratee is invoked with one argument; (value).
                     *
                     * @private
                     * @param {Array} array The sorted array to inspect.
                     * @param {*} value The value to evaluate.
                     * @param {Function} iteratee The iteratee invoked per element.
                     * @param {boolean} [retHighest] Specify returning the highest qualified index.
                     * @returns {number} Returns the index at which `value` should be inserted
                     *  into `array`.
                     */
                    function baseSortedIndexBy(array, value, iteratee, retHighest) {
                        var low = 0,
                            high = array == null ? 0 : array.length;
                        if (high === 0) {
                            return 0;
                        }

                        value = iteratee(value);
                        var valIsNaN = value !== value,
                            valIsNull = value === null,
                            valIsSymbol = isSymbol(value),
                            valIsUndefined = value === undefined;

                        while (low < high) {
                            var mid = nativeFloor((low + high) / 2),
                                computed = iteratee(array[mid]),
                                othIsDefined = computed !== undefined,
                                othIsNull = computed === null,
                                othIsReflexive = computed === computed,
                                othIsSymbol = isSymbol(computed);

                            if (valIsNaN) {
                                var setLow = retHighest || othIsReflexive;
                            } else if (valIsUndefined) {
                                setLow = othIsReflexive && (retHighest || othIsDefined);
                            } else if (valIsNull) {
                                setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
                            } else if (valIsSymbol) {
                                setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
                            } else if (othIsNull || othIsSymbol) {
                                setLow = false;
                            } else {
                                setLow = retHighest ? (computed <= value) : (computed < value);
                            }
                            if (setLow) {
                                low = mid + 1;
                            } else {
                                high = mid;
                            }
                        }
                        return nativeMin(high, MAX_ARRAY_INDEX);
                    }

                    /**
                     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
                     * support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array} array The array to inspect.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @returns {Array} Returns the new duplicate free array.
                     */
                    function baseSortedUniq(array, iteratee) {
                        var index = -1,
                            length = array.length,
                            resIndex = 0,
                            result = [];

                        while (++index < length) {
                            var value = array[index],
                                computed = iteratee ? iteratee(value) : value;

                            if (!index || !eq(computed, seen)) {
                                var seen = computed;
                                result[resIndex++] = value === 0 ? 0 : value;
                            }
                        }
                        return result;
                    }

                    /**
                     * The base implementation of `_.toNumber` which doesn't ensure correct
                     * conversions of binary, hexadecimal, or octal string values.
                     *
                     * @private
                     * @param {*} value The value to process.
                     * @returns {number} Returns the number.
                     */
                    function baseToNumber(value) {
                        if (typeof value == 'number') {
                            return value;
                        }
                        if (isSymbol(value)) {
                            return NAN;
                        }
                        return +value;
                    }

                    /**
                     * The base implementation of `_.toString` which doesn't convert nullish
                     * values to empty strings.
                     *
                     * @private
                     * @param {*} value The value to process.
                     * @returns {string} Returns the string.
                     */
                    function baseToString(value) {
                        // Exit early for strings to avoid a performance hit in some environments.
                        if (typeof value == 'string') {
                            return value;
                        }
                        if (isArray(value)) {
                            // Recursively convert values (susceptible to call stack limits).
                            return arrayMap(value, baseToString) + '';
                        }
                        if (isSymbol(value)) {
                            return symbolToString ? symbolToString.call(value) : '';
                        }
                        var result = (value + '');
                        return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
                    }

                    /**
                     * The base implementation of `_.uniqBy` without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array} array The array to inspect.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new duplicate free array.
                     */
                    function baseUniq(array, iteratee, comparator) {
                        var index = -1,
                            includes = arrayIncludes,
                            length = array.length,
                            isCommon = true,
                            result = [],
                            seen = result;

                        if (comparator) {
                            isCommon = false;
                            includes = arrayIncludesWith;
                        }
                        else if (length >= LARGE_ARRAY_SIZE) {
                            var set = iteratee ? null : createSet(array);
                            if (set) {
                                return setToArray(set);
                            }
                            isCommon = false;
                            includes = cacheHas;
                            seen = new SetCache;
                        }
                        else {
                            seen = iteratee ? [] : result;
                        }
                        outer:
                            while (++index < length) {
                                var value = array[index],
                                    computed = iteratee ? iteratee(value) : value;

                                value = (comparator || value !== 0) ? value : 0;
                                if (isCommon && computed === computed) {
                                    var seenIndex = seen.length;
                                    while (seenIndex--) {
                                        if (seen[seenIndex] === computed) {
                                            continue outer;
                                        }
                                    }
                                    if (iteratee) {
                                        seen.push(computed);
                                    }
                                    result.push(value);
                                }
                                else if (!includes(seen, computed, comparator)) {
                                    if (seen !== result) {
                                        seen.push(computed);
                                    }
                                    result.push(value);
                                }
                            }
                        return result;
                    }

                    /**
                     * The base implementation of `_.unset`.
                     *
                     * @private
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The property path to unset.
                     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
                     */
                    function baseUnset(object, path) {
                        path = castPath(path, object);
                        object = parent(object, path);
                        return object == null || delete object[toKey(last(path))];
                    }

                    /**
                     * The base implementation of `_.update`.
                     *
                     * @private
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to update.
                     * @param {Function} updater The function to produce the updated value.
                     * @param {Function} [customizer] The function to customize path creation.
                     * @returns {Object} Returns `object`.
                     */
                    function baseUpdate(object, path, updater, customizer) {
                        return baseSet(object, path, updater(baseGet(object, path)), customizer);
                    }

                    /**
                     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
                     * without support for iteratee shorthands.
                     *
                     * @private
                     * @param {Array} array The array to query.
                     * @param {Function} predicate The function invoked per iteration.
                     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
                     * @param {boolean} [fromRight] Specify iterating from right to left.
                     * @returns {Array} Returns the slice of `array`.
                     */
                    function baseWhile(array, predicate, isDrop, fromRight) {
                        var length = array.length,
                            index = fromRight ? length : -1;

                        while ((fromRight ? index-- : ++index < length) &&
                        predicate(array[index], index, array)) {}

                        return isDrop
                            ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
                            : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
                    }

                    /**
                     * The base implementation of `wrapperValue` which returns the result of
                     * performing a sequence of actions on the unwrapped `value`, where each
                     * successive action is supplied the return value of the previous.
                     *
                     * @private
                     * @param {*} value The unwrapped value.
                     * @param {Array} actions Actions to perform to resolve the unwrapped value.
                     * @returns {*} Returns the resolved value.
                     */
                    function baseWrapperValue(value, actions) {
                        var result = value;
                        if (result instanceof LazyWrapper) {
                            result = result.value();
                        }
                        return arrayReduce(actions, function(result, action) {
                            return action.func.apply(action.thisArg, arrayPush([result], action.args));
                        }, result);
                    }

                    /**
                     * The base implementation of methods like `_.xor`, without support for
                     * iteratee shorthands, that accepts an array of arrays to inspect.
                     *
                     * @private
                     * @param {Array} arrays The arrays to inspect.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of values.
                     */
                    function baseXor(arrays, iteratee, comparator) {
                        var length = arrays.length;
                        if (length < 2) {
                            return length ? baseUniq(arrays[0]) : [];
                        }
                        var index = -1,
                            result = Array(length);

                        while (++index < length) {
                            var array = arrays[index],
                                othIndex = -1;

                            while (++othIndex < length) {
                                if (othIndex != index) {
                                    result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
                                }
                            }
                        }
                        return baseUniq(baseFlatten(result, 1), iteratee, comparator);
                    }

                    /**
                     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
                     *
                     * @private
                     * @param {Array} props The property identifiers.
                     * @param {Array} values The property values.
                     * @param {Function} assignFunc The function to assign values.
                     * @returns {Object} Returns the new object.
                     */
                    function baseZipObject(props, values, assignFunc) {
                        var index = -1,
                            length = props.length,
                            valsLength = values.length,
                            result = {};

                        while (++index < length) {
                            var value = index < valsLength ? values[index] : undefined;
                            assignFunc(result, props[index], value);
                        }
                        return result;
                    }

                    /**
                     * Casts `value` to an empty array if it's not an array like object.
                     *
                     * @private
                     * @param {*} value The value to inspect.
                     * @returns {Array|Object} Returns the cast array-like object.
                     */
                    function castArrayLikeObject(value) {
                        return isArrayLikeObject(value) ? value : [];
                    }

                    /**
                     * Casts `value` to `identity` if it's not a function.
                     *
                     * @private
                     * @param {*} value The value to inspect.
                     * @returns {Function} Returns cast function.
                     */
                    function castFunction(value) {
                        return typeof value == 'function' ? value : identity;
                    }

                    /**
                     * Casts `value` to a path array if it's not one.
                     *
                     * @private
                     * @param {*} value The value to inspect.
                     * @param {Object} [object] The object to query keys on.
                     * @returns {Array} Returns the cast property path array.
                     */
                    function castPath(value, object) {
                        if (isArray(value)) {
                            return value;
                        }
                        return isKey(value, object) ? [value] : stringToPath(toString(value));
                    }

                    /**
                     * A `baseRest` alias which can be replaced with `identity` by module
                     * replacement plugins.
                     *
                     * @private
                     * @type {Function}
                     * @param {Function} func The function to apply a rest parameter to.
                     * @returns {Function} Returns the new function.
                     */
                    var castRest = baseRest;

                    /**
                     * Casts `array` to a slice if it's needed.
                     *
                     * @private
                     * @param {Array} array The array to inspect.
                     * @param {number} start The start position.
                     * @param {number} [end=array.length] The end position.
                     * @returns {Array} Returns the cast slice.
                     */
                    function castSlice(array, start, end) {
                        var length = array.length;
                        end = end === undefined ? length : end;
                        return (!start && end >= length) ? array : baseSlice(array, start, end);
                    }

                    /**
                     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
                     *
                     * @private
                     * @param {number|Object} id The timer id or timeout object of the timer to clear.
                     */
                    var clearTimeout = ctxClearTimeout || function(id) {
                        return root.clearTimeout(id);
                    };

                    /**
                     * Creates a clone of  `buffer`.
                     *
                     * @private
                     * @param {Buffer} buffer The buffer to clone.
                     * @param {boolean} [isDeep] Specify a deep clone.
                     * @returns {Buffer} Returns the cloned buffer.
                     */
                    function cloneBuffer(buffer, isDeep) {
                        if (isDeep) {
                            return buffer.slice();
                        }
                        var length = buffer.length,
                            result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

                        buffer.copy(result);
                        return result;
                    }

                    /**
                     * Creates a clone of `arrayBuffer`.
                     *
                     * @private
                     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
                     * @returns {ArrayBuffer} Returns the cloned array buffer.
                     */
                    function cloneArrayBuffer(arrayBuffer) {
                        var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
                        new Uint8Array(result).set(new Uint8Array(arrayBuffer));
                        return result;
                    }

                    /**
                     * Creates a clone of `dataView`.
                     *
                     * @private
                     * @param {Object} dataView The data view to clone.
                     * @param {boolean} [isDeep] Specify a deep clone.
                     * @returns {Object} Returns the cloned data view.
                     */
                    function cloneDataView(dataView, isDeep) {
                        var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
                        return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
                    }

                    /**
                     * Creates a clone of `regexp`.
                     *
                     * @private
                     * @param {Object} regexp The regexp to clone.
                     * @returns {Object} Returns the cloned regexp.
                     */
                    function cloneRegExp(regexp) {
                        var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
                        result.lastIndex = regexp.lastIndex;
                        return result;
                    }

                    /**
                     * Creates a clone of the `symbol` object.
                     *
                     * @private
                     * @param {Object} symbol The symbol object to clone.
                     * @returns {Object} Returns the cloned symbol object.
                     */
                    function cloneSymbol(symbol) {
                        return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
                    }

                    /**
                     * Creates a clone of `typedArray`.
                     *
                     * @private
                     * @param {Object} typedArray The typed array to clone.
                     * @param {boolean} [isDeep] Specify a deep clone.
                     * @returns {Object} Returns the cloned typed array.
                     */
                    function cloneTypedArray(typedArray, isDeep) {
                        var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
                        return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
                    }

                    /**
                     * Compares values to sort them in ascending order.
                     *
                     * @private
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {number} Returns the sort order indicator for `value`.
                     */
                    function compareAscending(value, other) {
                        if (value !== other) {
                            var valIsDefined = value !== undefined,
                                valIsNull = value === null,
                                valIsReflexive = value === value,
                                valIsSymbol = isSymbol(value);

                            var othIsDefined = other !== undefined,
                                othIsNull = other === null,
                                othIsReflexive = other === other,
                                othIsSymbol = isSymbol(other);

                            if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
                                (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
                                (valIsNull && othIsDefined && othIsReflexive) ||
                                (!valIsDefined && othIsReflexive) ||
                                !valIsReflexive) {
                                return 1;
                            }
                            if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
                                (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
                                (othIsNull && valIsDefined && valIsReflexive) ||
                                (!othIsDefined && valIsReflexive) ||
                                !othIsReflexive) {
                                return -1;
                            }
                        }
                        return 0;
                    }

                    /**
                     * Used by `_.orderBy` to compare multiple properties of a value to another
                     * and stable sort them.
                     *
                     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
                     * specify an order of "desc" for descending or "asc" for ascending sort order
                     * of corresponding values.
                     *
                     * @private
                     * @param {Object} object The object to compare.
                     * @param {Object} other The other object to compare.
                     * @param {boolean[]|string[]} orders The order to sort by for each property.
                     * @returns {number} Returns the sort order indicator for `object`.
                     */
                    function compareMultiple(object, other, orders) {
                        var index = -1,
                            objCriteria = object.criteria,
                            othCriteria = other.criteria,
                            length = objCriteria.length,
                            ordersLength = orders.length;

                        while (++index < length) {
                            var result = compareAscending(objCriteria[index], othCriteria[index]);
                            if (result) {
                                if (index >= ordersLength) {
                                    return result;
                                }
                                var order = orders[index];
                                return result * (order == 'desc' ? -1 : 1);
                            }
                        }
                        // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
                        // that causes it, under certain circumstances, to provide the same value for
                        // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
                        // for more details.
                        //
                        // This also ensures a stable sort in V8 and other engines.
                        // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
                        return object.index - other.index;
                    }

                    /**
                     * Creates an array that is the composition of partially applied arguments,
                     * placeholders, and provided arguments into a single array of arguments.
                     *
                     * @private
                     * @param {Array} args The provided arguments.
                     * @param {Array} partials The arguments to prepend to those provided.
                     * @param {Array} holders The `partials` placeholder indexes.
                     * @params {boolean} [isCurried] Specify composing for a curried function.
                     * @returns {Array} Returns the new array of composed arguments.
                     */
                    function composeArgs(args, partials, holders, isCurried) {
                        var argsIndex = -1,
                            argsLength = args.length,
                            holdersLength = holders.length,
                            leftIndex = -1,
                            leftLength = partials.length,
                            rangeLength = nativeMax(argsLength - holdersLength, 0),
                            result = Array(leftLength + rangeLength),
                            isUncurried = !isCurried;

                        while (++leftIndex < leftLength) {
                            result[leftIndex] = partials[leftIndex];
                        }
                        while (++argsIndex < holdersLength) {
                            if (isUncurried || argsIndex < argsLength) {
                                result[holders[argsIndex]] = args[argsIndex];
                            }
                        }
                        while (rangeLength--) {
                            result[leftIndex++] = args[argsIndex++];
                        }
                        return result;
                    }

                    /**
                     * This function is like `composeArgs` except that the arguments composition
                     * is tailored for `_.partialRight`.
                     *
                     * @private
                     * @param {Array} args The provided arguments.
                     * @param {Array} partials The arguments to append to those provided.
                     * @param {Array} holders The `partials` placeholder indexes.
                     * @params {boolean} [isCurried] Specify composing for a curried function.
                     * @returns {Array} Returns the new array of composed arguments.
                     */
                    function composeArgsRight(args, partials, holders, isCurried) {
                        var argsIndex = -1,
                            argsLength = args.length,
                            holdersIndex = -1,
                            holdersLength = holders.length,
                            rightIndex = -1,
                            rightLength = partials.length,
                            rangeLength = nativeMax(argsLength - holdersLength, 0),
                            result = Array(rangeLength + rightLength),
                            isUncurried = !isCurried;

                        while (++argsIndex < rangeLength) {
                            result[argsIndex] = args[argsIndex];
                        }
                        var offset = argsIndex;
                        while (++rightIndex < rightLength) {
                            result[offset + rightIndex] = partials[rightIndex];
                        }
                        while (++holdersIndex < holdersLength) {
                            if (isUncurried || argsIndex < argsLength) {
                                result[offset + holders[holdersIndex]] = args[argsIndex++];
                            }
                        }
                        return result;
                    }

                    /**
                     * Copies the values of `source` to `array`.
                     *
                     * @private
                     * @param {Array} source The array to copy values from.
                     * @param {Array} [array=[]] The array to copy values to.
                     * @returns {Array} Returns `array`.
                     */
                    function copyArray(source, array) {
                        var index = -1,
                            length = source.length;

                        array || (array = Array(length));
                        while (++index < length) {
                            array[index] = source[index];
                        }
                        return array;
                    }

                    /**
                     * Copies properties of `source` to `object`.
                     *
                     * @private
                     * @param {Object} source The object to copy properties from.
                     * @param {Array} props The property identifiers to copy.
                     * @param {Object} [object={}] The object to copy properties to.
                     * @param {Function} [customizer] The function to customize copied values.
                     * @returns {Object} Returns `object`.
                     */
                    function copyObject(source, props, object, customizer) {
                        var isNew = !object;
                        object || (object = {});

                        var index = -1,
                            length = props.length;

                        while (++index < length) {
                            var key = props[index];

                            var newValue = customizer
                                ? customizer(object[key], source[key], key, object, source)
                                : undefined;

                            if (newValue === undefined) {
                                newValue = source[key];
                            }
                            if (isNew) {
                                baseAssignValue(object, key, newValue);
                            } else {
                                assignValue(object, key, newValue);
                            }
                        }
                        return object;
                    }

                    /**
                     * Copies own symbols of `source` to `object`.
                     *
                     * @private
                     * @param {Object} source The object to copy symbols from.
                     * @param {Object} [object={}] The object to copy symbols to.
                     * @returns {Object} Returns `object`.
                     */
                    function copySymbols(source, object) {
                        return copyObject(source, getSymbols(source), object);
                    }

                    /**
                     * Copies own and inherited symbols of `source` to `object`.
                     *
                     * @private
                     * @param {Object} source The object to copy symbols from.
                     * @param {Object} [object={}] The object to copy symbols to.
                     * @returns {Object} Returns `object`.
                     */
                    function copySymbolsIn(source, object) {
                        return copyObject(source, getSymbolsIn(source), object);
                    }

                    /**
                     * Creates a function like `_.groupBy`.
                     *
                     * @private
                     * @param {Function} setter The function to set accumulator values.
                     * @param {Function} [initializer] The accumulator object initializer.
                     * @returns {Function} Returns the new aggregator function.
                     */
                    function createAggregator(setter, initializer) {
                        return function(collection, iteratee) {
                            var func = isArray(collection) ? arrayAggregator : baseAggregator,
                                accumulator = initializer ? initializer() : {};

                            return func(collection, setter, getIteratee(iteratee, 2), accumulator);
                        };
                    }

                    /**
                     * Creates a function like `_.assign`.
                     *
                     * @private
                     * @param {Function} assigner The function to assign values.
                     * @returns {Function} Returns the new assigner function.
                     */
                    function createAssigner(assigner) {
                        return baseRest(function(object, sources) {
                            var index = -1,
                                length = sources.length,
                                customizer = length > 1 ? sources[length - 1] : undefined,
                                guard = length > 2 ? sources[2] : undefined;

                            customizer = (assigner.length > 3 && typeof customizer == 'function')
                                ? (length--, customizer)
                                : undefined;

                            if (guard && isIterateeCall(sources[0], sources[1], guard)) {
                                customizer = length < 3 ? undefined : customizer;
                                length = 1;
                            }
                            object = Object(object);
                            while (++index < length) {
                                var source = sources[index];
                                if (source) {
                                    assigner(object, source, index, customizer);
                                }
                            }
                            return object;
                        });
                    }

                    /**
                     * Creates a `baseEach` or `baseEachRight` function.
                     *
                     * @private
                     * @param {Function} eachFunc The function to iterate over a collection.
                     * @param {boolean} [fromRight] Specify iterating from right to left.
                     * @returns {Function} Returns the new base function.
                     */
                    function createBaseEach(eachFunc, fromRight) {
                        return function(collection, iteratee) {
                            if (collection == null) {
                                return collection;
                            }
                            if (!isArrayLike(collection)) {
                                return eachFunc(collection, iteratee);
                            }
                            var length = collection.length,
                                index = fromRight ? length : -1,
                                iterable = Object(collection);

                            while ((fromRight ? index-- : ++index < length)) {
                                if (iteratee(iterable[index], index, iterable) === false) {
                                    break;
                                }
                            }
                            return collection;
                        };
                    }

                    /**
                     * Creates a base function for methods like `_.forIn` and `_.forOwn`.
                     *
                     * @private
                     * @param {boolean} [fromRight] Specify iterating from right to left.
                     * @returns {Function} Returns the new base function.
                     */
                    function createBaseFor(fromRight) {
                        return function(object, iteratee, keysFunc) {
                            var index = -1,
                                iterable = Object(object),
                                props = keysFunc(object),
                                length = props.length;

                            while (length--) {
                                var key = props[fromRight ? length : ++index];
                                if (iteratee(iterable[key], key, iterable) === false) {
                                    break;
                                }
                            }
                            return object;
                        };
                    }

                    /**
                     * Creates a function that wraps `func` to invoke it with the optional `this`
                     * binding of `thisArg`.
                     *
                     * @private
                     * @param {Function} func The function to wrap.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @param {*} [thisArg] The `this` binding of `func`.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createBind(func, bitmask, thisArg) {
                        var isBind = bitmask & WRAP_BIND_FLAG,
                            Ctor = createCtor(func);

                        function wrapper() {
                            var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
                            return fn.apply(isBind ? thisArg : this, arguments);
                        }
                        return wrapper;
                    }

                    /**
                     * Creates a function like `_.lowerFirst`.
                     *
                     * @private
                     * @param {string} methodName The name of the `String` case method to use.
                     * @returns {Function} Returns the new case function.
                     */
                    function createCaseFirst(methodName) {
                        return function(string) {
                            string = toString(string);

                            var strSymbols = hasUnicode(string)
                                ? stringToArray(string)
                                : undefined;

                            var chr = strSymbols
                                ? strSymbols[0]
                                : string.charAt(0);

                            var trailing = strSymbols
                                ? castSlice(strSymbols, 1).join('')
                                : string.slice(1);

                            return chr[methodName]() + trailing;
                        };
                    }

                    /**
                     * Creates a function like `_.camelCase`.
                     *
                     * @private
                     * @param {Function} callback The function to combine each word.
                     * @returns {Function} Returns the new compounder function.
                     */
                    function createCompounder(callback) {
                        return function(string) {
                            return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
                        };
                    }

                    /**
                     * Creates a function that produces an instance of `Ctor` regardless of
                     * whether it was invoked as part of a `new` expression or by `call` or `apply`.
                     *
                     * @private
                     * @param {Function} Ctor The constructor to wrap.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createCtor(Ctor) {
                        return function() {
                            // Use a `switch` statement to work with class constructors. See
                            // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
                            // for more details.
                            var args = arguments;
                            switch (args.length) {
                                case 0: return new Ctor;
                                case 1: return new Ctor(args[0]);
                                case 2: return new Ctor(args[0], args[1]);
                                case 3: return new Ctor(args[0], args[1], args[2]);
                                case 4: return new Ctor(args[0], args[1], args[2], args[3]);
                                case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
                                case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
                                case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
                            }
                            var thisBinding = baseCreate(Ctor.prototype),
                                result = Ctor.apply(thisBinding, args);

                            // Mimic the constructor's `return` behavior.
                            // See https://es5.github.io/#x13.2.2 for more details.
                            return isObject(result) ? result : thisBinding;
                        };
                    }

                    /**
                     * Creates a function that wraps `func` to enable currying.
                     *
                     * @private
                     * @param {Function} func The function to wrap.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @param {number} arity The arity of `func`.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createCurry(func, bitmask, arity) {
                        var Ctor = createCtor(func);

                        function wrapper() {
                            var length = arguments.length,
                                args = Array(length),
                                index = length,
                                placeholder = getHolder(wrapper);

                            while (index--) {
                                args[index] = arguments[index];
                            }
                            var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
                                ? []
                                : replaceHolders(args, placeholder);

                            length -= holders.length;
                            if (length < arity) {
                                return createRecurry(
                                    func, bitmask, createHybrid, wrapper.placeholder, undefined,
                                    args, holders, undefined, undefined, arity - length);
                            }
                            var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
                            return apply(fn, this, args);
                        }
                        return wrapper;
                    }

                    /**
                     * Creates a `_.find` or `_.findLast` function.
                     *
                     * @private
                     * @param {Function} findIndexFunc The function to find the collection index.
                     * @returns {Function} Returns the new find function.
                     */
                    function createFind(findIndexFunc) {
                        return function(collection, predicate, fromIndex) {
                            var iterable = Object(collection);
                            if (!isArrayLike(collection)) {
                                var iteratee = getIteratee(predicate, 3);
                                collection = keys(collection);
                                predicate = function(key) { return iteratee(iterable[key], key, iterable); };
                            }
                            var index = findIndexFunc(collection, predicate, fromIndex);
                            return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
                        };
                    }

                    /**
                     * Creates a `_.flow` or `_.flowRight` function.
                     *
                     * @private
                     * @param {boolean} [fromRight] Specify iterating from right to left.
                     * @returns {Function} Returns the new flow function.
                     */
                    function createFlow(fromRight) {
                        return flatRest(function(funcs) {
                            var length = funcs.length,
                                index = length,
                                prereq = LodashWrapper.prototype.thru;

                            if (fromRight) {
                                funcs.reverse();
                            }
                            while (index--) {
                                var func = funcs[index];
                                if (typeof func != 'function') {
                                    throw new TypeError(FUNC_ERROR_TEXT);
                                }
                                if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
                                    var wrapper = new LodashWrapper([], true);
                                }
                            }
                            index = wrapper ? index : length;
                            while (++index < length) {
                                func = funcs[index];

                                var funcName = getFuncName(func),
                                    data = funcName == 'wrapper' ? getData(func) : undefined;

                                if (data && isLaziable(data[0]) &&
                                    data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
                                    !data[4].length && data[9] == 1
                                ) {
                                    wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
                                } else {
                                    wrapper = (func.length == 1 && isLaziable(func))
                                        ? wrapper[funcName]()
                                        : wrapper.thru(func);
                                }
                            }
                            return function() {
                                var args = arguments,
                                    value = args[0];

                                if (wrapper && args.length == 1 && isArray(value)) {
                                    return wrapper.plant(value).value();
                                }
                                var index = 0,
                                    result = length ? funcs[index].apply(this, args) : value;

                                while (++index < length) {
                                    result = funcs[index].call(this, result);
                                }
                                return result;
                            };
                        });
                    }

                    /**
                     * Creates a function that wraps `func` to invoke it with optional `this`
                     * binding of `thisArg`, partial application, and currying.
                     *
                     * @private
                     * @param {Function|string} func The function or method name to wrap.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @param {*} [thisArg] The `this` binding of `func`.
                     * @param {Array} [partials] The arguments to prepend to those provided to
                     *  the new function.
                     * @param {Array} [holders] The `partials` placeholder indexes.
                     * @param {Array} [partialsRight] The arguments to append to those provided
                     *  to the new function.
                     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
                     * @param {Array} [argPos] The argument positions of the new function.
                     * @param {number} [ary] The arity cap of `func`.
                     * @param {number} [arity] The arity of `func`.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
                        var isAry = bitmask & WRAP_ARY_FLAG,
                            isBind = bitmask & WRAP_BIND_FLAG,
                            isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
                            isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
                            isFlip = bitmask & WRAP_FLIP_FLAG,
                            Ctor = isBindKey ? undefined : createCtor(func);

                        function wrapper() {
                            var length = arguments.length,
                                args = Array(length),
                                index = length;

                            while (index--) {
                                args[index] = arguments[index];
                            }
                            if (isCurried) {
                                var placeholder = getHolder(wrapper),
                                    holdersCount = countHolders(args, placeholder);
                            }
                            if (partials) {
                                args = composeArgs(args, partials, holders, isCurried);
                            }
                            if (partialsRight) {
                                args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
                            }
                            length -= holdersCount;
                            if (isCurried && length < arity) {
                                var newHolders = replaceHolders(args, placeholder);
                                return createRecurry(
                                    func, bitmask, createHybrid, wrapper.placeholder, thisArg,
                                    args, newHolders, argPos, ary, arity - length
                                );
                            }
                            var thisBinding = isBind ? thisArg : this,
                                fn = isBindKey ? thisBinding[func] : func;

                            length = args.length;
                            if (argPos) {
                                args = reorder(args, argPos);
                            } else if (isFlip && length > 1) {
                                args.reverse();
                            }
                            if (isAry && ary < length) {
                                args.length = ary;
                            }
                            if (this && this !== root && this instanceof wrapper) {
                                fn = Ctor || createCtor(fn);
                            }
                            return fn.apply(thisBinding, args);
                        }
                        return wrapper;
                    }

                    /**
                     * Creates a function like `_.invertBy`.
                     *
                     * @private
                     * @param {Function} setter The function to set accumulator values.
                     * @param {Function} toIteratee The function to resolve iteratees.
                     * @returns {Function} Returns the new inverter function.
                     */
                    function createInverter(setter, toIteratee) {
                        return function(object, iteratee) {
                            return baseInverter(object, setter, toIteratee(iteratee), {});
                        };
                    }

                    /**
                     * Creates a function that performs a mathematical operation on two values.
                     *
                     * @private
                     * @param {Function} operator The function to perform the operation.
                     * @param {number} [defaultValue] The value used for `undefined` arguments.
                     * @returns {Function} Returns the new mathematical operation function.
                     */
                    function createMathOperation(operator, defaultValue) {
                        return function(value, other) {
                            var result;
                            if (value === undefined && other === undefined) {
                                return defaultValue;
                            }
                            if (value !== undefined) {
                                result = value;
                            }
                            if (other !== undefined) {
                                if (result === undefined) {
                                    return other;
                                }
                                if (typeof value == 'string' || typeof other == 'string') {
                                    value = baseToString(value);
                                    other = baseToString(other);
                                } else {
                                    value = baseToNumber(value);
                                    other = baseToNumber(other);
                                }
                                result = operator(value, other);
                            }
                            return result;
                        };
                    }

                    /**
                     * Creates a function like `_.over`.
                     *
                     * @private
                     * @param {Function} arrayFunc The function to iterate over iteratees.
                     * @returns {Function} Returns the new over function.
                     */
                    function createOver(arrayFunc) {
                        return flatRest(function(iteratees) {
                            iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
                            return baseRest(function(args) {
                                var thisArg = this;
                                return arrayFunc(iteratees, function(iteratee) {
                                    return apply(iteratee, thisArg, args);
                                });
                            });
                        });
                    }

                    /**
                     * Creates the padding for `string` based on `length`. The `chars` string
                     * is truncated if the number of characters exceeds `length`.
                     *
                     * @private
                     * @param {number} length The padding length.
                     * @param {string} [chars=' '] The string used as padding.
                     * @returns {string} Returns the padding for `string`.
                     */
                    function createPadding(length, chars) {
                        chars = chars === undefined ? ' ' : baseToString(chars);

                        var charsLength = chars.length;
                        if (charsLength < 2) {
                            return charsLength ? baseRepeat(chars, length) : chars;
                        }
                        var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
                        return hasUnicode(chars)
                            ? castSlice(stringToArray(result), 0, length).join('')
                            : result.slice(0, length);
                    }

                    /**
                     * Creates a function that wraps `func` to invoke it with the `this` binding
                     * of `thisArg` and `partials` prepended to the arguments it receives.
                     *
                     * @private
                     * @param {Function} func The function to wrap.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @param {*} thisArg The `this` binding of `func`.
                     * @param {Array} partials The arguments to prepend to those provided to
                     *  the new function.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createPartial(func, bitmask, thisArg, partials) {
                        var isBind = bitmask & WRAP_BIND_FLAG,
                            Ctor = createCtor(func);

                        function wrapper() {
                            var argsIndex = -1,
                                argsLength = arguments.length,
                                leftIndex = -1,
                                leftLength = partials.length,
                                args = Array(leftLength + argsLength),
                                fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;

                            while (++leftIndex < leftLength) {
                                args[leftIndex] = partials[leftIndex];
                            }
                            while (argsLength--) {
                                args[leftIndex++] = arguments[++argsIndex];
                            }
                            return apply(fn, isBind ? thisArg : this, args);
                        }
                        return wrapper;
                    }

                    /**
                     * Creates a `_.range` or `_.rangeRight` function.
                     *
                     * @private
                     * @param {boolean} [fromRight] Specify iterating from right to left.
                     * @returns {Function} Returns the new range function.
                     */
                    function createRange(fromRight) {
                        return function(start, end, step) {
                            if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
                                end = step = undefined;
                            }
                            // Ensure the sign of `-0` is preserved.
                            start = toFinite(start);
                            if (end === undefined) {
                                end = start;
                                start = 0;
                            } else {
                                end = toFinite(end);
                            }
                            step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
                            return baseRange(start, end, step, fromRight);
                        };
                    }

                    /**
                     * Creates a function that performs a relational operation on two values.
                     *
                     * @private
                     * @param {Function} operator The function to perform the operation.
                     * @returns {Function} Returns the new relational operation function.
                     */
                    function createRelationalOperation(operator) {
                        return function(value, other) {
                            if (!(typeof value == 'string' && typeof other == 'string')) {
                                value = toNumber(value);
                                other = toNumber(other);
                            }
                            return operator(value, other);
                        };
                    }

                    /**
                     * Creates a function that wraps `func` to continue currying.
                     *
                     * @private
                     * @param {Function} func The function to wrap.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @param {Function} wrapFunc The function to create the `func` wrapper.
                     * @param {*} placeholder The placeholder value.
                     * @param {*} [thisArg] The `this` binding of `func`.
                     * @param {Array} [partials] The arguments to prepend to those provided to
                     *  the new function.
                     * @param {Array} [holders] The `partials` placeholder indexes.
                     * @param {Array} [argPos] The argument positions of the new function.
                     * @param {number} [ary] The arity cap of `func`.
                     * @param {number} [arity] The arity of `func`.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
                        var isCurry = bitmask & WRAP_CURRY_FLAG,
                            newHolders = isCurry ? holders : undefined,
                            newHoldersRight = isCurry ? undefined : holders,
                            newPartials = isCurry ? partials : undefined,
                            newPartialsRight = isCurry ? undefined : partials;

                        bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
                        bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);

                        if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
                            bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
                        }
                        var newData = [
                            func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
                            newHoldersRight, argPos, ary, arity
                        ];

                        var result = wrapFunc.apply(undefined, newData);
                        if (isLaziable(func)) {
                            setData(result, newData);
                        }
                        result.placeholder = placeholder;
                        return setWrapToString(result, func, bitmask);
                    }

                    /**
                     * Creates a function like `_.round`.
                     *
                     * @private
                     * @param {string} methodName The name of the `Math` method to use when rounding.
                     * @returns {Function} Returns the new round function.
                     */
                    function createRound(methodName) {
                        var func = Math[methodName];
                        return function(number, precision) {
                            number = toNumber(number);
                            precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
                            if (precision && nativeIsFinite(number)) {
                                // Shift with exponential notation to avoid floating-point issues.
                                // See [MDN](https://mdn.io/round#Examples) for more details.
                                var pair = (toString(number) + 'e').split('e'),
                                    value = func(pair[0] + 'e' + (+pair[1] + precision));

                                pair = (toString(value) + 'e').split('e');
                                return +(pair[0] + 'e' + (+pair[1] - precision));
                            }
                            return func(number);
                        };
                    }

                    /**
                     * Creates a set object of `values`.
                     *
                     * @private
                     * @param {Array} values The values to add to the set.
                     * @returns {Object} Returns the new set.
                     */
                    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
                        return new Set(values);
                    };

                    /**
                     * Creates a `_.toPairs` or `_.toPairsIn` function.
                     *
                     * @private
                     * @param {Function} keysFunc The function to get the keys of a given object.
                     * @returns {Function} Returns the new pairs function.
                     */
                    function createToPairs(keysFunc) {
                        return function(object) {
                            var tag = getTag(object);
                            if (tag == mapTag) {
                                return mapToArray(object);
                            }
                            if (tag == setTag) {
                                return setToPairs(object);
                            }
                            return baseToPairs(object, keysFunc(object));
                        };
                    }

                    /**
                     * Creates a function that either curries or invokes `func` with optional
                     * `this` binding and partially applied arguments.
                     *
                     * @private
                     * @param {Function|string} func The function or method name to wrap.
                     * @param {number} bitmask The bitmask flags.
                     *    1 - `_.bind`
                     *    2 - `_.bindKey`
                     *    4 - `_.curry` or `_.curryRight` of a bound function
                     *    8 - `_.curry`
                     *   16 - `_.curryRight`
                     *   32 - `_.partial`
                     *   64 - `_.partialRight`
                     *  128 - `_.rearg`
                     *  256 - `_.ary`
                     *  512 - `_.flip`
                     * @param {*} [thisArg] The `this` binding of `func`.
                     * @param {Array} [partials] The arguments to be partially applied.
                     * @param {Array} [holders] The `partials` placeholder indexes.
                     * @param {Array} [argPos] The argument positions of the new function.
                     * @param {number} [ary] The arity cap of `func`.
                     * @param {number} [arity] The arity of `func`.
                     * @returns {Function} Returns the new wrapped function.
                     */
                    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
                        var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
                        if (!isBindKey && typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        var length = partials ? partials.length : 0;
                        if (!length) {
                            bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
                            partials = holders = undefined;
                        }
                        ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
                        arity = arity === undefined ? arity : toInteger(arity);
                        length -= holders ? holders.length : 0;

                        if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
                            var partialsRight = partials,
                                holdersRight = holders;

                            partials = holders = undefined;
                        }
                        var data = isBindKey ? undefined : getData(func);

                        var newData = [
                            func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
                            argPos, ary, arity
                        ];

                        if (data) {
                            mergeData(newData, data);
                        }
                        func = newData[0];
                        bitmask = newData[1];
                        thisArg = newData[2];
                        partials = newData[3];
                        holders = newData[4];
                        arity = newData[9] = newData[9] === undefined
                            ? (isBindKey ? 0 : func.length)
                            : nativeMax(newData[9] - length, 0);

                        if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
                            bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
                        }
                        if (!bitmask || bitmask == WRAP_BIND_FLAG) {
                            var result = createBind(func, bitmask, thisArg);
                        } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
                            result = createCurry(func, bitmask, arity);
                        } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
                            result = createPartial(func, bitmask, thisArg, partials);
                        } else {
                            result = createHybrid.apply(undefined, newData);
                        }
                        var setter = data ? baseSetData : setData;
                        return setWrapToString(setter(result, newData), func, bitmask);
                    }

                    /**
                     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
                     * of source objects to the destination object for all destination properties
                     * that resolve to `undefined`.
                     *
                     * @private
                     * @param {*} objValue The destination value.
                     * @param {*} srcValue The source value.
                     * @param {string} key The key of the property to assign.
                     * @param {Object} object The parent object of `objValue`.
                     * @returns {*} Returns the value to assign.
                     */
                    function customDefaultsAssignIn(objValue, srcValue, key, object) {
                        if (objValue === undefined ||
                            (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
                            return srcValue;
                        }
                        return objValue;
                    }

                    /**
                     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
                     * objects into destination objects that are passed thru.
                     *
                     * @private
                     * @param {*} objValue The destination value.
                     * @param {*} srcValue The source value.
                     * @param {string} key The key of the property to merge.
                     * @param {Object} object The parent object of `objValue`.
                     * @param {Object} source The parent object of `srcValue`.
                     * @param {Object} [stack] Tracks traversed source values and their merged
                     *  counterparts.
                     * @returns {*} Returns the value to assign.
                     */
                    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
                        if (isObject(objValue) && isObject(srcValue)) {
                            // Recursively merge objects and arrays (susceptible to call stack limits).
                            stack.set(srcValue, objValue);
                            baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
                            stack['delete'](srcValue);
                        }
                        return objValue;
                    }

                    /**
                     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
                     * objects.
                     *
                     * @private
                     * @param {*} value The value to inspect.
                     * @param {string} key The key of the property to inspect.
                     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
                     */
                    function customOmitClone(value) {
                        return isPlainObject(value) ? undefined : value;
                    }

                    /**
                     * A specialized version of `baseIsEqualDeep` for arrays with support for
                     * partial deep comparisons.
                     *
                     * @private
                     * @param {Array} array The array to compare.
                     * @param {Array} other The other array to compare.
                     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
                     * @param {Function} customizer The function to customize comparisons.
                     * @param {Function} equalFunc The function to determine equivalents of values.
                     * @param {Object} stack Tracks traversed `array` and `other` objects.
                     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
                     */
                    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
                        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
                            arrLength = array.length,
                            othLength = other.length;

                        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
                            return false;
                        }
                        // Check that cyclic values are equal.
                        var arrStacked = stack.get(array);
                        var othStacked = stack.get(other);
                        if (arrStacked && othStacked) {
                            return arrStacked == other && othStacked == array;
                        }
                        var index = -1,
                            result = true,
                            seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;

                        stack.set(array, other);
                        stack.set(other, array);

                        // Ignore non-index properties.
                        while (++index < arrLength) {
                            var arrValue = array[index],
                                othValue = other[index];

                            if (customizer) {
                                var compared = isPartial
                                    ? customizer(othValue, arrValue, index, other, array, stack)
                                    : customizer(arrValue, othValue, index, array, other, stack);
                            }
                            if (compared !== undefined) {
                                if (compared) {
                                    continue;
                                }
                                result = false;
                                break;
                            }
                            // Recursively compare arrays (susceptible to call stack limits).
                            if (seen) {
                                if (!arraySome(other, function(othValue, othIndex) {
                                    if (!cacheHas(seen, othIndex) &&
                                        (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
                                        return seen.push(othIndex);
                                    }
                                })) {
                                    result = false;
                                    break;
                                }
                            } else if (!(
                                arrValue === othValue ||
                                equalFunc(arrValue, othValue, bitmask, customizer, stack)
                            )) {
                                result = false;
                                break;
                            }
                        }
                        stack['delete'](array);
                        stack['delete'](other);
                        return result;
                    }

                    /**
                     * A specialized version of `baseIsEqualDeep` for comparing objects of
                     * the same `toStringTag`.
                     *
                     * **Note:** This function only supports comparing values with tags of
                     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
                     *
                     * @private
                     * @param {Object} object The object to compare.
                     * @param {Object} other The other object to compare.
                     * @param {string} tag The `toStringTag` of the objects to compare.
                     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
                     * @param {Function} customizer The function to customize comparisons.
                     * @param {Function} equalFunc The function to determine equivalents of values.
                     * @param {Object} stack Tracks traversed `object` and `other` objects.
                     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
                     */
                    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
                        switch (tag) {
                            case dataViewTag:
                                if ((object.byteLength != other.byteLength) ||
                                    (object.byteOffset != other.byteOffset)) {
                                    return false;
                                }
                                object = object.buffer;
                                other = other.buffer;

                            case arrayBufferTag:
                                if ((object.byteLength != other.byteLength) ||
                                    !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
                                    return false;
                                }
                                return true;

                            case boolTag:
                            case dateTag:
                            case numberTag:
                                // Coerce booleans to `1` or `0` and dates to milliseconds.
                                // Invalid dates are coerced to `NaN`.
                                return eq(+object, +other);

                            case errorTag:
                                return object.name == other.name && object.message == other.message;

                            case regexpTag:
                            case stringTag:
                                // Coerce regexes to strings and treat strings, primitives and objects,
                                // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
                                // for more details.
                                return object == (other + '');

                            case mapTag:
                                var convert = mapToArray;

                            case setTag:
                                var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
                                convert || (convert = setToArray);

                                if (object.size != other.size && !isPartial) {
                                    return false;
                                }
                                // Assume cyclic values are equal.
                                var stacked = stack.get(object);
                                if (stacked) {
                                    return stacked == other;
                                }
                                bitmask |= COMPARE_UNORDERED_FLAG;

                                // Recursively compare objects (susceptible to call stack limits).
                                stack.set(object, other);
                                var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
                                stack['delete'](object);
                                return result;

                            case symbolTag:
                                if (symbolValueOf) {
                                    return symbolValueOf.call(object) == symbolValueOf.call(other);
                                }
                        }
                        return false;
                    }

                    /**
                     * A specialized version of `baseIsEqualDeep` for objects with support for
                     * partial deep comparisons.
                     *
                     * @private
                     * @param {Object} object The object to compare.
                     * @param {Object} other The other object to compare.
                     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
                     * @param {Function} customizer The function to customize comparisons.
                     * @param {Function} equalFunc The function to determine equivalents of values.
                     * @param {Object} stack Tracks traversed `object` and `other` objects.
                     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
                     */
                    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
                        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
                            objProps = getAllKeys(object),
                            objLength = objProps.length,
                            othProps = getAllKeys(other),
                            othLength = othProps.length;

                        if (objLength != othLength && !isPartial) {
                            return false;
                        }
                        var index = objLength;
                        while (index--) {
                            var key = objProps[index];
                            if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
                                return false;
                            }
                        }
                        // Check that cyclic values are equal.
                        var objStacked = stack.get(object);
                        var othStacked = stack.get(other);
                        if (objStacked && othStacked) {
                            return objStacked == other && othStacked == object;
                        }
                        var result = true;
                        stack.set(object, other);
                        stack.set(other, object);

                        var skipCtor = isPartial;
                        while (++index < objLength) {
                            key = objProps[index];
                            var objValue = object[key],
                                othValue = other[key];

                            if (customizer) {
                                var compared = isPartial
                                    ? customizer(othValue, objValue, key, other, object, stack)
                                    : customizer(objValue, othValue, key, object, other, stack);
                            }
                            // Recursively compare objects (susceptible to call stack limits).
                            if (!(compared === undefined
                                    ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
                                    : compared
                            )) {
                                result = false;
                                break;
                            }
                            skipCtor || (skipCtor = key == 'constructor');
                        }
                        if (result && !skipCtor) {
                            var objCtor = object.constructor,
                                othCtor = other.constructor;

                            // Non `Object` object instances with different constructors are not equal.
                            if (objCtor != othCtor &&
                                ('constructor' in object && 'constructor' in other) &&
                                !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
                                    typeof othCtor == 'function' && othCtor instanceof othCtor)) {
                                result = false;
                            }
                        }
                        stack['delete'](object);
                        stack['delete'](other);
                        return result;
                    }

                    /**
                     * A specialized version of `baseRest` which flattens the rest array.
                     *
                     * @private
                     * @param {Function} func The function to apply a rest parameter to.
                     * @returns {Function} Returns the new function.
                     */
                    function flatRest(func) {
                        return setToString(overRest(func, undefined, flatten), func + '');
                    }

                    /**
                     * Creates an array of own enumerable property names and symbols of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names and symbols.
                     */
                    function getAllKeys(object) {
                        return baseGetAllKeys(object, keys, getSymbols);
                    }

                    /**
                     * Creates an array of own and inherited enumerable property names and
                     * symbols of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names and symbols.
                     */
                    function getAllKeysIn(object) {
                        return baseGetAllKeys(object, keysIn, getSymbolsIn);
                    }

                    /**
                     * Gets metadata for `func`.
                     *
                     * @private
                     * @param {Function} func The function to query.
                     * @returns {*} Returns the metadata for `func`.
                     */
                    var getData = !metaMap ? noop : function(func) {
                        return metaMap.get(func);
                    };

                    /**
                     * Gets the name of `func`.
                     *
                     * @private
                     * @param {Function} func The function to query.
                     * @returns {string} Returns the function name.
                     */
                    function getFuncName(func) {
                        var result = (func.name + ''),
                            array = realNames[result],
                            length = hasOwnProperty.call(realNames, result) ? array.length : 0;

                        while (length--) {
                            var data = array[length],
                                otherFunc = data.func;
                            if (otherFunc == null || otherFunc == func) {
                                return data.name;
                            }
                        }
                        return result;
                    }

                    /**
                     * Gets the argument placeholder value for `func`.
                     *
                     * @private
                     * @param {Function} func The function to inspect.
                     * @returns {*} Returns the placeholder value.
                     */
                    function getHolder(func) {
                        var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
                        return object.placeholder;
                    }

                    /**
                     * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
                     * this function returns the custom method, otherwise it returns `baseIteratee`.
                     * If arguments are provided, the chosen function is invoked with them and
                     * its result is returned.
                     *
                     * @private
                     * @param {*} [value] The value to convert to an iteratee.
                     * @param {number} [arity] The arity of the created iteratee.
                     * @returns {Function} Returns the chosen function or its result.
                     */
                    function getIteratee() {
                        var result = lodash.iteratee || iteratee;
                        result = result === iteratee ? baseIteratee : result;
                        return arguments.length ? result(arguments[0], arguments[1]) : result;
                    }

                    /**
                     * Gets the data for `map`.
                     *
                     * @private
                     * @param {Object} map The map to query.
                     * @param {string} key The reference key.
                     * @returns {*} Returns the map data.
                     */
                    function getMapData(map, key) {
                        var data = map.__data__;
                        return isKeyable(key)
                            ? data[typeof key == 'string' ? 'string' : 'hash']
                            : data.map;
                    }

                    /**
                     * Gets the property names, values, and compare flags of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the match data of `object`.
                     */
                    function getMatchData(object) {
                        var result = keys(object),
                            length = result.length;

                        while (length--) {
                            var key = result[length],
                                value = object[key];

                            result[length] = [key, value, isStrictComparable(value)];
                        }
                        return result;
                    }

                    /**
                     * Gets the native function at `key` of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {string} key The key of the method to get.
                     * @returns {*} Returns the function if it's native, else `undefined`.
                     */
                    function getNative(object, key) {
                        var value = getValue(object, key);
                        return baseIsNative(value) ? value : undefined;
                    }

                    /**
                     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
                     *
                     * @private
                     * @param {*} value The value to query.
                     * @returns {string} Returns the raw `toStringTag`.
                     */
                    function getRawTag(value) {
                        var isOwn = hasOwnProperty.call(value, symToStringTag),
                            tag = value[symToStringTag];

                        try {
                            value[symToStringTag] = undefined;
                            var unmasked = true;
                        } catch (e) {}

                        var result = nativeObjectToString.call(value);
                        if (unmasked) {
                            if (isOwn) {
                                value[symToStringTag] = tag;
                            } else {
                                delete value[symToStringTag];
                            }
                        }
                        return result;
                    }

                    /**
                     * Creates an array of the own enumerable symbols of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of symbols.
                     */
                    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
                        if (object == null) {
                            return [];
                        }
                        object = Object(object);
                        return arrayFilter(nativeGetSymbols(object), function(symbol) {
                            return propertyIsEnumerable.call(object, symbol);
                        });
                    };

                    /**
                     * Creates an array of the own and inherited enumerable symbols of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of symbols.
                     */
                    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
                        var result = [];
                        while (object) {
                            arrayPush(result, getSymbols(object));
                            object = getPrototype(object);
                        }
                        return result;
                    };

                    /**
                     * Gets the `toStringTag` of `value`.
                     *
                     * @private
                     * @param {*} value The value to query.
                     * @returns {string} Returns the `toStringTag`.
                     */
                    var getTag = baseGetTag;

                    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
                    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
                        (Map && getTag(new Map) != mapTag) ||
                        (Promise && getTag(Promise.resolve()) != promiseTag) ||
                        (Set && getTag(new Set) != setTag) ||
                        (WeakMap && getTag(new WeakMap) != weakMapTag)) {
                        getTag = function(value) {
                            var result = baseGetTag(value),
                                Ctor = result == objectTag ? value.constructor : undefined,
                                ctorString = Ctor ? toSource(Ctor) : '';

                            if (ctorString) {
                                switch (ctorString) {
                                    case dataViewCtorString: return dataViewTag;
                                    case mapCtorString: return mapTag;
                                    case promiseCtorString: return promiseTag;
                                    case setCtorString: return setTag;
                                    case weakMapCtorString: return weakMapTag;
                                }
                            }
                            return result;
                        };
                    }

                    /**
                     * Gets the view, applying any `transforms` to the `start` and `end` positions.
                     *
                     * @private
                     * @param {number} start The start of the view.
                     * @param {number} end The end of the view.
                     * @param {Array} transforms The transformations to apply to the view.
                     * @returns {Object} Returns an object containing the `start` and `end`
                     *  positions of the view.
                     */
                    function getView(start, end, transforms) {
                        var index = -1,
                            length = transforms.length;

                        while (++index < length) {
                            var data = transforms[index],
                                size = data.size;

                            switch (data.type) {
                                case 'drop':      start += size; break;
                                case 'dropRight': end -= size; break;
                                case 'take':      end = nativeMin(end, start + size); break;
                                case 'takeRight': start = nativeMax(start, end - size); break;
                            }
                        }
                        return { 'start': start, 'end': end };
                    }

                    /**
                     * Extracts wrapper details from the `source` body comment.
                     *
                     * @private
                     * @param {string} source The source to inspect.
                     * @returns {Array} Returns the wrapper details.
                     */
                    function getWrapDetails(source) {
                        var match = source.match(reWrapDetails);
                        return match ? match[1].split(reSplitDetails) : [];
                    }

                    /**
                     * Checks if `path` exists on `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path to check.
                     * @param {Function} hasFunc The function to check properties.
                     * @returns {boolean} Returns `true` if `path` exists, else `false`.
                     */
                    function hasPath(object, path, hasFunc) {
                        path = castPath(path, object);

                        var index = -1,
                            length = path.length,
                            result = false;

                        while (++index < length) {
                            var key = toKey(path[index]);
                            if (!(result = object != null && hasFunc(object, key))) {
                                break;
                            }
                            object = object[key];
                        }
                        if (result || ++index != length) {
                            return result;
                        }
                        length = object == null ? 0 : object.length;
                        return !!length && isLength(length) && isIndex(key, length) &&
                            (isArray(object) || isArguments(object));
                    }

                    /**
                     * Initializes an array clone.
                     *
                     * @private
                     * @param {Array} array The array to clone.
                     * @returns {Array} Returns the initialized clone.
                     */
                    function initCloneArray(array) {
                        var length = array.length,
                            result = new array.constructor(length);

                        // Add properties assigned by `RegExp#exec`.
                        if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
                            result.index = array.index;
                            result.input = array.input;
                        }
                        return result;
                    }

                    /**
                     * Initializes an object clone.
                     *
                     * @private
                     * @param {Object} object The object to clone.
                     * @returns {Object} Returns the initialized clone.
                     */
                    function initCloneObject(object) {
                        return (typeof object.constructor == 'function' && !isPrototype(object))
                            ? baseCreate(getPrototype(object))
                            : {};
                    }

                    /**
                     * Initializes an object clone based on its `toStringTag`.
                     *
                     * **Note:** This function only supports cloning values with tags of
                     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
                     *
                     * @private
                     * @param {Object} object The object to clone.
                     * @param {string} tag The `toStringTag` of the object to clone.
                     * @param {boolean} [isDeep] Specify a deep clone.
                     * @returns {Object} Returns the initialized clone.
                     */
                    function initCloneByTag(object, tag, isDeep) {
                        var Ctor = object.constructor;
                        switch (tag) {
                            case arrayBufferTag:
                                return cloneArrayBuffer(object);

                            case boolTag:
                            case dateTag:
                                return new Ctor(+object);

                            case dataViewTag:
                                return cloneDataView(object, isDeep);

                            case float32Tag: case float64Tag:
                            case int8Tag: case int16Tag: case int32Tag:
                            case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
                                return cloneTypedArray(object, isDeep);

                            case mapTag:
                                return new Ctor;

                            case numberTag:
                            case stringTag:
                                return new Ctor(object);

                            case regexpTag:
                                return cloneRegExp(object);

                            case setTag:
                                return new Ctor;

                            case symbolTag:
                                return cloneSymbol(object);
                        }
                    }

                    /**
                     * Inserts wrapper `details` in a comment at the top of the `source` body.
                     *
                     * @private
                     * @param {string} source The source to modify.
                     * @returns {Array} details The details to insert.
                     * @returns {string} Returns the modified source.
                     */
                    function insertWrapDetails(source, details) {
                        var length = details.length;
                        if (!length) {
                            return source;
                        }
                        var lastIndex = length - 1;
                        details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
                        details = details.join(length > 2 ? ', ' : ' ');
                        return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
                    }

                    /**
                     * Checks if `value` is a flattenable `arguments` object or array.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
                     */
                    function isFlattenable(value) {
                        return isArray(value) || isArguments(value) ||
                            !!(spreadableSymbol && value && value[spreadableSymbol]);
                    }

                    /**
                     * Checks if `value` is a valid array-like index.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
                     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
                     */
                    function isIndex(value, length) {
                        var type = typeof value;
                        length = length == null ? MAX_SAFE_INTEGER : length;

                        return !!length &&
                            (type == 'number' ||
                                (type != 'symbol' && reIsUint.test(value))) &&
                            (value > -1 && value % 1 == 0 && value < length);
                    }

                    /**
                     * Checks if the given arguments are from an iteratee call.
                     *
                     * @private
                     * @param {*} value The potential iteratee value argument.
                     * @param {*} index The potential iteratee index or key argument.
                     * @param {*} object The potential iteratee object argument.
                     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
                     *  else `false`.
                     */
                    function isIterateeCall(value, index, object) {
                        if (!isObject(object)) {
                            return false;
                        }
                        var type = typeof index;
                        if (type == 'number'
                            ? (isArrayLike(object) && isIndex(index, object.length))
                            : (type == 'string' && index in object)
                        ) {
                            return eq(object[index], value);
                        }
                        return false;
                    }

                    /**
                     * Checks if `value` is a property name and not a property path.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @param {Object} [object] The object to query keys on.
                     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
                     */
                    function isKey(value, object) {
                        if (isArray(value)) {
                            return false;
                        }
                        var type = typeof value;
                        if (type == 'number' || type == 'symbol' || type == 'boolean' ||
                            value == null || isSymbol(value)) {
                            return true;
                        }
                        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
                            (object != null && value in Object(object));
                    }

                    /**
                     * Checks if `value` is suitable for use as unique object key.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
                     */
                    function isKeyable(value) {
                        var type = typeof value;
                        return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
                            ? (value !== '__proto__')
                            : (value === null);
                    }

                    /**
                     * Checks if `func` has a lazy counterpart.
                     *
                     * @private
                     * @param {Function} func The function to check.
                     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
                     *  else `false`.
                     */
                    function isLaziable(func) {
                        var funcName = getFuncName(func),
                            other = lodash[funcName];

                        if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
                            return false;
                        }
                        if (func === other) {
                            return true;
                        }
                        var data = getData(other);
                        return !!data && func === data[0];
                    }

                    /**
                     * Checks if `func` has its source masked.
                     *
                     * @private
                     * @param {Function} func The function to check.
                     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
                     */
                    function isMasked(func) {
                        return !!maskSrcKey && (maskSrcKey in func);
                    }

                    /**
                     * Checks if `func` is capable of being masked.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
                     */
                    var isMaskable = coreJsData ? isFunction : stubFalse;

                    /**
                     * Checks if `value` is likely a prototype object.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
                     */
                    function isPrototype(value) {
                        var Ctor = value && value.constructor,
                            proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

                        return value === proto;
                    }

                    /**
                     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
                     *
                     * @private
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` if suitable for strict
                     *  equality comparisons, else `false`.
                     */
                    function isStrictComparable(value) {
                        return value === value && !isObject(value);
                    }

                    /**
                     * A specialized version of `matchesProperty` for source values suitable
                     * for strict equality comparisons, i.e. `===`.
                     *
                     * @private
                     * @param {string} key The key of the property to get.
                     * @param {*} srcValue The value to match.
                     * @returns {Function} Returns the new spec function.
                     */
                    function matchesStrictComparable(key, srcValue) {
                        return function(object) {
                            if (object == null) {
                                return false;
                            }
                            return object[key] === srcValue &&
                                (srcValue !== undefined || (key in Object(object)));
                        };
                    }

                    /**
                     * A specialized version of `_.memoize` which clears the memoized function's
                     * cache when it exceeds `MAX_MEMOIZE_SIZE`.
                     *
                     * @private
                     * @param {Function} func The function to have its output memoized.
                     * @returns {Function} Returns the new memoized function.
                     */
                    function memoizeCapped(func) {
                        var result = memoize(func, function(key) {
                            if (cache.size === MAX_MEMOIZE_SIZE) {
                                cache.clear();
                            }
                            return key;
                        });

                        var cache = result.cache;
                        return result;
                    }

                    /**
                     * Merges the function metadata of `source` into `data`.
                     *
                     * Merging metadata reduces the number of wrappers used to invoke a function.
                     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
                     * may be applied regardless of execution order. Methods like `_.ary` and
                     * `_.rearg` modify function arguments, making the order in which they are
                     * executed important, preventing the merging of metadata. However, we make
                     * an exception for a safe combined case where curried functions have `_.ary`
                     * and or `_.rearg` applied.
                     *
                     * @private
                     * @param {Array} data The destination metadata.
                     * @param {Array} source The source metadata.
                     * @returns {Array} Returns `data`.
                     */
                    function mergeData(data, source) {
                        var bitmask = data[1],
                            srcBitmask = source[1],
                            newBitmask = bitmask | srcBitmask,
                            isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);

                        var isCombo =
                            ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
                            ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
                            ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));

                        // Exit early if metadata can't be merged.
                        if (!(isCommon || isCombo)) {
                            return data;
                        }
                        // Use source `thisArg` if available.
                        if (srcBitmask & WRAP_BIND_FLAG) {
                            data[2] = source[2];
                            // Set when currying a bound function.
                            newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
                        }
                        // Compose partial arguments.
                        var value = source[3];
                        if (value) {
                            var partials = data[3];
                            data[3] = partials ? composeArgs(partials, value, source[4]) : value;
                            data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
                        }
                        // Compose partial right arguments.
                        value = source[5];
                        if (value) {
                            partials = data[5];
                            data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
                            data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
                        }
                        // Use source `argPos` if available.
                        value = source[7];
                        if (value) {
                            data[7] = value;
                        }
                        // Use source `ary` if it's smaller.
                        if (srcBitmask & WRAP_ARY_FLAG) {
                            data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
                        }
                        // Use source `arity` if one is not provided.
                        if (data[9] == null) {
                            data[9] = source[9];
                        }
                        // Use source `func` and merge bitmasks.
                        data[0] = source[0];
                        data[1] = newBitmask;

                        return data;
                    }

                    /**
                     * This function is like
                     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
                     * except that it includes inherited enumerable properties.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names.
                     */
                    function nativeKeysIn(object) {
                        var result = [];
                        if (object != null) {
                            for (var key in Object(object)) {
                                result.push(key);
                            }
                        }
                        return result;
                    }

                    /**
                     * Converts `value` to a string using `Object.prototype.toString`.
                     *
                     * @private
                     * @param {*} value The value to convert.
                     * @returns {string} Returns the converted string.
                     */
                    function objectToString(value) {
                        return nativeObjectToString.call(value);
                    }

                    /**
                     * A specialized version of `baseRest` which transforms the rest array.
                     *
                     * @private
                     * @param {Function} func The function to apply a rest parameter to.
                     * @param {number} [start=func.length-1] The start position of the rest parameter.
                     * @param {Function} transform The rest array transform.
                     * @returns {Function} Returns the new function.
                     */
                    function overRest(func, start, transform) {
                        start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
                        return function() {
                            var args = arguments,
                                index = -1,
                                length = nativeMax(args.length - start, 0),
                                array = Array(length);

                            while (++index < length) {
                                array[index] = args[start + index];
                            }
                            index = -1;
                            var otherArgs = Array(start + 1);
                            while (++index < start) {
                                otherArgs[index] = args[index];
                            }
                            otherArgs[start] = transform(array);
                            return apply(func, this, otherArgs);
                        };
                    }

                    /**
                     * Gets the parent value at `path` of `object`.
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {Array} path The path to get the parent value of.
                     * @returns {*} Returns the parent value.
                     */
                    function parent(object, path) {
                        return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
                    }

                    /**
                     * Reorder `array` according to the specified indexes where the element at
                     * the first index is assigned as the first element, the element at
                     * the second index is assigned as the second element, and so on.
                     *
                     * @private
                     * @param {Array} array The array to reorder.
                     * @param {Array} indexes The arranged array indexes.
                     * @returns {Array} Returns `array`.
                     */
                    function reorder(array, indexes) {
                        var arrLength = array.length,
                            length = nativeMin(indexes.length, arrLength),
                            oldArray = copyArray(array);

                        while (length--) {
                            var index = indexes[length];
                            array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
                        }
                        return array;
                    }

                    /**
                     * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
                     *
                     * @private
                     * @param {Object} object The object to query.
                     * @param {string} key The key of the property to get.
                     * @returns {*} Returns the property value.
                     */
                    function safeGet(object, key) {
                        if (key === 'constructor' && typeof object[key] === 'function') {
                            return;
                        }

                        if (key == '__proto__') {
                            return;
                        }

                        return object[key];
                    }

                    /**
                     * Sets metadata for `func`.
                     *
                     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
                     * period of time, it will trip its breaker and transition to an identity
                     * function to avoid garbage collection pauses in V8. See
                     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
                     * for more details.
                     *
                     * @private
                     * @param {Function} func The function to associate metadata with.
                     * @param {*} data The metadata.
                     * @returns {Function} Returns `func`.
                     */
                    var setData = shortOut(baseSetData);

                    /**
                     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
                     *
                     * @private
                     * @param {Function} func The function to delay.
                     * @param {number} wait The number of milliseconds to delay invocation.
                     * @returns {number|Object} Returns the timer id or timeout object.
                     */
                    var setTimeout = ctxSetTimeout || function(func, wait) {
                        return root.setTimeout(func, wait);
                    };

                    /**
                     * Sets the `toString` method of `func` to return `string`.
                     *
                     * @private
                     * @param {Function} func The function to modify.
                     * @param {Function} string The `toString` result.
                     * @returns {Function} Returns `func`.
                     */
                    var setToString = shortOut(baseSetToString);

                    /**
                     * Sets the `toString` method of `wrapper` to mimic the source of `reference`
                     * with wrapper details in a comment at the top of the source body.
                     *
                     * @private
                     * @param {Function} wrapper The function to modify.
                     * @param {Function} reference The reference function.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @returns {Function} Returns `wrapper`.
                     */
                    function setWrapToString(wrapper, reference, bitmask) {
                        var source = (reference + '');
                        return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
                    }

                    /**
                     * Creates a function that'll short out and invoke `identity` instead
                     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
                     * milliseconds.
                     *
                     * @private
                     * @param {Function} func The function to restrict.
                     * @returns {Function} Returns the new shortable function.
                     */
                    function shortOut(func) {
                        var count = 0,
                            lastCalled = 0;

                        return function() {
                            var stamp = nativeNow(),
                                remaining = HOT_SPAN - (stamp - lastCalled);

                            lastCalled = stamp;
                            if (remaining > 0) {
                                if (++count >= HOT_COUNT) {
                                    return arguments[0];
                                }
                            } else {
                                count = 0;
                            }
                            return func.apply(undefined, arguments);
                        };
                    }

                    /**
                     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
                     *
                     * @private
                     * @param {Array} array The array to shuffle.
                     * @param {number} [size=array.length] The size of `array`.
                     * @returns {Array} Returns `array`.
                     */
                    function shuffleSelf(array, size) {
                        var index = -1,
                            length = array.length,
                            lastIndex = length - 1;

                        size = size === undefined ? length : size;
                        while (++index < size) {
                            var rand = baseRandom(index, lastIndex),
                                value = array[rand];

                            array[rand] = array[index];
                            array[index] = value;
                        }
                        array.length = size;
                        return array;
                    }

                    /**
                     * Converts `string` to a property path array.
                     *
                     * @private
                     * @param {string} string The string to convert.
                     * @returns {Array} Returns the property path array.
                     */
                    var stringToPath = memoizeCapped(function(string) {
                        var result = [];
                        if (string.charCodeAt(0) === 46 /* . */) {
                            result.push('');
                        }
                        string.replace(rePropName, function(match, number, quote, subString) {
                            result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
                        });
                        return result;
                    });

                    /**
                     * Converts `value` to a string key if it's not a string or symbol.
                     *
                     * @private
                     * @param {*} value The value to inspect.
                     * @returns {string|symbol} Returns the key.
                     */
                    function toKey(value) {
                        if (typeof value == 'string' || isSymbol(value)) {
                            return value;
                        }
                        var result = (value + '');
                        return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
                    }

                    /**
                     * Converts `func` to its source code.
                     *
                     * @private
                     * @param {Function} func The function to convert.
                     * @returns {string} Returns the source code.
                     */
                    function toSource(func) {
                        if (func != null) {
                            try {
                                return funcToString.call(func);
                            } catch (e) {}
                            try {
                                return (func + '');
                            } catch (e) {}
                        }
                        return '';
                    }

                    /**
                     * Updates wrapper `details` based on `bitmask` flags.
                     *
                     * @private
                     * @returns {Array} details The details to modify.
                     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
                     * @returns {Array} Returns `details`.
                     */
                    function updateWrapDetails(details, bitmask) {
                        arrayEach(wrapFlags, function(pair) {
                            var value = '_.' + pair[0];
                            if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
                                details.push(value);
                            }
                        });
                        return details.sort();
                    }

                    /**
                     * Creates a clone of `wrapper`.
                     *
                     * @private
                     * @param {Object} wrapper The wrapper to clone.
                     * @returns {Object} Returns the cloned wrapper.
                     */
                    function wrapperClone(wrapper) {
                        if (wrapper instanceof LazyWrapper) {
                            return wrapper.clone();
                        }
                        var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
                        result.__actions__ = copyArray(wrapper.__actions__);
                        result.__index__  = wrapper.__index__;
                        result.__values__ = wrapper.__values__;
                        return result;
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates an array of elements split into groups the length of `size`.
                     * If `array` can't be split evenly, the final chunk will be the remaining
                     * elements.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to process.
                     * @param {number} [size=1] The length of each chunk
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the new array of chunks.
                     * @example
                     *
                     * _.chunk(['a', 'b', 'c', 'd'], 2);
                     * // => [['a', 'b'], ['c', 'd']]
                     *
                     * _.chunk(['a', 'b', 'c', 'd'], 3);
                     * // => [['a', 'b', 'c'], ['d']]
                     */
                    function chunk(array, size, guard) {
                        if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
                            size = 1;
                        } else {
                            size = nativeMax(toInteger(size), 0);
                        }
                        var length = array == null ? 0 : array.length;
                        if (!length || size < 1) {
                            return [];
                        }
                        var index = 0,
                            resIndex = 0,
                            result = Array(nativeCeil(length / size));

                        while (index < length) {
                            result[resIndex++] = baseSlice(array, index, (index += size));
                        }
                        return result;
                    }

                    /**
                     * Creates an array with all falsey values removed. The values `false`, `null`,
                     * `0`, `""`, `undefined`, and `NaN` are falsey.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to compact.
                     * @returns {Array} Returns the new array of filtered values.
                     * @example
                     *
                     * _.compact([0, 1, false, 2, '', 3]);
                     * // => [1, 2, 3]
                     */
                    function compact(array) {
                        var index = -1,
                            length = array == null ? 0 : array.length,
                            resIndex = 0,
                            result = [];

                        while (++index < length) {
                            var value = array[index];
                            if (value) {
                                result[resIndex++] = value;
                            }
                        }
                        return result;
                    }

                    /**
                     * Creates a new array concatenating `array` with any additional arrays
                     * and/or values.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to concatenate.
                     * @param {...*} [values] The values to concatenate.
                     * @returns {Array} Returns the new concatenated array.
                     * @example
                     *
                     * var array = [1];
                     * var other = _.concat(array, 2, [3], [[4]]);
                     *
                     * console.log(other);
                     * // => [1, 2, 3, [4]]
                     *
                     * console.log(array);
                     * // => [1]
                     */
                    function concat() {
                        var length = arguments.length;
                        if (!length) {
                            return [];
                        }
                        var args = Array(length - 1),
                            array = arguments[0],
                            index = length;

                        while (index--) {
                            args[index - 1] = arguments[index];
                        }
                        return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
                    }

                    /**
                     * Creates an array of `array` values not included in the other given arrays
                     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons. The order and references of result values are
                     * determined by the first array.
                     *
                     * **Note:** Unlike `_.pullAll`, this method returns a new array.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {...Array} [values] The values to exclude.
                     * @returns {Array} Returns the new array of filtered values.
                     * @see _.without, _.xor
                     * @example
                     *
                     * _.difference([2, 1], [2, 3]);
                     * // => [1]
                     */
                    var difference = baseRest(function(array, values) {
                        return isArrayLikeObject(array)
                            ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
                            : [];
                    });

                    /**
                     * This method is like `_.difference` except that it accepts `iteratee` which
                     * is invoked for each element of `array` and `values` to generate the criterion
                     * by which they're compared. The order and references of result values are
                     * determined by the first array. The iteratee is invoked with one argument:
                     * (value).
                     *
                     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {...Array} [values] The values to exclude.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Array} Returns the new array of filtered values.
                     * @example
                     *
                     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
                     * // => [1.2]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
                     * // => [{ 'x': 2 }]
                     */
                    var differenceBy = baseRest(function(array, values) {
                        var iteratee = last(values);
                        if (isArrayLikeObject(iteratee)) {
                            iteratee = undefined;
                        }
                        return isArrayLikeObject(array)
                            ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
                            : [];
                    });

                    /**
                     * This method is like `_.difference` except that it accepts `comparator`
                     * which is invoked to compare elements of `array` to `values`. The order and
                     * references of result values are determined by the first array. The comparator
                     * is invoked with two arguments: (arrVal, othVal).
                     *
                     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {...Array} [values] The values to exclude.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of filtered values.
                     * @example
                     *
                     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
                     *
                     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
                     * // => [{ 'x': 2, 'y': 1 }]
                     */
                    var differenceWith = baseRest(function(array, values) {
                        var comparator = last(values);
                        if (isArrayLikeObject(comparator)) {
                            comparator = undefined;
                        }
                        return isArrayLikeObject(array)
                            ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
                            : [];
                    });

                    /**
                     * Creates a slice of `array` with `n` elements dropped from the beginning.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.5.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {number} [n=1] The number of elements to drop.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * _.drop([1, 2, 3]);
                     * // => [2, 3]
                     *
                     * _.drop([1, 2, 3], 2);
                     * // => [3]
                     *
                     * _.drop([1, 2, 3], 5);
                     * // => []
                     *
                     * _.drop([1, 2, 3], 0);
                     * // => [1, 2, 3]
                     */
                    function drop(array, n, guard) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return [];
                        }
                        n = (guard || n === undefined) ? 1 : toInteger(n);
                        return baseSlice(array, n < 0 ? 0 : n, length);
                    }

                    /**
                     * Creates a slice of `array` with `n` elements dropped from the end.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {number} [n=1] The number of elements to drop.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * _.dropRight([1, 2, 3]);
                     * // => [1, 2]
                     *
                     * _.dropRight([1, 2, 3], 2);
                     * // => [1]
                     *
                     * _.dropRight([1, 2, 3], 5);
                     * // => []
                     *
                     * _.dropRight([1, 2, 3], 0);
                     * // => [1, 2, 3]
                     */
                    function dropRight(array, n, guard) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return [];
                        }
                        n = (guard || n === undefined) ? 1 : toInteger(n);
                        n = length - n;
                        return baseSlice(array, 0, n < 0 ? 0 : n);
                    }

                    /**
                     * Creates a slice of `array` excluding elements dropped from the end.
                     * Elements are dropped until `predicate` returns falsey. The predicate is
                     * invoked with three arguments: (value, index, array).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'active': true },
                     *   { 'user': 'fred',    'active': false },
                     *   { 'user': 'pebbles', 'active': false }
                     * ];
                     *
                     * _.dropRightWhile(users, function(o) { return !o.active; });
                     * // => objects for ['barney']
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
                     * // => objects for ['barney', 'fred']
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.dropRightWhile(users, ['active', false]);
                     * // => objects for ['barney']
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.dropRightWhile(users, 'active');
                     * // => objects for ['barney', 'fred', 'pebbles']
                     */
                    function dropRightWhile(array, predicate) {
                        return (array && array.length)
                            ? baseWhile(array, getIteratee(predicate, 3), true, true)
                            : [];
                    }

                    /**
                     * Creates a slice of `array` excluding elements dropped from the beginning.
                     * Elements are dropped until `predicate` returns falsey. The predicate is
                     * invoked with three arguments: (value, index, array).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'active': false },
                     *   { 'user': 'fred',    'active': false },
                     *   { 'user': 'pebbles', 'active': true }
                     * ];
                     *
                     * _.dropWhile(users, function(o) { return !o.active; });
                     * // => objects for ['pebbles']
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.dropWhile(users, { 'user': 'barney', 'active': false });
                     * // => objects for ['fred', 'pebbles']
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.dropWhile(users, ['active', false]);
                     * // => objects for ['pebbles']
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.dropWhile(users, 'active');
                     * // => objects for ['barney', 'fred', 'pebbles']
                     */
                    function dropWhile(array, predicate) {
                        return (array && array.length)
                            ? baseWhile(array, getIteratee(predicate, 3), true)
                            : [];
                    }

                    /**
                     * Fills elements of `array` with `value` from `start` up to, but not
                     * including, `end`.
                     *
                     * **Note:** This method mutates `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.2.0
                     * @category Array
                     * @param {Array} array The array to fill.
                     * @param {*} value The value to fill `array` with.
                     * @param {number} [start=0] The start position.
                     * @param {number} [end=array.length] The end position.
                     * @returns {Array} Returns `array`.
                     * @example
                     *
                     * var array = [1, 2, 3];
                     *
                     * _.fill(array, 'a');
                     * console.log(array);
                     * // => ['a', 'a', 'a']
                     *
                     * _.fill(Array(3), 2);
                     * // => [2, 2, 2]
                     *
                     * _.fill([4, 6, 8, 10], '*', 1, 3);
                     * // => [4, '*', '*', 10]
                     */
                    function fill(array, value, start, end) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return [];
                        }
                        if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
                            start = 0;
                            end = length;
                        }
                        return baseFill(array, value, start, end);
                    }

                    /**
                     * This method is like `_.find` except that it returns the index of the first
                     * element `predicate` returns truthy for instead of the element itself.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.1.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @param {number} [fromIndex=0] The index to search from.
                     * @returns {number} Returns the index of the found element, else `-1`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'active': false },
                     *   { 'user': 'fred',    'active': false },
                     *   { 'user': 'pebbles', 'active': true }
                     * ];
                     *
                     * _.findIndex(users, function(o) { return o.user == 'barney'; });
                     * // => 0
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.findIndex(users, { 'user': 'fred', 'active': false });
                     * // => 1
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.findIndex(users, ['active', false]);
                     * // => 0
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.findIndex(users, 'active');
                     * // => 2
                     */
                    function findIndex(array, predicate, fromIndex) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return -1;
                        }
                        var index = fromIndex == null ? 0 : toInteger(fromIndex);
                        if (index < 0) {
                            index = nativeMax(length + index, 0);
                        }
                        return baseFindIndex(array, getIteratee(predicate, 3), index);
                    }

                    /**
                     * This method is like `_.findIndex` except that it iterates over elements
                     * of `collection` from right to left.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @param {number} [fromIndex=array.length-1] The index to search from.
                     * @returns {number} Returns the index of the found element, else `-1`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'active': true },
                     *   { 'user': 'fred',    'active': false },
                     *   { 'user': 'pebbles', 'active': false }
                     * ];
                     *
                     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
                     * // => 2
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.findLastIndex(users, { 'user': 'barney', 'active': true });
                     * // => 0
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.findLastIndex(users, ['active', false]);
                     * // => 2
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.findLastIndex(users, 'active');
                     * // => 0
                     */
                    function findLastIndex(array, predicate, fromIndex) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return -1;
                        }
                        var index = length - 1;
                        if (fromIndex !== undefined) {
                            index = toInteger(fromIndex);
                            index = fromIndex < 0
                                ? nativeMax(length + index, 0)
                                : nativeMin(index, length - 1);
                        }
                        return baseFindIndex(array, getIteratee(predicate, 3), index, true);
                    }

                    /**
                     * Flattens `array` a single level deep.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to flatten.
                     * @returns {Array} Returns the new flattened array.
                     * @example
                     *
                     * _.flatten([1, [2, [3, [4]], 5]]);
                     * // => [1, 2, [3, [4]], 5]
                     */
                    function flatten(array) {
                        var length = array == null ? 0 : array.length;
                        return length ? baseFlatten(array, 1) : [];
                    }

                    /**
                     * Recursively flattens `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to flatten.
                     * @returns {Array} Returns the new flattened array.
                     * @example
                     *
                     * _.flattenDeep([1, [2, [3, [4]], 5]]);
                     * // => [1, 2, 3, 4, 5]
                     */
                    function flattenDeep(array) {
                        var length = array == null ? 0 : array.length;
                        return length ? baseFlatten(array, INFINITY) : [];
                    }

                    /**
                     * Recursively flatten `array` up to `depth` times.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.4.0
                     * @category Array
                     * @param {Array} array The array to flatten.
                     * @param {number} [depth=1] The maximum recursion depth.
                     * @returns {Array} Returns the new flattened array.
                     * @example
                     *
                     * var array = [1, [2, [3, [4]], 5]];
                     *
                     * _.flattenDepth(array, 1);
                     * // => [1, 2, [3, [4]], 5]
                     *
                     * _.flattenDepth(array, 2);
                     * // => [1, 2, 3, [4], 5]
                     */
                    function flattenDepth(array, depth) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return [];
                        }
                        depth = depth === undefined ? 1 : toInteger(depth);
                        return baseFlatten(array, depth);
                    }

                    /**
                     * The inverse of `_.toPairs`; this method returns an object composed
                     * from key-value `pairs`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} pairs The key-value pairs.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * _.fromPairs([['a', 1], ['b', 2]]);
                     * // => { 'a': 1, 'b': 2 }
                     */
                    function fromPairs(pairs) {
                        var index = -1,
                            length = pairs == null ? 0 : pairs.length,
                            result = {};

                        while (++index < length) {
                            var pair = pairs[index];
                            result[pair[0]] = pair[1];
                        }
                        return result;
                    }

                    /**
                     * Gets the first element of `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @alias first
                     * @category Array
                     * @param {Array} array The array to query.
                     * @returns {*} Returns the first element of `array`.
                     * @example
                     *
                     * _.head([1, 2, 3]);
                     * // => 1
                     *
                     * _.head([]);
                     * // => undefined
                     */
                    function head(array) {
                        return (array && array.length) ? array[0] : undefined;
                    }

                    /**
                     * Gets the index at which the first occurrence of `value` is found in `array`
                     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons. If `fromIndex` is negative, it's used as the
                     * offset from the end of `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {*} value The value to search for.
                     * @param {number} [fromIndex=0] The index to search from.
                     * @returns {number} Returns the index of the matched value, else `-1`.
                     * @example
                     *
                     * _.indexOf([1, 2, 1, 2], 2);
                     * // => 1
                     *
                     * // Search from the `fromIndex`.
                     * _.indexOf([1, 2, 1, 2], 2, 2);
                     * // => 3
                     */
                    function indexOf(array, value, fromIndex) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return -1;
                        }
                        var index = fromIndex == null ? 0 : toInteger(fromIndex);
                        if (index < 0) {
                            index = nativeMax(length + index, 0);
                        }
                        return baseIndexOf(array, value, index);
                    }

                    /**
                     * Gets all but the last element of `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * _.initial([1, 2, 3]);
                     * // => [1, 2]
                     */
                    function initial(array) {
                        var length = array == null ? 0 : array.length;
                        return length ? baseSlice(array, 0, -1) : [];
                    }

                    /**
                     * Creates an array of unique values that are included in all given arrays
                     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons. The order and references of result values are
                     * determined by the first array.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @returns {Array} Returns the new array of intersecting values.
                     * @example
                     *
                     * _.intersection([2, 1], [2, 3]);
                     * // => [2]
                     */
                    var intersection = baseRest(function(arrays) {
                        var mapped = arrayMap(arrays, castArrayLikeObject);
                        return (mapped.length && mapped[0] === arrays[0])
                            ? baseIntersection(mapped)
                            : [];
                    });

                    /**
                     * This method is like `_.intersection` except that it accepts `iteratee`
                     * which is invoked for each element of each `arrays` to generate the criterion
                     * by which they're compared. The order and references of result values are
                     * determined by the first array. The iteratee is invoked with one argument:
                     * (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Array} Returns the new array of intersecting values.
                     * @example
                     *
                     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
                     * // => [2.1]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
                     * // => [{ 'x': 1 }]
                     */
                    var intersectionBy = baseRest(function(arrays) {
                        var iteratee = last(arrays),
                            mapped = arrayMap(arrays, castArrayLikeObject);

                        if (iteratee === last(mapped)) {
                            iteratee = undefined;
                        } else {
                            mapped.pop();
                        }
                        return (mapped.length && mapped[0] === arrays[0])
                            ? baseIntersection(mapped, getIteratee(iteratee, 2))
                            : [];
                    });

                    /**
                     * This method is like `_.intersection` except that it accepts `comparator`
                     * which is invoked to compare elements of `arrays`. The order and references
                     * of result values are determined by the first array. The comparator is
                     * invoked with two arguments: (arrVal, othVal).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of intersecting values.
                     * @example
                     *
                     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
                     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
                     *
                     * _.intersectionWith(objects, others, _.isEqual);
                     * // => [{ 'x': 1, 'y': 2 }]
                     */
                    var intersectionWith = baseRest(function(arrays) {
                        var comparator = last(arrays),
                            mapped = arrayMap(arrays, castArrayLikeObject);

                        comparator = typeof comparator == 'function' ? comparator : undefined;
                        if (comparator) {
                            mapped.pop();
                        }
                        return (mapped.length && mapped[0] === arrays[0])
                            ? baseIntersection(mapped, undefined, comparator)
                            : [];
                    });

                    /**
                     * Converts all elements in `array` into a string separated by `separator`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to convert.
                     * @param {string} [separator=','] The element separator.
                     * @returns {string} Returns the joined string.
                     * @example
                     *
                     * _.join(['a', 'b', 'c'], '~');
                     * // => 'a~b~c'
                     */
                    function join(array, separator) {
                        return array == null ? '' : nativeJoin.call(array, separator);
                    }

                    /**
                     * Gets the last element of `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @returns {*} Returns the last element of `array`.
                     * @example
                     *
                     * _.last([1, 2, 3]);
                     * // => 3
                     */
                    function last(array) {
                        var length = array == null ? 0 : array.length;
                        return length ? array[length - 1] : undefined;
                    }

                    /**
                     * This method is like `_.indexOf` except that it iterates over elements of
                     * `array` from right to left.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {*} value The value to search for.
                     * @param {number} [fromIndex=array.length-1] The index to search from.
                     * @returns {number} Returns the index of the matched value, else `-1`.
                     * @example
                     *
                     * _.lastIndexOf([1, 2, 1, 2], 2);
                     * // => 3
                     *
                     * // Search from the `fromIndex`.
                     * _.lastIndexOf([1, 2, 1, 2], 2, 2);
                     * // => 1
                     */
                    function lastIndexOf(array, value, fromIndex) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return -1;
                        }
                        var index = length;
                        if (fromIndex !== undefined) {
                            index = toInteger(fromIndex);
                            index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
                        }
                        return value === value
                            ? strictLastIndexOf(array, value, index)
                            : baseFindIndex(array, baseIsNaN, index, true);
                    }

                    /**
                     * Gets the element at index `n` of `array`. If `n` is negative, the nth
                     * element from the end is returned.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.11.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {number} [n=0] The index of the element to return.
                     * @returns {*} Returns the nth element of `array`.
                     * @example
                     *
                     * var array = ['a', 'b', 'c', 'd'];
                     *
                     * _.nth(array, 1);
                     * // => 'b'
                     *
                     * _.nth(array, -2);
                     * // => 'c';
                     */
                    function nth(array, n) {
                        return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
                    }

                    /**
                     * Removes all given values from `array` using
                     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons.
                     *
                     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
                     * to remove elements from an array by predicate.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @param {...*} [values] The values to remove.
                     * @returns {Array} Returns `array`.
                     * @example
                     *
                     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
                     *
                     * _.pull(array, 'a', 'c');
                     * console.log(array);
                     * // => ['b', 'b']
                     */
                    var pull = baseRest(pullAll);

                    /**
                     * This method is like `_.pull` except that it accepts an array of values to remove.
                     *
                     * **Note:** Unlike `_.difference`, this method mutates `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @param {Array} values The values to remove.
                     * @returns {Array} Returns `array`.
                     * @example
                     *
                     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
                     *
                     * _.pullAll(array, ['a', 'c']);
                     * console.log(array);
                     * // => ['b', 'b']
                     */
                    function pullAll(array, values) {
                        return (array && array.length && values && values.length)
                            ? basePullAll(array, values)
                            : array;
                    }

                    /**
                     * This method is like `_.pullAll` except that it accepts `iteratee` which is
                     * invoked for each element of `array` and `values` to generate the criterion
                     * by which they're compared. The iteratee is invoked with one argument: (value).
                     *
                     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @param {Array} values The values to remove.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Array} Returns `array`.
                     * @example
                     *
                     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
                     *
                     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
                     * console.log(array);
                     * // => [{ 'x': 2 }]
                     */
                    function pullAllBy(array, values, iteratee) {
                        return (array && array.length && values && values.length)
                            ? basePullAll(array, values, getIteratee(iteratee, 2))
                            : array;
                    }

                    /**
                     * This method is like `_.pullAll` except that it accepts `comparator` which
                     * is invoked to compare elements of `array` to `values`. The comparator is
                     * invoked with two arguments: (arrVal, othVal).
                     *
                     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.6.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @param {Array} values The values to remove.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns `array`.
                     * @example
                     *
                     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
                     *
                     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
                     * console.log(array);
                     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
                     */
                    function pullAllWith(array, values, comparator) {
                        return (array && array.length && values && values.length)
                            ? basePullAll(array, values, undefined, comparator)
                            : array;
                    }

                    /**
                     * Removes elements from `array` corresponding to `indexes` and returns an
                     * array of removed elements.
                     *
                     * **Note:** Unlike `_.at`, this method mutates `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @param {...(number|number[])} [indexes] The indexes of elements to remove.
                     * @returns {Array} Returns the new array of removed elements.
                     * @example
                     *
                     * var array = ['a', 'b', 'c', 'd'];
                     * var pulled = _.pullAt(array, [1, 3]);
                     *
                     * console.log(array);
                     * // => ['a', 'c']
                     *
                     * console.log(pulled);
                     * // => ['b', 'd']
                     */
                    var pullAt = flatRest(function(array, indexes) {
                        var length = array == null ? 0 : array.length,
                            result = baseAt(array, indexes);

                        basePullAt(array, arrayMap(indexes, function(index) {
                            return isIndex(index, length) ? +index : index;
                        }).sort(compareAscending));

                        return result;
                    });

                    /**
                     * Removes all elements from `array` that `predicate` returns truthy for
                     * and returns an array of the removed elements. The predicate is invoked
                     * with three arguments: (value, index, array).
                     *
                     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
                     * to pull elements from an array by value.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the new array of removed elements.
                     * @example
                     *
                     * var array = [1, 2, 3, 4];
                     * var evens = _.remove(array, function(n) {
                     *   return n % 2 == 0;
                     * });
                     *
                     * console.log(array);
                     * // => [1, 3]
                     *
                     * console.log(evens);
                     * // => [2, 4]
                     */
                    function remove(array, predicate) {
                        var result = [];
                        if (!(array && array.length)) {
                            return result;
                        }
                        var index = -1,
                            indexes = [],
                            length = array.length;

                        predicate = getIteratee(predicate, 3);
                        while (++index < length) {
                            var value = array[index];
                            if (predicate(value, index, array)) {
                                result.push(value);
                                indexes.push(index);
                            }
                        }
                        basePullAt(array, indexes);
                        return result;
                    }

                    /**
                     * Reverses `array` so that the first element becomes the last, the second
                     * element becomes the second to last, and so on.
                     *
                     * **Note:** This method mutates `array` and is based on
                     * [`Array#reverse`](https://mdn.io/Array/reverse).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to modify.
                     * @returns {Array} Returns `array`.
                     * @example
                     *
                     * var array = [1, 2, 3];
                     *
                     * _.reverse(array);
                     * // => [3, 2, 1]
                     *
                     * console.log(array);
                     * // => [3, 2, 1]
                     */
                    function reverse(array) {
                        return array == null ? array : nativeReverse.call(array);
                    }

                    /**
                     * Creates a slice of `array` from `start` up to, but not including, `end`.
                     *
                     * **Note:** This method is used instead of
                     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
                     * returned.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to slice.
                     * @param {number} [start=0] The start position.
                     * @param {number} [end=array.length] The end position.
                     * @returns {Array} Returns the slice of `array`.
                     */
                    function slice(array, start, end) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return [];
                        }
                        if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
                            start = 0;
                            end = length;
                        }
                        else {
                            start = start == null ? 0 : toInteger(start);
                            end = end === undefined ? length : toInteger(end);
                        }
                        return baseSlice(array, start, end);
                    }

                    /**
                     * Uses a binary search to determine the lowest index at which `value`
                     * should be inserted into `array` in order to maintain its sort order.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The sorted array to inspect.
                     * @param {*} value The value to evaluate.
                     * @returns {number} Returns the index at which `value` should be inserted
                     *  into `array`.
                     * @example
                     *
                     * _.sortedIndex([30, 50], 40);
                     * // => 1
                     */
                    function sortedIndex(array, value) {
                        return baseSortedIndex(array, value);
                    }

                    /**
                     * This method is like `_.sortedIndex` except that it accepts `iteratee`
                     * which is invoked for `value` and each element of `array` to compute their
                     * sort ranking. The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The sorted array to inspect.
                     * @param {*} value The value to evaluate.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {number} Returns the index at which `value` should be inserted
                     *  into `array`.
                     * @example
                     *
                     * var objects = [{ 'x': 4 }, { 'x': 5 }];
                     *
                     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
                     * // => 0
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
                     * // => 0
                     */
                    function sortedIndexBy(array, value, iteratee) {
                        return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
                    }

                    /**
                     * This method is like `_.indexOf` except that it performs a binary
                     * search on a sorted `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {*} value The value to search for.
                     * @returns {number} Returns the index of the matched value, else `-1`.
                     * @example
                     *
                     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
                     * // => 1
                     */
                    function sortedIndexOf(array, value) {
                        var length = array == null ? 0 : array.length;
                        if (length) {
                            var index = baseSortedIndex(array, value);
                            if (index < length && eq(array[index], value)) {
                                return index;
                            }
                        }
                        return -1;
                    }

                    /**
                     * This method is like `_.sortedIndex` except that it returns the highest
                     * index at which `value` should be inserted into `array` in order to
                     * maintain its sort order.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The sorted array to inspect.
                     * @param {*} value The value to evaluate.
                     * @returns {number} Returns the index at which `value` should be inserted
                     *  into `array`.
                     * @example
                     *
                     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
                     * // => 4
                     */
                    function sortedLastIndex(array, value) {
                        return baseSortedIndex(array, value, true);
                    }

                    /**
                     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
                     * which is invoked for `value` and each element of `array` to compute their
                     * sort ranking. The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The sorted array to inspect.
                     * @param {*} value The value to evaluate.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {number} Returns the index at which `value` should be inserted
                     *  into `array`.
                     * @example
                     *
                     * var objects = [{ 'x': 4 }, { 'x': 5 }];
                     *
                     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
                     * // => 1
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
                     * // => 1
                     */
                    function sortedLastIndexBy(array, value, iteratee) {
                        return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
                    }

                    /**
                     * This method is like `_.lastIndexOf` except that it performs a binary
                     * search on a sorted `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {*} value The value to search for.
                     * @returns {number} Returns the index of the matched value, else `-1`.
                     * @example
                     *
                     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
                     * // => 3
                     */
                    function sortedLastIndexOf(array, value) {
                        var length = array == null ? 0 : array.length;
                        if (length) {
                            var index = baseSortedIndex(array, value, true) - 1;
                            if (eq(array[index], value)) {
                                return index;
                            }
                        }
                        return -1;
                    }

                    /**
                     * This method is like `_.uniq` except that it's designed and optimized
                     * for sorted arrays.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @returns {Array} Returns the new duplicate free array.
                     * @example
                     *
                     * _.sortedUniq([1, 1, 2]);
                     * // => [1, 2]
                     */
                    function sortedUniq(array) {
                        return (array && array.length)
                            ? baseSortedUniq(array)
                            : [];
                    }

                    /**
                     * This method is like `_.uniqBy` except that it's designed and optimized
                     * for sorted arrays.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {Function} [iteratee] The iteratee invoked per element.
                     * @returns {Array} Returns the new duplicate free array.
                     * @example
                     *
                     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
                     * // => [1.1, 2.3]
                     */
                    function sortedUniqBy(array, iteratee) {
                        return (array && array.length)
                            ? baseSortedUniq(array, getIteratee(iteratee, 2))
                            : [];
                    }

                    /**
                     * Gets all but the first element of `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * _.tail([1, 2, 3]);
                     * // => [2, 3]
                     */
                    function tail(array) {
                        var length = array == null ? 0 : array.length;
                        return length ? baseSlice(array, 1, length) : [];
                    }

                    /**
                     * Creates a slice of `array` with `n` elements taken from the beginning.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {number} [n=1] The number of elements to take.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * _.take([1, 2, 3]);
                     * // => [1]
                     *
                     * _.take([1, 2, 3], 2);
                     * // => [1, 2]
                     *
                     * _.take([1, 2, 3], 5);
                     * // => [1, 2, 3]
                     *
                     * _.take([1, 2, 3], 0);
                     * // => []
                     */
                    function take(array, n, guard) {
                        if (!(array && array.length)) {
                            return [];
                        }
                        n = (guard || n === undefined) ? 1 : toInteger(n);
                        return baseSlice(array, 0, n < 0 ? 0 : n);
                    }

                    /**
                     * Creates a slice of `array` with `n` elements taken from the end.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {number} [n=1] The number of elements to take.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * _.takeRight([1, 2, 3]);
                     * // => [3]
                     *
                     * _.takeRight([1, 2, 3], 2);
                     * // => [2, 3]
                     *
                     * _.takeRight([1, 2, 3], 5);
                     * // => [1, 2, 3]
                     *
                     * _.takeRight([1, 2, 3], 0);
                     * // => []
                     */
                    function takeRight(array, n, guard) {
                        var length = array == null ? 0 : array.length;
                        if (!length) {
                            return [];
                        }
                        n = (guard || n === undefined) ? 1 : toInteger(n);
                        n = length - n;
                        return baseSlice(array, n < 0 ? 0 : n, length);
                    }

                    /**
                     * Creates a slice of `array` with elements taken from the end. Elements are
                     * taken until `predicate` returns falsey. The predicate is invoked with
                     * three arguments: (value, index, array).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'active': true },
                     *   { 'user': 'fred',    'active': false },
                     *   { 'user': 'pebbles', 'active': false }
                     * ];
                     *
                     * _.takeRightWhile(users, function(o) { return !o.active; });
                     * // => objects for ['fred', 'pebbles']
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
                     * // => objects for ['pebbles']
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.takeRightWhile(users, ['active', false]);
                     * // => objects for ['fred', 'pebbles']
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.takeRightWhile(users, 'active');
                     * // => []
                     */
                    function takeRightWhile(array, predicate) {
                        return (array && array.length)
                            ? baseWhile(array, getIteratee(predicate, 3), false, true)
                            : [];
                    }

                    /**
                     * Creates a slice of `array` with elements taken from the beginning. Elements
                     * are taken until `predicate` returns falsey. The predicate is invoked with
                     * three arguments: (value, index, array).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Array
                     * @param {Array} array The array to query.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the slice of `array`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'active': false },
                     *   { 'user': 'fred',    'active': false },
                     *   { 'user': 'pebbles', 'active': true }
                     * ];
                     *
                     * _.takeWhile(users, function(o) { return !o.active; });
                     * // => objects for ['barney', 'fred']
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.takeWhile(users, { 'user': 'barney', 'active': false });
                     * // => objects for ['barney']
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.takeWhile(users, ['active', false]);
                     * // => objects for ['barney', 'fred']
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.takeWhile(users, 'active');
                     * // => []
                     */
                    function takeWhile(array, predicate) {
                        return (array && array.length)
                            ? baseWhile(array, getIteratee(predicate, 3))
                            : [];
                    }

                    /**
                     * Creates an array of unique values, in order, from all given arrays using
                     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @returns {Array} Returns the new array of combined values.
                     * @example
                     *
                     * _.union([2], [1, 2]);
                     * // => [2, 1]
                     */
                    var union = baseRest(function(arrays) {
                        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
                    });

                    /**
                     * This method is like `_.union` except that it accepts `iteratee` which is
                     * invoked for each element of each `arrays` to generate the criterion by
                     * which uniqueness is computed. Result values are chosen from the first
                     * array in which the value occurs. The iteratee is invoked with one argument:
                     * (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Array} Returns the new array of combined values.
                     * @example
                     *
                     * _.unionBy([2.1], [1.2, 2.3], Math.floor);
                     * // => [2.1, 1.2]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
                     * // => [{ 'x': 1 }, { 'x': 2 }]
                     */
                    var unionBy = baseRest(function(arrays) {
                        var iteratee = last(arrays);
                        if (isArrayLikeObject(iteratee)) {
                            iteratee = undefined;
                        }
                        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
                    });

                    /**
                     * This method is like `_.union` except that it accepts `comparator` which
                     * is invoked to compare elements of `arrays`. Result values are chosen from
                     * the first array in which the value occurs. The comparator is invoked
                     * with two arguments: (arrVal, othVal).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of combined values.
                     * @example
                     *
                     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
                     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
                     *
                     * _.unionWith(objects, others, _.isEqual);
                     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
                     */
                    var unionWith = baseRest(function(arrays) {
                        var comparator = last(arrays);
                        comparator = typeof comparator == 'function' ? comparator : undefined;
                        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
                    });

                    /**
                     * Creates a duplicate-free version of an array, using
                     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons, in which only the first occurrence of each element
                     * is kept. The order of result values is determined by the order they occur
                     * in the array.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @returns {Array} Returns the new duplicate free array.
                     * @example
                     *
                     * _.uniq([2, 1, 2]);
                     * // => [2, 1]
                     */
                    function uniq(array) {
                        return (array && array.length) ? baseUniq(array) : [];
                    }

                    /**
                     * This method is like `_.uniq` except that it accepts `iteratee` which is
                     * invoked for each element in `array` to generate the criterion by which
                     * uniqueness is computed. The order of result values is determined by the
                     * order they occur in the array. The iteratee is invoked with one argument:
                     * (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Array} Returns the new duplicate free array.
                     * @example
                     *
                     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
                     * // => [2.1, 1.2]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
                     * // => [{ 'x': 1 }, { 'x': 2 }]
                     */
                    function uniqBy(array, iteratee) {
                        return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
                    }

                    /**
                     * This method is like `_.uniq` except that it accepts `comparator` which
                     * is invoked to compare elements of `array`. The order of result values is
                     * determined by the order they occur in the array.The comparator is invoked
                     * with two arguments: (arrVal, othVal).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new duplicate free array.
                     * @example
                     *
                     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
                     *
                     * _.uniqWith(objects, _.isEqual);
                     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
                     */
                    function uniqWith(array, comparator) {
                        comparator = typeof comparator == 'function' ? comparator : undefined;
                        return (array && array.length) ? baseUniq(array, undefined, comparator) : [];
                    }

                    /**
                     * This method is like `_.zip` except that it accepts an array of grouped
                     * elements and creates an array regrouping the elements to their pre-zip
                     * configuration.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.2.0
                     * @category Array
                     * @param {Array} array The array of grouped elements to process.
                     * @returns {Array} Returns the new array of regrouped elements.
                     * @example
                     *
                     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
                     * // => [['a', 1, true], ['b', 2, false]]
                     *
                     * _.unzip(zipped);
                     * // => [['a', 'b'], [1, 2], [true, false]]
                     */
                    function unzip(array) {
                        if (!(array && array.length)) {
                            return [];
                        }
                        var length = 0;
                        array = arrayFilter(array, function(group) {
                            if (isArrayLikeObject(group)) {
                                length = nativeMax(group.length, length);
                                return true;
                            }
                        });
                        return baseTimes(length, function(index) {
                            return arrayMap(array, baseProperty(index));
                        });
                    }

                    /**
                     * This method is like `_.unzip` except that it accepts `iteratee` to specify
                     * how regrouped values should be combined. The iteratee is invoked with the
                     * elements of each group: (...group).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.8.0
                     * @category Array
                     * @param {Array} array The array of grouped elements to process.
                     * @param {Function} [iteratee=_.identity] The function to combine
                     *  regrouped values.
                     * @returns {Array} Returns the new array of regrouped elements.
                     * @example
                     *
                     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
                     * // => [[1, 10, 100], [2, 20, 200]]
                     *
                     * _.unzipWith(zipped, _.add);
                     * // => [3, 30, 300]
                     */
                    function unzipWith(array, iteratee) {
                        if (!(array && array.length)) {
                            return [];
                        }
                        var result = unzip(array);
                        if (iteratee == null) {
                            return result;
                        }
                        return arrayMap(result, function(group) {
                            return apply(iteratee, undefined, group);
                        });
                    }

                    /**
                     * Creates an array excluding all given values using
                     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * for equality comparisons.
                     *
                     * **Note:** Unlike `_.pull`, this method returns a new array.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {Array} array The array to inspect.
                     * @param {...*} [values] The values to exclude.
                     * @returns {Array} Returns the new array of filtered values.
                     * @see _.difference, _.xor
                     * @example
                     *
                     * _.without([2, 1, 2, 3], 1, 2);
                     * // => [3]
                     */
                    var without = baseRest(function(array, values) {
                        return isArrayLikeObject(array)
                            ? baseDifference(array, values)
                            : [];
                    });

                    /**
                     * Creates an array of unique values that is the
                     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
                     * of the given arrays. The order of result values is determined by the order
                     * they occur in the arrays.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.4.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @returns {Array} Returns the new array of filtered values.
                     * @see _.difference, _.without
                     * @example
                     *
                     * _.xor([2, 1], [2, 3]);
                     * // => [1, 3]
                     */
                    var xor = baseRest(function(arrays) {
                        return baseXor(arrayFilter(arrays, isArrayLikeObject));
                    });

                    /**
                     * This method is like `_.xor` except that it accepts `iteratee` which is
                     * invoked for each element of each `arrays` to generate the criterion by
                     * which by which they're compared. The order of result values is determined
                     * by the order they occur in the arrays. The iteratee is invoked with one
                     * argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Array} Returns the new array of filtered values.
                     * @example
                     *
                     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
                     * // => [1.2, 3.4]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
                     * // => [{ 'x': 2 }]
                     */
                    var xorBy = baseRest(function(arrays) {
                        var iteratee = last(arrays);
                        if (isArrayLikeObject(iteratee)) {
                            iteratee = undefined;
                        }
                        return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
                    });

                    /**
                     * This method is like `_.xor` except that it accepts `comparator` which is
                     * invoked to compare elements of `arrays`. The order of result values is
                     * determined by the order they occur in the arrays. The comparator is invoked
                     * with two arguments: (arrVal, othVal).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to inspect.
                     * @param {Function} [comparator] The comparator invoked per element.
                     * @returns {Array} Returns the new array of filtered values.
                     * @example
                     *
                     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
                     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
                     *
                     * _.xorWith(objects, others, _.isEqual);
                     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
                     */
                    var xorWith = baseRest(function(arrays) {
                        var comparator = last(arrays);
                        comparator = typeof comparator == 'function' ? comparator : undefined;
                        return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);
                    });

                    /**
                     * Creates an array of grouped elements, the first of which contains the
                     * first elements of the given arrays, the second of which contains the
                     * second elements of the given arrays, and so on.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to process.
                     * @returns {Array} Returns the new array of grouped elements.
                     * @example
                     *
                     * _.zip(['a', 'b'], [1, 2], [true, false]);
                     * // => [['a', 1, true], ['b', 2, false]]
                     */
                    var zip = baseRest(unzip);

                    /**
                     * This method is like `_.fromPairs` except that it accepts two arrays,
                     * one of property identifiers and one of corresponding values.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.4.0
                     * @category Array
                     * @param {Array} [props=[]] The property identifiers.
                     * @param {Array} [values=[]] The property values.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * _.zipObject(['a', 'b'], [1, 2]);
                     * // => { 'a': 1, 'b': 2 }
                     */
                    function zipObject(props, values) {
                        return baseZipObject(props || [], values || [], assignValue);
                    }

                    /**
                     * This method is like `_.zipObject` except that it supports property paths.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.1.0
                     * @category Array
                     * @param {Array} [props=[]] The property identifiers.
                     * @param {Array} [values=[]] The property values.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
                     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
                     */
                    function zipObjectDeep(props, values) {
                        return baseZipObject(props || [], values || [], baseSet);
                    }

                    /**
                     * This method is like `_.zip` except that it accepts `iteratee` to specify
                     * how grouped values should be combined. The iteratee is invoked with the
                     * elements of each group: (...group).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.8.0
                     * @category Array
                     * @param {...Array} [arrays] The arrays to process.
                     * @param {Function} [iteratee=_.identity] The function to combine
                     *  grouped values.
                     * @returns {Array} Returns the new array of grouped elements.
                     * @example
                     *
                     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
                     *   return a + b + c;
                     * });
                     * // => [111, 222]
                     */
                    var zipWith = baseRest(function(arrays) {
                        var length = arrays.length,
                            iteratee = length > 1 ? arrays[length - 1] : undefined;

                        iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;
                        return unzipWith(arrays, iteratee);
                    });

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates a `lodash` wrapper instance that wraps `value` with explicit method
                     * chain sequences enabled. The result of such sequences must be unwrapped
                     * with `_#value`.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.3.0
                     * @category Seq
                     * @param {*} value The value to wrap.
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'age': 36 },
                     *   { 'user': 'fred',    'age': 40 },
                     *   { 'user': 'pebbles', 'age': 1 }
                     * ];
                     *
                     * var youngest = _
                     *   .chain(users)
                     *   .sortBy('age')
                     *   .map(function(o) {
                     *     return o.user + ' is ' + o.age;
                     *   })
                     *   .head()
                     *   .value();
                     * // => 'pebbles is 1'
                     */
                    function chain(value) {
                        var result = lodash(value);
                        result.__chain__ = true;
                        return result;
                    }

                    /**
                     * This method invokes `interceptor` and returns `value`. The interceptor
                     * is invoked with one argument; (value). The purpose of this method is to
                     * "tap into" a method chain sequence in order to modify intermediate results.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Seq
                     * @param {*} value The value to provide to `interceptor`.
                     * @param {Function} interceptor The function to invoke.
                     * @returns {*} Returns `value`.
                     * @example
                     *
                     * _([1, 2, 3])
                     *  .tap(function(array) {
                     *    // Mutate input array.
                     *    array.pop();
                     *  })
                     *  .reverse()
                     *  .value();
                     * // => [2, 1]
                     */
                    function tap(value, interceptor) {
                        interceptor(value);
                        return value;
                    }

                    /**
                     * This method is like `_.tap` except that it returns the result of `interceptor`.
                     * The purpose of this method is to "pass thru" values replacing intermediate
                     * results in a method chain sequence.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Seq
                     * @param {*} value The value to provide to `interceptor`.
                     * @param {Function} interceptor The function to invoke.
                     * @returns {*} Returns the result of `interceptor`.
                     * @example
                     *
                     * _('  abc  ')
                     *  .chain()
                     *  .trim()
                     *  .thru(function(value) {
                     *    return [value];
                     *  })
                     *  .value();
                     * // => ['abc']
                     */
                    function thru(value, interceptor) {
                        return interceptor(value);
                    }

                    /**
                     * This method is the wrapper version of `_.at`.
                     *
                     * @name at
                     * @memberOf _
                     * @since 1.0.0
                     * @category Seq
                     * @param {...(string|string[])} [paths] The property paths to pick.
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
                     *
                     * _(object).at(['a[0].b.c', 'a[1]']).value();
                     * // => [3, 4]
                     */
                    var wrapperAt = flatRest(function(paths) {
                        var length = paths.length,
                            start = length ? paths[0] : 0,
                            value = this.__wrapped__,
                            interceptor = function(object) { return baseAt(object, paths); };

                        if (length > 1 || this.__actions__.length ||
                            !(value instanceof LazyWrapper) || !isIndex(start)) {
                            return this.thru(interceptor);
                        }
                        value = value.slice(start, +start + (length ? 1 : 0));
                        value.__actions__.push({
                            'func': thru,
                            'args': [interceptor],
                            'thisArg': undefined
                        });
                        return new LodashWrapper(value, this.__chain__).thru(function(array) {
                            if (length && !array.length) {
                                array.push(undefined);
                            }
                            return array;
                        });
                    });

                    /**
                     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
                     *
                     * @name chain
                     * @memberOf _
                     * @since 0.1.0
                     * @category Seq
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney', 'age': 36 },
                     *   { 'user': 'fred',   'age': 40 }
                     * ];
                     *
                     * // A sequence without explicit chaining.
                     * _(users).head();
                     * // => { 'user': 'barney', 'age': 36 }
                     *
                     * // A sequence with explicit chaining.
                     * _(users)
                     *   .chain()
                     *   .head()
                     *   .pick('user')
                     *   .value();
                     * // => { 'user': 'barney' }
                     */
                    function wrapperChain() {
                        return chain(this);
                    }

                    /**
                     * Executes the chain sequence and returns the wrapped result.
                     *
                     * @name commit
                     * @memberOf _
                     * @since 3.2.0
                     * @category Seq
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * var array = [1, 2];
                     * var wrapped = _(array).push(3);
                     *
                     * console.log(array);
                     * // => [1, 2]
                     *
                     * wrapped = wrapped.commit();
                     * console.log(array);
                     * // => [1, 2, 3]
                     *
                     * wrapped.last();
                     * // => 3
                     *
                     * console.log(array);
                     * // => [1, 2, 3]
                     */
                    function wrapperCommit() {
                        return new LodashWrapper(this.value(), this.__chain__);
                    }

                    /**
                     * Gets the next value on a wrapped object following the
                     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
                     *
                     * @name next
                     * @memberOf _
                     * @since 4.0.0
                     * @category Seq
                     * @returns {Object} Returns the next iterator value.
                     * @example
                     *
                     * var wrapped = _([1, 2]);
                     *
                     * wrapped.next();
                     * // => { 'done': false, 'value': 1 }
                     *
                     * wrapped.next();
                     * // => { 'done': false, 'value': 2 }
                     *
                     * wrapped.next();
                     * // => { 'done': true, 'value': undefined }
                     */
                    function wrapperNext() {
                        if (this.__values__ === undefined) {
                            this.__values__ = toArray(this.value());
                        }
                        var done = this.__index__ >= this.__values__.length,
                            value = done ? undefined : this.__values__[this.__index__++];

                        return { 'done': done, 'value': value };
                    }

                    /**
                     * Enables the wrapper to be iterable.
                     *
                     * @name Symbol.iterator
                     * @memberOf _
                     * @since 4.0.0
                     * @category Seq
                     * @returns {Object} Returns the wrapper object.
                     * @example
                     *
                     * var wrapped = _([1, 2]);
                     *
                     * wrapped[Symbol.iterator]() === wrapped;
                     * // => true
                     *
                     * Array.from(wrapped);
                     * // => [1, 2]
                     */
                    function wrapperToIterator() {
                        return this;
                    }

                    /**
                     * Creates a clone of the chain sequence planting `value` as the wrapped value.
                     *
                     * @name plant
                     * @memberOf _
                     * @since 3.2.0
                     * @category Seq
                     * @param {*} value The value to plant.
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * function square(n) {
                     *   return n * n;
                     * }
                     *
                     * var wrapped = _([1, 2]).map(square);
                     * var other = wrapped.plant([3, 4]);
                     *
                     * other.value();
                     * // => [9, 16]
                     *
                     * wrapped.value();
                     * // => [1, 4]
                     */
                    function wrapperPlant(value) {
                        var result,
                            parent = this;

                        while (parent instanceof baseLodash) {
                            var clone = wrapperClone(parent);
                            clone.__index__ = 0;
                            clone.__values__ = undefined;
                            if (result) {
                                previous.__wrapped__ = clone;
                            } else {
                                result = clone;
                            }
                            var previous = clone;
                            parent = parent.__wrapped__;
                        }
                        previous.__wrapped__ = value;
                        return result;
                    }

                    /**
                     * This method is the wrapper version of `_.reverse`.
                     *
                     * **Note:** This method mutates the wrapped array.
                     *
                     * @name reverse
                     * @memberOf _
                     * @since 0.1.0
                     * @category Seq
                     * @returns {Object} Returns the new `lodash` wrapper instance.
                     * @example
                     *
                     * var array = [1, 2, 3];
                     *
                     * _(array).reverse().value()
                     * // => [3, 2, 1]
                     *
                     * console.log(array);
                     * // => [3, 2, 1]
                     */
                    function wrapperReverse() {
                        var value = this.__wrapped__;
                        if (value instanceof LazyWrapper) {
                            var wrapped = value;
                            if (this.__actions__.length) {
                                wrapped = new LazyWrapper(this);
                            }
                            wrapped = wrapped.reverse();
                            wrapped.__actions__.push({
                                'func': thru,
                                'args': [reverse],
                                'thisArg': undefined
                            });
                            return new LodashWrapper(wrapped, this.__chain__);
                        }
                        return this.thru(reverse);
                    }

                    /**
                     * Executes the chain sequence to resolve the unwrapped value.
                     *
                     * @name value
                     * @memberOf _
                     * @since 0.1.0
                     * @alias toJSON, valueOf
                     * @category Seq
                     * @returns {*} Returns the resolved unwrapped value.
                     * @example
                     *
                     * _([1, 2, 3]).value();
                     * // => [1, 2, 3]
                     */
                    function wrapperValue() {
                        return baseWrapperValue(this.__wrapped__, this.__actions__);
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Creates an object composed of keys generated from the results of running
                     * each element of `collection` thru `iteratee`. The corresponding value of
                     * each key is the number of times the key was returned by `iteratee`. The
                     * iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.5.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
                     * @returns {Object} Returns the composed aggregate object.
                     * @example
                     *
                     * _.countBy([6.1, 4.2, 6.3], Math.floor);
                     * // => { '4': 1, '6': 2 }
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.countBy(['one', 'two', 'three'], 'length');
                     * // => { '3': 2, '5': 1 }
                     */
                    var countBy = createAggregator(function(result, value, key) {
                        if (hasOwnProperty.call(result, key)) {
                            ++result[key];
                        } else {
                            baseAssignValue(result, key, 1);
                        }
                    });

                    /**
                     * Checks if `predicate` returns truthy for **all** elements of `collection`.
                     * Iteration is stopped once `predicate` returns falsey. The predicate is
                     * invoked with three arguments: (value, index|key, collection).
                     *
                     * **Note:** This method returns `true` for
                     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
                     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
                     * elements of empty collections.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {boolean} Returns `true` if all elements pass the predicate check,
                     *  else `false`.
                     * @example
                     *
                     * _.every([true, 1, null, 'yes'], Boolean);
                     * // => false
                     *
                     * var users = [
                     *   { 'user': 'barney', 'age': 36, 'active': false },
                     *   { 'user': 'fred',   'age': 40, 'active': false }
                     * ];
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.every(users, { 'user': 'barney', 'active': false });
                     * // => false
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.every(users, ['active', false]);
                     * // => true
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.every(users, 'active');
                     * // => false
                     */
                    function every(collection, predicate, guard) {
                        var func = isArray(collection) ? arrayEvery : baseEvery;
                        if (guard && isIterateeCall(collection, predicate, guard)) {
                            predicate = undefined;
                        }
                        return func(collection, getIteratee(predicate, 3));
                    }

                    /**
                     * Iterates over elements of `collection`, returning an array of all elements
                     * `predicate` returns truthy for. The predicate is invoked with three
                     * arguments: (value, index|key, collection).
                     *
                     * **Note:** Unlike `_.remove`, this method returns a new array.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the new filtered array.
                     * @see _.reject
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney', 'age': 36, 'active': true },
                     *   { 'user': 'fred',   'age': 40, 'active': false }
                     * ];
                     *
                     * _.filter(users, function(o) { return !o.active; });
                     * // => objects for ['fred']
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.filter(users, { 'age': 36, 'active': true });
                     * // => objects for ['barney']
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.filter(users, ['active', false]);
                     * // => objects for ['fred']
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.filter(users, 'active');
                     * // => objects for ['barney']
                     *
                     * // Combining several predicates using `_.overEvery` or `_.overSome`.
                     * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
                     * // => objects for ['fred', 'barney']
                     */
                    function filter(collection, predicate) {
                        var func = isArray(collection) ? arrayFilter : baseFilter;
                        return func(collection, getIteratee(predicate, 3));
                    }

                    /**
                     * Iterates over elements of `collection`, returning the first element
                     * `predicate` returns truthy for. The predicate is invoked with three
                     * arguments: (value, index|key, collection).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to inspect.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @param {number} [fromIndex=0] The index to search from.
                     * @returns {*} Returns the matched element, else `undefined`.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'age': 36, 'active': true },
                     *   { 'user': 'fred',    'age': 40, 'active': false },
                     *   { 'user': 'pebbles', 'age': 1,  'active': true }
                     * ];
                     *
                     * _.find(users, function(o) { return o.age < 40; });
                     * // => object for 'barney'
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.find(users, { 'age': 1, 'active': true });
                     * // => object for 'pebbles'
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.find(users, ['active', false]);
                     * // => object for 'fred'
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.find(users, 'active');
                     * // => object for 'barney'
                     */
                    var find = createFind(findIndex);

                    /**
                     * This method is like `_.find` except that it iterates over elements of
                     * `collection` from right to left.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to inspect.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @param {number} [fromIndex=collection.length-1] The index to search from.
                     * @returns {*} Returns the matched element, else `undefined`.
                     * @example
                     *
                     * _.findLast([1, 2, 3, 4], function(n) {
                     *   return n % 2 == 1;
                     * });
                     * // => 3
                     */
                    var findLast = createFind(findLastIndex);

                    /**
                     * Creates a flattened array of values by running each element in `collection`
                     * thru `iteratee` and flattening the mapped results. The iteratee is invoked
                     * with three arguments: (value, index|key, collection).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the new flattened array.
                     * @example
                     *
                     * function duplicate(n) {
                     *   return [n, n];
                     * }
                     *
                     * _.flatMap([1, 2], duplicate);
                     * // => [1, 1, 2, 2]
                     */
                    function flatMap(collection, iteratee) {
                        return baseFlatten(map(collection, iteratee), 1);
                    }

                    /**
                     * This method is like `_.flatMap` except that it recursively flattens the
                     * mapped results.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.7.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the new flattened array.
                     * @example
                     *
                     * function duplicate(n) {
                     *   return [[[n, n]]];
                     * }
                     *
                     * _.flatMapDeep([1, 2], duplicate);
                     * // => [1, 1, 2, 2]
                     */
                    function flatMapDeep(collection, iteratee) {
                        return baseFlatten(map(collection, iteratee), INFINITY);
                    }

                    /**
                     * This method is like `_.flatMap` except that it recursively flattens the
                     * mapped results up to `depth` times.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.7.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @param {number} [depth=1] The maximum recursion depth.
                     * @returns {Array} Returns the new flattened array.
                     * @example
                     *
                     * function duplicate(n) {
                     *   return [[[n, n]]];
                     * }
                     *
                     * _.flatMapDepth([1, 2], duplicate, 2);
                     * // => [[1, 1], [2, 2]]
                     */
                    function flatMapDepth(collection, iteratee, depth) {
                        depth = depth === undefined ? 1 : toInteger(depth);
                        return baseFlatten(map(collection, iteratee), depth);
                    }

                    /**
                     * Iterates over elements of `collection` and invokes `iteratee` for each element.
                     * The iteratee is invoked with three arguments: (value, index|key, collection).
                     * Iteratee functions may exit iteration early by explicitly returning `false`.
                     *
                     * **Note:** As with other "Collections" methods, objects with a "length"
                     * property are iterated like arrays. To avoid this behavior use `_.forIn`
                     * or `_.forOwn` for object iteration.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @alias each
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Array|Object} Returns `collection`.
                     * @see _.forEachRight
                     * @example
                     *
                     * _.forEach([1, 2], function(value) {
                     *   console.log(value);
                     * });
                     * // => Logs `1` then `2`.
                     *
                     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
                     *   console.log(key);
                     * });
                     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
                     */
                    function forEach(collection, iteratee) {
                        var func = isArray(collection) ? arrayEach : baseEach;
                        return func(collection, getIteratee(iteratee, 3));
                    }

                    /**
                     * This method is like `_.forEach` except that it iterates over elements of
                     * `collection` from right to left.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @alias eachRight
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Array|Object} Returns `collection`.
                     * @see _.forEach
                     * @example
                     *
                     * _.forEachRight([1, 2], function(value) {
                     *   console.log(value);
                     * });
                     * // => Logs `2` then `1`.
                     */
                    function forEachRight(collection, iteratee) {
                        var func = isArray(collection) ? arrayEachRight : baseEachRight;
                        return func(collection, getIteratee(iteratee, 3));
                    }

                    /**
                     * Creates an object composed of keys generated from the results of running
                     * each element of `collection` thru `iteratee`. The order of grouped values
                     * is determined by the order they occur in `collection`. The corresponding
                     * value of each key is an array of elements responsible for generating the
                     * key. The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
                     * @returns {Object} Returns the composed aggregate object.
                     * @example
                     *
                     * _.groupBy([6.1, 4.2, 6.3], Math.floor);
                     * // => { '4': [4.2], '6': [6.1, 6.3] }
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.groupBy(['one', 'two', 'three'], 'length');
                     * // => { '3': ['one', 'two'], '5': ['three'] }
                     */
                    var groupBy = createAggregator(function(result, value, key) {
                        if (hasOwnProperty.call(result, key)) {
                            result[key].push(value);
                        } else {
                            baseAssignValue(result, key, [value]);
                        }
                    });

                    /**
                     * Checks if `value` is in `collection`. If `collection` is a string, it's
                     * checked for a substring of `value`, otherwise
                     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * is used for equality comparisons. If `fromIndex` is negative, it's used as
                     * the offset from the end of `collection`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object|string} collection The collection to inspect.
                     * @param {*} value The value to search for.
                     * @param {number} [fromIndex=0] The index to search from.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
                     * @returns {boolean} Returns `true` if `value` is found, else `false`.
                     * @example
                     *
                     * _.includes([1, 2, 3], 1);
                     * // => true
                     *
                     * _.includes([1, 2, 3], 1, 2);
                     * // => false
                     *
                     * _.includes({ 'a': 1, 'b': 2 }, 1);
                     * // => true
                     *
                     * _.includes('abcd', 'bc');
                     * // => true
                     */
                    function includes(collection, value, fromIndex, guard) {
                        collection = isArrayLike(collection) ? collection : values(collection);
                        fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;

                        var length = collection.length;
                        if (fromIndex < 0) {
                            fromIndex = nativeMax(length + fromIndex, 0);
                        }
                        return isString(collection)
                            ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
                            : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
                    }

                    /**
                     * Invokes the method at `path` of each element in `collection`, returning
                     * an array of the results of each invoked method. Any additional arguments
                     * are provided to each invoked method. If `path` is a function, it's invoked
                     * for, and `this` bound to, each element in `collection`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Array|Function|string} path The path of the method to invoke or
                     *  the function invoked per iteration.
                     * @param {...*} [args] The arguments to invoke each method with.
                     * @returns {Array} Returns the array of results.
                     * @example
                     *
                     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
                     * // => [[1, 5, 7], [1, 2, 3]]
                     *
                     * _.invokeMap([123, 456], String.prototype.split, '');
                     * // => [['1', '2', '3'], ['4', '5', '6']]
                     */
                    var invokeMap = baseRest(function(collection, path, args) {
                        var index = -1,
                            isFunc = typeof path == 'function',
                            result = isArrayLike(collection) ? Array(collection.length) : [];

                        baseEach(collection, function(value) {
                            result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
                        });
                        return result;
                    });

                    /**
                     * Creates an object composed of keys generated from the results of running
                     * each element of `collection` thru `iteratee`. The corresponding value of
                     * each key is the last element responsible for generating the key. The
                     * iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
                     * @returns {Object} Returns the composed aggregate object.
                     * @example
                     *
                     * var array = [
                     *   { 'dir': 'left', 'code': 97 },
                     *   { 'dir': 'right', 'code': 100 }
                     * ];
                     *
                     * _.keyBy(array, function(o) {
                     *   return String.fromCharCode(o.code);
                     * });
                     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
                     *
                     * _.keyBy(array, 'dir');
                     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
                     */
                    var keyBy = createAggregator(function(result, value, key) {
                        baseAssignValue(result, key, value);
                    });

                    /**
                     * Creates an array of values by running each element in `collection` thru
                     * `iteratee`. The iteratee is invoked with three arguments:
                     * (value, index|key, collection).
                     *
                     * Many lodash methods are guarded to work as iteratees for methods like
                     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
                     *
                     * The guarded methods are:
                     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
                     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
                     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
                     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the new mapped array.
                     * @example
                     *
                     * function square(n) {
                     *   return n * n;
                     * }
                     *
                     * _.map([4, 8], square);
                     * // => [16, 64]
                     *
                     * _.map({ 'a': 4, 'b': 8 }, square);
                     * // => [16, 64] (iteration order is not guaranteed)
                     *
                     * var users = [
                     *   { 'user': 'barney' },
                     *   { 'user': 'fred' }
                     * ];
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.map(users, 'user');
                     * // => ['barney', 'fred']
                     */
                    function map(collection, iteratee) {
                        var func = isArray(collection) ? arrayMap : baseMap;
                        return func(collection, getIteratee(iteratee, 3));
                    }

                    /**
                     * This method is like `_.sortBy` except that it allows specifying the sort
                     * orders of the iteratees to sort by. If `orders` is unspecified, all values
                     * are sorted in ascending order. Otherwise, specify an order of "desc" for
                     * descending or "asc" for ascending sort order of corresponding values.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
                     *  The iteratees to sort by.
                     * @param {string[]} [orders] The sort orders of `iteratees`.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
                     * @returns {Array} Returns the new sorted array.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'fred',   'age': 48 },
                     *   { 'user': 'barney', 'age': 34 },
                     *   { 'user': 'fred',   'age': 40 },
                     *   { 'user': 'barney', 'age': 36 }
                     * ];
                     *
                     * // Sort by `user` in ascending order and by `age` in descending order.
                     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
                     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
                     */
                    function orderBy(collection, iteratees, orders, guard) {
                        if (collection == null) {
                            return [];
                        }
                        if (!isArray(iteratees)) {
                            iteratees = iteratees == null ? [] : [iteratees];
                        }
                        orders = guard ? undefined : orders;
                        if (!isArray(orders)) {
                            orders = orders == null ? [] : [orders];
                        }
                        return baseOrderBy(collection, iteratees, orders);
                    }

                    /**
                     * Creates an array of elements split into two groups, the first of which
                     * contains elements `predicate` returns truthy for, the second of which
                     * contains elements `predicate` returns falsey for. The predicate is
                     * invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the array of grouped elements.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney',  'age': 36, 'active': false },
                     *   { 'user': 'fred',    'age': 40, 'active': true },
                     *   { 'user': 'pebbles', 'age': 1,  'active': false }
                     * ];
                     *
                     * _.partition(users, function(o) { return o.active; });
                     * // => objects for [['fred'], ['barney', 'pebbles']]
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.partition(users, { 'age': 1, 'active': false });
                     * // => objects for [['pebbles'], ['barney', 'fred']]
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.partition(users, ['active', false]);
                     * // => objects for [['barney', 'pebbles'], ['fred']]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.partition(users, 'active');
                     * // => objects for [['fred'], ['barney', 'pebbles']]
                     */
                    var partition = createAggregator(function(result, value, key) {
                        result[key ? 0 : 1].push(value);
                    }, function() { return [[], []]; });

                    /**
                     * Reduces `collection` to a value which is the accumulated result of running
                     * each element in `collection` thru `iteratee`, where each successive
                     * invocation is supplied the return value of the previous. If `accumulator`
                     * is not given, the first element of `collection` is used as the initial
                     * value. The iteratee is invoked with four arguments:
                     * (accumulator, value, index|key, collection).
                     *
                     * Many lodash methods are guarded to work as iteratees for methods like
                     * `_.reduce`, `_.reduceRight`, and `_.transform`.
                     *
                     * The guarded methods are:
                     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
                     * and `sortBy`
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @param {*} [accumulator] The initial value.
                     * @returns {*} Returns the accumulated value.
                     * @see _.reduceRight
                     * @example
                     *
                     * _.reduce([1, 2], function(sum, n) {
                     *   return sum + n;
                     * }, 0);
                     * // => 3
                     *
                     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
                     *   (result[value] || (result[value] = [])).push(key);
                     *   return result;
                     * }, {});
                     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
                     */
                    function reduce(collection, iteratee, accumulator) {
                        var func = isArray(collection) ? arrayReduce : baseReduce,
                            initAccum = arguments.length < 3;

                        return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
                    }

                    /**
                     * This method is like `_.reduce` except that it iterates over elements of
                     * `collection` from right to left.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @param {*} [accumulator] The initial value.
                     * @returns {*} Returns the accumulated value.
                     * @see _.reduce
                     * @example
                     *
                     * var array = [[0, 1], [2, 3], [4, 5]];
                     *
                     * _.reduceRight(array, function(flattened, other) {
                     *   return flattened.concat(other);
                     * }, []);
                     * // => [4, 5, 2, 3, 0, 1]
                     */
                    function reduceRight(collection, iteratee, accumulator) {
                        var func = isArray(collection) ? arrayReduceRight : baseReduce,
                            initAccum = arguments.length < 3;

                        return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
                    }

                    /**
                     * The opposite of `_.filter`; this method returns the elements of `collection`
                     * that `predicate` does **not** return truthy for.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the new filtered array.
                     * @see _.filter
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney', 'age': 36, 'active': false },
                     *   { 'user': 'fred',   'age': 40, 'active': true }
                     * ];
                     *
                     * _.reject(users, function(o) { return !o.active; });
                     * // => objects for ['fred']
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.reject(users, { 'age': 40, 'active': true });
                     * // => objects for ['barney']
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.reject(users, ['active', false]);
                     * // => objects for ['fred']
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.reject(users, 'active');
                     * // => objects for ['barney']
                     */
                    function reject(collection, predicate) {
                        var func = isArray(collection) ? arrayFilter : baseFilter;
                        return func(collection, negate(getIteratee(predicate, 3)));
                    }

                    /**
                     * Gets a random element from `collection`.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to sample.
                     * @returns {*} Returns the random element.
                     * @example
                     *
                     * _.sample([1, 2, 3, 4]);
                     * // => 2
                     */
                    function sample(collection) {
                        var func = isArray(collection) ? arraySample : baseSample;
                        return func(collection);
                    }

                    /**
                     * Gets `n` random elements at unique keys from `collection` up to the
                     * size of `collection`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to sample.
                     * @param {number} [n=1] The number of elements to sample.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the random elements.
                     * @example
                     *
                     * _.sampleSize([1, 2, 3], 2);
                     * // => [3, 1]
                     *
                     * _.sampleSize([1, 2, 3], 4);
                     * // => [2, 3, 1]
                     */
                    function sampleSize(collection, n, guard) {
                        if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
                            n = 1;
                        } else {
                            n = toInteger(n);
                        }
                        var func = isArray(collection) ? arraySampleSize : baseSampleSize;
                        return func(collection, n);
                    }

                    /**
                     * Creates an array of shuffled values, using a version of the
                     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to shuffle.
                     * @returns {Array} Returns the new shuffled array.
                     * @example
                     *
                     * _.shuffle([1, 2, 3, 4]);
                     * // => [4, 1, 3, 2]
                     */
                    function shuffle(collection) {
                        var func = isArray(collection) ? arrayShuffle : baseShuffle;
                        return func(collection);
                    }

                    /**
                     * Gets the size of `collection` by returning its length for array-like
                     * values or the number of own enumerable string keyed properties for objects.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object|string} collection The collection to inspect.
                     * @returns {number} Returns the collection size.
                     * @example
                     *
                     * _.size([1, 2, 3]);
                     * // => 3
                     *
                     * _.size({ 'a': 1, 'b': 2 });
                     * // => 2
                     *
                     * _.size('pebbles');
                     * // => 7
                     */
                    function size(collection) {
                        if (collection == null) {
                            return 0;
                        }
                        if (isArrayLike(collection)) {
                            return isString(collection) ? stringSize(collection) : collection.length;
                        }
                        var tag = getTag(collection);
                        if (tag == mapTag || tag == setTag) {
                            return collection.size;
                        }
                        return baseKeys(collection).length;
                    }

                    /**
                     * Checks if `predicate` returns truthy for **any** element of `collection`.
                     * Iteration is stopped once `predicate` returns truthy. The predicate is
                     * invoked with three arguments: (value, index|key, collection).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {boolean} Returns `true` if any element passes the predicate check,
                     *  else `false`.
                     * @example
                     *
                     * _.some([null, 0, 'yes', false], Boolean);
                     * // => true
                     *
                     * var users = [
                     *   { 'user': 'barney', 'active': true },
                     *   { 'user': 'fred',   'active': false }
                     * ];
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.some(users, { 'user': 'barney', 'active': false });
                     * // => false
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.some(users, ['active', false]);
                     * // => true
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.some(users, 'active');
                     * // => true
                     */
                    function some(collection, predicate, guard) {
                        var func = isArray(collection) ? arraySome : baseSome;
                        if (guard && isIterateeCall(collection, predicate, guard)) {
                            predicate = undefined;
                        }
                        return func(collection, getIteratee(predicate, 3));
                    }

                    /**
                     * Creates an array of elements, sorted in ascending order by the results of
                     * running each element in a collection thru each iteratee. This method
                     * performs a stable sort, that is, it preserves the original sort order of
                     * equal elements. The iteratees are invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Collection
                     * @param {Array|Object} collection The collection to iterate over.
                     * @param {...(Function|Function[])} [iteratees=[_.identity]]
                     *  The iteratees to sort by.
                     * @returns {Array} Returns the new sorted array.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'fred',   'age': 48 },
                     *   { 'user': 'barney', 'age': 36 },
                     *   { 'user': 'fred',   'age': 30 },
                     *   { 'user': 'barney', 'age': 34 }
                     * ];
                     *
                     * _.sortBy(users, [function(o) { return o.user; }]);
                     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
                     *
                     * _.sortBy(users, ['user', 'age']);
                     * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
                     */
                    var sortBy = baseRest(function(collection, iteratees) {
                        if (collection == null) {
                            return [];
                        }
                        var length = iteratees.length;
                        if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
                            iteratees = [];
                        } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
                            iteratees = [iteratees[0]];
                        }
                        return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
                    });

                    /*------------------------------------------------------------------------*/

                    /**
                     * Gets the timestamp of the number of milliseconds that have elapsed since
                     * the Unix epoch (1 January 1970 00:00:00 UTC).
                     *
                     * @static
                     * @memberOf _
                     * @since 2.4.0
                     * @category Date
                     * @returns {number} Returns the timestamp.
                     * @example
                     *
                     * _.defer(function(stamp) {
                     *   console.log(_.now() - stamp);
                     * }, _.now());
                     * // => Logs the number of milliseconds it took for the deferred invocation.
                     */
                    var now = ctxNow || function() {
                        return root.Date.now();
                    };

                    /*------------------------------------------------------------------------*/

                    /**
                     * The opposite of `_.before`; this method creates a function that invokes
                     * `func` once it's called `n` or more times.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {number} n The number of calls before `func` is invoked.
                     * @param {Function} func The function to restrict.
                     * @returns {Function} Returns the new restricted function.
                     * @example
                     *
                     * var saves = ['profile', 'settings'];
                     *
                     * var done = _.after(saves.length, function() {
                     *   console.log('done saving!');
                     * });
                     *
                     * _.forEach(saves, function(type) {
                     *   asyncSave({ 'type': type, 'complete': done });
                     * });
                     * // => Logs 'done saving!' after the two async saves have completed.
                     */
                    function after(n, func) {
                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        n = toInteger(n);
                        return function() {
                            if (--n < 1) {
                                return func.apply(this, arguments);
                            }
                        };
                    }

                    /**
                     * Creates a function that invokes `func`, with up to `n` arguments,
                     * ignoring any additional arguments.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Function
                     * @param {Function} func The function to cap arguments for.
                     * @param {number} [n=func.length] The arity cap.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Function} Returns the new capped function.
                     * @example
                     *
                     * _.map(['6', '8', '10'], _.ary(parseInt, 1));
                     * // => [6, 8, 10]
                     */
                    function ary(func, n, guard) {
                        n = guard ? undefined : n;
                        n = (func && n == null) ? func.length : n;
                        return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
                    }

                    /**
                     * Creates a function that invokes `func`, with the `this` binding and arguments
                     * of the created function, while it's called less than `n` times. Subsequent
                     * calls to the created function return the result of the last `func` invocation.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Function
                     * @param {number} n The number of calls at which `func` is no longer invoked.
                     * @param {Function} func The function to restrict.
                     * @returns {Function} Returns the new restricted function.
                     * @example
                     *
                     * jQuery(element).on('click', _.before(5, addContactToList));
                     * // => Allows adding up to 4 contacts to the list.
                     */
                    function before(n, func) {
                        var result;
                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        n = toInteger(n);
                        return function() {
                            if (--n > 0) {
                                result = func.apply(this, arguments);
                            }
                            if (n <= 1) {
                                func = undefined;
                            }
                            return result;
                        };
                    }

                    /**
                     * Creates a function that invokes `func` with the `this` binding of `thisArg`
                     * and `partials` prepended to the arguments it receives.
                     *
                     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
                     * may be used as a placeholder for partially applied arguments.
                     *
                     * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
                     * property of bound functions.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to bind.
                     * @param {*} thisArg The `this` binding of `func`.
                     * @param {...*} [partials] The arguments to be partially applied.
                     * @returns {Function} Returns the new bound function.
                     * @example
                     *
                     * function greet(greeting, punctuation) {
                     *   return greeting + ' ' + this.user + punctuation;
                     * }
                     *
                     * var object = { 'user': 'fred' };
                     *
                     * var bound = _.bind(greet, object, 'hi');
                     * bound('!');
                     * // => 'hi fred!'
                     *
                     * // Bound with placeholders.
                     * var bound = _.bind(greet, object, _, '!');
                     * bound('hi');
                     * // => 'hi fred!'
                     */
                    var bind = baseRest(function(func, thisArg, partials) {
                        var bitmask = WRAP_BIND_FLAG;
                        if (partials.length) {
                            var holders = replaceHolders(partials, getHolder(bind));
                            bitmask |= WRAP_PARTIAL_FLAG;
                        }
                        return createWrap(func, bitmask, thisArg, partials, holders);
                    });

                    /**
                     * Creates a function that invokes the method at `object[key]` with `partials`
                     * prepended to the arguments it receives.
                     *
                     * This method differs from `_.bind` by allowing bound functions to reference
                     * methods that may be redefined or don't yet exist. See
                     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
                     * for more details.
                     *
                     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
                     * builds, may be used as a placeholder for partially applied arguments.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.10.0
                     * @category Function
                     * @param {Object} object The object to invoke the method on.
                     * @param {string} key The key of the method.
                     * @param {...*} [partials] The arguments to be partially applied.
                     * @returns {Function} Returns the new bound function.
                     * @example
                     *
                     * var object = {
                     *   'user': 'fred',
                     *   'greet': function(greeting, punctuation) {
                     *     return greeting + ' ' + this.user + punctuation;
                     *   }
                     * };
                     *
                     * var bound = _.bindKey(object, 'greet', 'hi');
                     * bound('!');
                     * // => 'hi fred!'
                     *
                     * object.greet = function(greeting, punctuation) {
                     *   return greeting + 'ya ' + this.user + punctuation;
                     * };
                     *
                     * bound('!');
                     * // => 'hiya fred!'
                     *
                     * // Bound with placeholders.
                     * var bound = _.bindKey(object, 'greet', _, '!');
                     * bound('hi');
                     * // => 'hiya fred!'
                     */
                    var bindKey = baseRest(function(object, key, partials) {
                        var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
                        if (partials.length) {
                            var holders = replaceHolders(partials, getHolder(bindKey));
                            bitmask |= WRAP_PARTIAL_FLAG;
                        }
                        return createWrap(key, bitmask, object, partials, holders);
                    });

                    /**
                     * Creates a function that accepts arguments of `func` and either invokes
                     * `func` returning its result, if at least `arity` number of arguments have
                     * been provided, or returns a function that accepts the remaining `func`
                     * arguments, and so on. The arity of `func` may be specified if `func.length`
                     * is not sufficient.
                     *
                     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
                     * may be used as a placeholder for provided arguments.
                     *
                     * **Note:** This method doesn't set the "length" property of curried functions.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Function
                     * @param {Function} func The function to curry.
                     * @param {number} [arity=func.length] The arity of `func`.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Function} Returns the new curried function.
                     * @example
                     *
                     * var abc = function(a, b, c) {
                     *   return [a, b, c];
                     * };
                     *
                     * var curried = _.curry(abc);
                     *
                     * curried(1)(2)(3);
                     * // => [1, 2, 3]
                     *
                     * curried(1, 2)(3);
                     * // => [1, 2, 3]
                     *
                     * curried(1, 2, 3);
                     * // => [1, 2, 3]
                     *
                     * // Curried with placeholders.
                     * curried(1)(_, 3)(2);
                     * // => [1, 2, 3]
                     */
                    function curry(func, arity, guard) {
                        arity = guard ? undefined : arity;
                        var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
                        result.placeholder = curry.placeholder;
                        return result;
                    }

                    /**
                     * This method is like `_.curry` except that arguments are applied to `func`
                     * in the manner of `_.partialRight` instead of `_.partial`.
                     *
                     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
                     * builds, may be used as a placeholder for provided arguments.
                     *
                     * **Note:** This method doesn't set the "length" property of curried functions.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Function
                     * @param {Function} func The function to curry.
                     * @param {number} [arity=func.length] The arity of `func`.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Function} Returns the new curried function.
                     * @example
                     *
                     * var abc = function(a, b, c) {
                     *   return [a, b, c];
                     * };
                     *
                     * var curried = _.curryRight(abc);
                     *
                     * curried(3)(2)(1);
                     * // => [1, 2, 3]
                     *
                     * curried(2, 3)(1);
                     * // => [1, 2, 3]
                     *
                     * curried(1, 2, 3);
                     * // => [1, 2, 3]
                     *
                     * // Curried with placeholders.
                     * curried(3)(1, _)(2);
                     * // => [1, 2, 3]
                     */
                    function curryRight(func, arity, guard) {
                        arity = guard ? undefined : arity;
                        var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
                        result.placeholder = curryRight.placeholder;
                        return result;
                    }

                    /**
                     * Creates a debounced function that delays invoking `func` until after `wait`
                     * milliseconds have elapsed since the last time the debounced function was
                     * invoked. The debounced function comes with a `cancel` method to cancel
                     * delayed `func` invocations and a `flush` method to immediately invoke them.
                     * Provide `options` to indicate whether `func` should be invoked on the
                     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
                     * with the last arguments provided to the debounced function. Subsequent
                     * calls to the debounced function return the result of the last `func`
                     * invocation.
                     *
                     * **Note:** If `leading` and `trailing` options are `true`, `func` is
                     * invoked on the trailing edge of the timeout only if the debounced function
                     * is invoked more than once during the `wait` timeout.
                     *
                     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
                     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
                     *
                     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
                     * for details over the differences between `_.debounce` and `_.throttle`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to debounce.
                     * @param {number} [wait=0] The number of milliseconds to delay.
                     * @param {Object} [options={}] The options object.
                     * @param {boolean} [options.leading=false]
                     *  Specify invoking on the leading edge of the timeout.
                     * @param {number} [options.maxWait]
                     *  The maximum time `func` is allowed to be delayed before it's invoked.
                     * @param {boolean} [options.trailing=true]
                     *  Specify invoking on the trailing edge of the timeout.
                     * @returns {Function} Returns the new debounced function.
                     * @example
                     *
                     * // Avoid costly calculations while the window size is in flux.
                     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
                     *
                     * // Invoke `sendMail` when clicked, debouncing subsequent calls.
                     * jQuery(element).on('click', _.debounce(sendMail, 300, {
                     *   'leading': true,
                     *   'trailing': false
                     * }));
                     *
                     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
                     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
                     * var source = new EventSource('/stream');
                     * jQuery(source).on('message', debounced);
                     *
                     * // Cancel the trailing debounced invocation.
                     * jQuery(window).on('popstate', debounced.cancel);
                     */
                    function debounce(func, wait, options) {
                        var lastArgs,
                            lastThis,
                            maxWait,
                            result,
                            timerId,
                            lastCallTime,
                            lastInvokeTime = 0,
                            leading = false,
                            maxing = false,
                            trailing = true;

                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        wait = toNumber(wait) || 0;
                        if (isObject(options)) {
                            leading = !!options.leading;
                            maxing = 'maxWait' in options;
                            maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
                            trailing = 'trailing' in options ? !!options.trailing : trailing;
                        }

                        function invokeFunc(time) {
                            var args = lastArgs,
                                thisArg = lastThis;

                            lastArgs = lastThis = undefined;
                            lastInvokeTime = time;
                            result = func.apply(thisArg, args);
                            return result;
                        }

                        function leadingEdge(time) {
                            // Reset any `maxWait` timer.
                            lastInvokeTime = time;
                            // Start the timer for the trailing edge.
                            timerId = setTimeout(timerExpired, wait);
                            // Invoke the leading edge.
                            return leading ? invokeFunc(time) : result;
                        }

                        function remainingWait(time) {
                            var timeSinceLastCall = time - lastCallTime,
                                timeSinceLastInvoke = time - lastInvokeTime,
                                timeWaiting = wait - timeSinceLastCall;

                            return maxing
                                ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
                                : timeWaiting;
                        }

                        function shouldInvoke(time) {
                            var timeSinceLastCall = time - lastCallTime,
                                timeSinceLastInvoke = time - lastInvokeTime;

                            // Either this is the first call, activity has stopped and we're at the
                            // trailing edge, the system time has gone backwards and we're treating
                            // it as the trailing edge, or we've hit the `maxWait` limit.
                            return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
                                (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
                        }

                        function timerExpired() {
                            var time = now();
                            if (shouldInvoke(time)) {
                                return trailingEdge(time);
                            }
                            // Restart the timer.
                            timerId = setTimeout(timerExpired, remainingWait(time));
                        }

                        function trailingEdge(time) {
                            timerId = undefined;

                            // Only invoke if we have `lastArgs` which means `func` has been
                            // debounced at least once.
                            if (trailing && lastArgs) {
                                return invokeFunc(time);
                            }
                            lastArgs = lastThis = undefined;
                            return result;
                        }

                        function cancel() {
                            if (timerId !== undefined) {
                                clearTimeout(timerId);
                            }
                            lastInvokeTime = 0;
                            lastArgs = lastCallTime = lastThis = timerId = undefined;
                        }

                        function flush() {
                            return timerId === undefined ? result : trailingEdge(now());
                        }

                        function debounced() {
                            var time = now(),
                                isInvoking = shouldInvoke(time);

                            lastArgs = arguments;
                            lastThis = this;
                            lastCallTime = time;

                            if (isInvoking) {
                                if (timerId === undefined) {
                                    return leadingEdge(lastCallTime);
                                }
                                if (maxing) {
                                    // Handle invocations in a tight loop.
                                    clearTimeout(timerId);
                                    timerId = setTimeout(timerExpired, wait);
                                    return invokeFunc(lastCallTime);
                                }
                            }
                            if (timerId === undefined) {
                                timerId = setTimeout(timerExpired, wait);
                            }
                            return result;
                        }
                        debounced.cancel = cancel;
                        debounced.flush = flush;
                        return debounced;
                    }

                    /**
                     * Defers invoking the `func` until the current call stack has cleared. Any
                     * additional arguments are provided to `func` when it's invoked.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to defer.
                     * @param {...*} [args] The arguments to invoke `func` with.
                     * @returns {number} Returns the timer id.
                     * @example
                     *
                     * _.defer(function(text) {
                     *   console.log(text);
                     * }, 'deferred');
                     * // => Logs 'deferred' after one millisecond.
                     */
                    var defer = baseRest(function(func, args) {
                        return baseDelay(func, 1, args);
                    });

                    /**
                     * Invokes `func` after `wait` milliseconds. Any additional arguments are
                     * provided to `func` when it's invoked.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to delay.
                     * @param {number} wait The number of milliseconds to delay invocation.
                     * @param {...*} [args] The arguments to invoke `func` with.
                     * @returns {number} Returns the timer id.
                     * @example
                     *
                     * _.delay(function(text) {
                     *   console.log(text);
                     * }, 1000, 'later');
                     * // => Logs 'later' after one second.
                     */
                    var delay = baseRest(function(func, wait, args) {
                        return baseDelay(func, toNumber(wait) || 0, args);
                    });

                    /**
                     * Creates a function that invokes `func` with arguments reversed.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Function
                     * @param {Function} func The function to flip arguments for.
                     * @returns {Function} Returns the new flipped function.
                     * @example
                     *
                     * var flipped = _.flip(function() {
                     *   return _.toArray(arguments);
                     * });
                     *
                     * flipped('a', 'b', 'c', 'd');
                     * // => ['d', 'c', 'b', 'a']
                     */
                    function flip(func) {
                        return createWrap(func, WRAP_FLIP_FLAG);
                    }

                    /**
                     * Creates a function that memoizes the result of `func`. If `resolver` is
                     * provided, it determines the cache key for storing the result based on the
                     * arguments provided to the memoized function. By default, the first argument
                     * provided to the memoized function is used as the map cache key. The `func`
                     * is invoked with the `this` binding of the memoized function.
                     *
                     * **Note:** The cache is exposed as the `cache` property on the memoized
                     * function. Its creation may be customized by replacing the `_.memoize.Cache`
                     * constructor with one whose instances implement the
                     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
                     * method interface of `clear`, `delete`, `get`, `has`, and `set`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to have its output memoized.
                     * @param {Function} [resolver] The function to resolve the cache key.
                     * @returns {Function} Returns the new memoized function.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': 2 };
                     * var other = { 'c': 3, 'd': 4 };
                     *
                     * var values = _.memoize(_.values);
                     * values(object);
                     * // => [1, 2]
                     *
                     * values(other);
                     * // => [3, 4]
                     *
                     * object.a = 2;
                     * values(object);
                     * // => [1, 2]
                     *
                     * // Modify the result cache.
                     * values.cache.set(object, ['a', 'b']);
                     * values(object);
                     * // => ['a', 'b']
                     *
                     * // Replace `_.memoize.Cache`.
                     * _.memoize.Cache = WeakMap;
                     */
                    function memoize(func, resolver) {
                        if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        var memoized = function() {
                            var args = arguments,
                                key = resolver ? resolver.apply(this, args) : args[0],
                                cache = memoized.cache;

                            if (cache.has(key)) {
                                return cache.get(key);
                            }
                            var result = func.apply(this, args);
                            memoized.cache = cache.set(key, result) || cache;
                            return result;
                        };
                        memoized.cache = new (memoize.Cache || MapCache);
                        return memoized;
                    }

                    // Expose `MapCache`.
                    memoize.Cache = MapCache;

                    /**
                     * Creates a function that negates the result of the predicate `func`. The
                     * `func` predicate is invoked with the `this` binding and arguments of the
                     * created function.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Function
                     * @param {Function} predicate The predicate to negate.
                     * @returns {Function} Returns the new negated function.
                     * @example
                     *
                     * function isEven(n) {
                     *   return n % 2 == 0;
                     * }
                     *
                     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
                     * // => [1, 3, 5]
                     */
                    function negate(predicate) {
                        if (typeof predicate != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        return function() {
                            var args = arguments;
                            switch (args.length) {
                                case 0: return !predicate.call(this);
                                case 1: return !predicate.call(this, args[0]);
                                case 2: return !predicate.call(this, args[0], args[1]);
                                case 3: return !predicate.call(this, args[0], args[1], args[2]);
                            }
                            return !predicate.apply(this, args);
                        };
                    }

                    /**
                     * Creates a function that is restricted to invoking `func` once. Repeat calls
                     * to the function return the value of the first invocation. The `func` is
                     * invoked with the `this` binding and arguments of the created function.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to restrict.
                     * @returns {Function} Returns the new restricted function.
                     * @example
                     *
                     * var initialize = _.once(createApplication);
                     * initialize();
                     * initialize();
                     * // => `createApplication` is invoked once
                     */
                    function once(func) {
                        return before(2, func);
                    }

                    /**
                     * Creates a function that invokes `func` with its arguments transformed.
                     *
                     * @static
                     * @since 4.0.0
                     * @memberOf _
                     * @category Function
                     * @param {Function} func The function to wrap.
                     * @param {...(Function|Function[])} [transforms=[_.identity]]
                     *  The argument transforms.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * function doubled(n) {
                     *   return n * 2;
                     * }
                     *
                     * function square(n) {
                     *   return n * n;
                     * }
                     *
                     * var func = _.overArgs(function(x, y) {
                     *   return [x, y];
                     * }, [square, doubled]);
                     *
                     * func(9, 3);
                     * // => [81, 6]
                     *
                     * func(10, 5);
                     * // => [100, 10]
                     */
                    var overArgs = castRest(function(func, transforms) {
                        transforms = (transforms.length == 1 && isArray(transforms[0]))
                            ? arrayMap(transforms[0], baseUnary(getIteratee()))
                            : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));

                        var funcsLength = transforms.length;
                        return baseRest(function(args) {
                            var index = -1,
                                length = nativeMin(args.length, funcsLength);

                            while (++index < length) {
                                args[index] = transforms[index].call(this, args[index]);
                            }
                            return apply(func, this, args);
                        });
                    });

                    /**
                     * Creates a function that invokes `func` with `partials` prepended to the
                     * arguments it receives. This method is like `_.bind` except it does **not**
                     * alter the `this` binding.
                     *
                     * The `_.partial.placeholder` value, which defaults to `_` in monolithic
                     * builds, may be used as a placeholder for partially applied arguments.
                     *
                     * **Note:** This method doesn't set the "length" property of partially
                     * applied functions.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.2.0
                     * @category Function
                     * @param {Function} func The function to partially apply arguments to.
                     * @param {...*} [partials] The arguments to be partially applied.
                     * @returns {Function} Returns the new partially applied function.
                     * @example
                     *
                     * function greet(greeting, name) {
                     *   return greeting + ' ' + name;
                     * }
                     *
                     * var sayHelloTo = _.partial(greet, 'hello');
                     * sayHelloTo('fred');
                     * // => 'hello fred'
                     *
                     * // Partially applied with placeholders.
                     * var greetFred = _.partial(greet, _, 'fred');
                     * greetFred('hi');
                     * // => 'hi fred'
                     */
                    var partial = baseRest(function(func, partials) {
                        var holders = replaceHolders(partials, getHolder(partial));
                        return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
                    });

                    /**
                     * This method is like `_.partial` except that partially applied arguments
                     * are appended to the arguments it receives.
                     *
                     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
                     * builds, may be used as a placeholder for partially applied arguments.
                     *
                     * **Note:** This method doesn't set the "length" property of partially
                     * applied functions.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.0.0
                     * @category Function
                     * @param {Function} func The function to partially apply arguments to.
                     * @param {...*} [partials] The arguments to be partially applied.
                     * @returns {Function} Returns the new partially applied function.
                     * @example
                     *
                     * function greet(greeting, name) {
                     *   return greeting + ' ' + name;
                     * }
                     *
                     * var greetFred = _.partialRight(greet, 'fred');
                     * greetFred('hi');
                     * // => 'hi fred'
                     *
                     * // Partially applied with placeholders.
                     * var sayHelloTo = _.partialRight(greet, 'hello', _);
                     * sayHelloTo('fred');
                     * // => 'hello fred'
                     */
                    var partialRight = baseRest(function(func, partials) {
                        var holders = replaceHolders(partials, getHolder(partialRight));
                        return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);
                    });

                    /**
                     * Creates a function that invokes `func` with arguments arranged according
                     * to the specified `indexes` where the argument value at the first index is
                     * provided as the first argument, the argument value at the second index is
                     * provided as the second argument, and so on.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Function
                     * @param {Function} func The function to rearrange arguments for.
                     * @param {...(number|number[])} indexes The arranged argument indexes.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var rearged = _.rearg(function(a, b, c) {
                     *   return [a, b, c];
                     * }, [2, 0, 1]);
                     *
                     * rearged('b', 'c', 'a')
                     * // => ['a', 'b', 'c']
                     */
                    var rearg = flatRest(function(func, indexes) {
                        return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
                    });

                    /**
                     * Creates a function that invokes `func` with the `this` binding of the
                     * created function and arguments from `start` and beyond provided as
                     * an array.
                     *
                     * **Note:** This method is based on the
                     * [rest parameter](https://mdn.io/rest_parameters).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Function
                     * @param {Function} func The function to apply a rest parameter to.
                     * @param {number} [start=func.length-1] The start position of the rest parameter.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var say = _.rest(function(what, names) {
                     *   return what + ' ' + _.initial(names).join(', ') +
                     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
                     * });
                     *
                     * say('hello', 'fred', 'barney', 'pebbles');
                     * // => 'hello fred, barney, & pebbles'
                     */
                    function rest(func, start) {
                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        start = start === undefined ? start : toInteger(start);
                        return baseRest(func, start);
                    }

                    /**
                     * Creates a function that invokes `func` with the `this` binding of the
                     * create function and an array of arguments much like
                     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
                     *
                     * **Note:** This method is based on the
                     * [spread operator](https://mdn.io/spread_operator).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.2.0
                     * @category Function
                     * @param {Function} func The function to spread arguments over.
                     * @param {number} [start=0] The start position of the spread.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var say = _.spread(function(who, what) {
                     *   return who + ' says ' + what;
                     * });
                     *
                     * say(['fred', 'hello']);
                     * // => 'fred says hello'
                     *
                     * var numbers = Promise.all([
                     *   Promise.resolve(40),
                     *   Promise.resolve(36)
                     * ]);
                     *
                     * numbers.then(_.spread(function(x, y) {
                     *   return x + y;
                     * }));
                     * // => a Promise of 76
                     */
                    function spread(func, start) {
                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        start = start == null ? 0 : nativeMax(toInteger(start), 0);
                        return baseRest(function(args) {
                            var array = args[start],
                                otherArgs = castSlice(args, 0, start);

                            if (array) {
                                arrayPush(otherArgs, array);
                            }
                            return apply(func, this, otherArgs);
                        });
                    }

                    /**
                     * Creates a throttled function that only invokes `func` at most once per
                     * every `wait` milliseconds. The throttled function comes with a `cancel`
                     * method to cancel delayed `func` invocations and a `flush` method to
                     * immediately invoke them. Provide `options` to indicate whether `func`
                     * should be invoked on the leading and/or trailing edge of the `wait`
                     * timeout. The `func` is invoked with the last arguments provided to the
                     * throttled function. Subsequent calls to the throttled function return the
                     * result of the last `func` invocation.
                     *
                     * **Note:** If `leading` and `trailing` options are `true`, `func` is
                     * invoked on the trailing edge of the timeout only if the throttled function
                     * is invoked more than once during the `wait` timeout.
                     *
                     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
                     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
                     *
                     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
                     * for details over the differences between `_.throttle` and `_.debounce`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {Function} func The function to throttle.
                     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
                     * @param {Object} [options={}] The options object.
                     * @param {boolean} [options.leading=true]
                     *  Specify invoking on the leading edge of the timeout.
                     * @param {boolean} [options.trailing=true]
                     *  Specify invoking on the trailing edge of the timeout.
                     * @returns {Function} Returns the new throttled function.
                     * @example
                     *
                     * // Avoid excessively updating the position while scrolling.
                     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
                     *
                     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
                     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
                     * jQuery(element).on('click', throttled);
                     *
                     * // Cancel the trailing throttled invocation.
                     * jQuery(window).on('popstate', throttled.cancel);
                     */
                    function throttle(func, wait, options) {
                        var leading = true,
                            trailing = true;

                        if (typeof func != 'function') {
                            throw new TypeError(FUNC_ERROR_TEXT);
                        }
                        if (isObject(options)) {
                            leading = 'leading' in options ? !!options.leading : leading;
                            trailing = 'trailing' in options ? !!options.trailing : trailing;
                        }
                        return debounce(func, wait, {
                            'leading': leading,
                            'maxWait': wait,
                            'trailing': trailing
                        });
                    }

                    /**
                     * Creates a function that accepts up to one argument, ignoring any
                     * additional arguments.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Function
                     * @param {Function} func The function to cap arguments for.
                     * @returns {Function} Returns the new capped function.
                     * @example
                     *
                     * _.map(['6', '8', '10'], _.unary(parseInt));
                     * // => [6, 8, 10]
                     */
                    function unary(func) {
                        return ary(func, 1);
                    }

                    /**
                     * Creates a function that provides `value` to `wrapper` as its first
                     * argument. Any additional arguments provided to the function are appended
                     * to those provided to the `wrapper`. The wrapper is invoked with the `this`
                     * binding of the created function.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Function
                     * @param {*} value The value to wrap.
                     * @param {Function} [wrapper=identity] The wrapper function.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var p = _.wrap(_.escape, function(func, text) {
                     *   return '<p>' + func(text) + '</p>';
                     * });
                     *
                     * p('fred, barney, & pebbles');
                     * // => '<p>fred, barney, &amp; pebbles</p>'
                     */
                    function wrap(value, wrapper) {
                        return partial(castFunction(wrapper), value);
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Casts `value` as an array if it's not one.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.4.0
                     * @category Lang
                     * @param {*} value The value to inspect.
                     * @returns {Array} Returns the cast array.
                     * @example
                     *
                     * _.castArray(1);
                     * // => [1]
                     *
                     * _.castArray({ 'a': 1 });
                     * // => [{ 'a': 1 }]
                     *
                     * _.castArray('abc');
                     * // => ['abc']
                     *
                     * _.castArray(null);
                     * // => [null]
                     *
                     * _.castArray(undefined);
                     * // => [undefined]
                     *
                     * _.castArray();
                     * // => []
                     *
                     * var array = [1, 2, 3];
                     * console.log(_.castArray(array) === array);
                     * // => true
                     */
                    function castArray() {
                        if (!arguments.length) {
                            return [];
                        }
                        var value = arguments[0];
                        return isArray(value) ? value : [value];
                    }

                    /**
                     * Creates a shallow clone of `value`.
                     *
                     * **Note:** This method is loosely based on the
                     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
                     * and supports cloning arrays, array buffers, booleans, date objects, maps,
                     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
                     * arrays. The own enumerable properties of `arguments` objects are cloned
                     * as plain objects. An empty object is returned for uncloneable values such
                     * as error objects, functions, DOM nodes, and WeakMaps.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to clone.
                     * @returns {*} Returns the cloned value.
                     * @see _.cloneDeep
                     * @example
                     *
                     * var objects = [{ 'a': 1 }, { 'b': 2 }];
                     *
                     * var shallow = _.clone(objects);
                     * console.log(shallow[0] === objects[0]);
                     * // => true
                     */
                    function clone(value) {
                        return baseClone(value, CLONE_SYMBOLS_FLAG);
                    }

                    /**
                     * This method is like `_.clone` except that it accepts `customizer` which
                     * is invoked to produce the cloned value. If `customizer` returns `undefined`,
                     * cloning is handled by the method instead. The `customizer` is invoked with
                     * up to four arguments; (value [, index|key, object, stack]).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to clone.
                     * @param {Function} [customizer] The function to customize cloning.
                     * @returns {*} Returns the cloned value.
                     * @see _.cloneDeepWith
                     * @example
                     *
                     * function customizer(value) {
                     *   if (_.isElement(value)) {
                     *     return value.cloneNode(false);
                     *   }
                     * }
                     *
                     * var el = _.cloneWith(document.body, customizer);
                     *
                     * console.log(el === document.body);
                     * // => false
                     * console.log(el.nodeName);
                     * // => 'BODY'
                     * console.log(el.childNodes.length);
                     * // => 0
                     */
                    function cloneWith(value, customizer) {
                        customizer = typeof customizer == 'function' ? customizer : undefined;
                        return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
                    }

                    /**
                     * This method is like `_.clone` except that it recursively clones `value`.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.0.0
                     * @category Lang
                     * @param {*} value The value to recursively clone.
                     * @returns {*} Returns the deep cloned value.
                     * @see _.clone
                     * @example
                     *
                     * var objects = [{ 'a': 1 }, { 'b': 2 }];
                     *
                     * var deep = _.cloneDeep(objects);
                     * console.log(deep[0] === objects[0]);
                     * // => false
                     */
                    function cloneDeep(value) {
                        return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
                    }

                    /**
                     * This method is like `_.cloneWith` except that it recursively clones `value`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to recursively clone.
                     * @param {Function} [customizer] The function to customize cloning.
                     * @returns {*} Returns the deep cloned value.
                     * @see _.cloneWith
                     * @example
                     *
                     * function customizer(value) {
                     *   if (_.isElement(value)) {
                     *     return value.cloneNode(true);
                     *   }
                     * }
                     *
                     * var el = _.cloneDeepWith(document.body, customizer);
                     *
                     * console.log(el === document.body);
                     * // => false
                     * console.log(el.nodeName);
                     * // => 'BODY'
                     * console.log(el.childNodes.length);
                     * // => 20
                     */
                    function cloneDeepWith(value, customizer) {
                        customizer = typeof customizer == 'function' ? customizer : undefined;
                        return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
                    }

                    /**
                     * Checks if `object` conforms to `source` by invoking the predicate
                     * properties of `source` with the corresponding property values of `object`.
                     *
                     * **Note:** This method is equivalent to `_.conforms` when `source` is
                     * partially applied.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.14.0
                     * @category Lang
                     * @param {Object} object The object to inspect.
                     * @param {Object} source The object of property predicates to conform to.
                     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': 2 };
                     *
                     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
                     * // => true
                     *
                     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
                     * // => false
                     */
                    function conformsTo(object, source) {
                        return source == null || baseConformsTo(object, source, keys(source));
                    }

                    /**
                     * Performs a
                     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
                     * comparison between two values to determine if they are equivalent.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
                     * @example
                     *
                     * var object = { 'a': 1 };
                     * var other = { 'a': 1 };
                     *
                     * _.eq(object, object);
                     * // => true
                     *
                     * _.eq(object, other);
                     * // => false
                     *
                     * _.eq('a', 'a');
                     * // => true
                     *
                     * _.eq('a', Object('a'));
                     * // => false
                     *
                     * _.eq(NaN, NaN);
                     * // => true
                     */
                    function eq(value, other) {
                        return value === other || (value !== value && other !== other);
                    }

                    /**
                     * Checks if `value` is greater than `other`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.9.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if `value` is greater than `other`,
                     *  else `false`.
                     * @see _.lt
                     * @example
                     *
                     * _.gt(3, 1);
                     * // => true
                     *
                     * _.gt(3, 3);
                     * // => false
                     *
                     * _.gt(1, 3);
                     * // => false
                     */
                    var gt = createRelationalOperation(baseGt);

                    /**
                     * Checks if `value` is greater than or equal to `other`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.9.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if `value` is greater than or equal to
                     *  `other`, else `false`.
                     * @see _.lte
                     * @example
                     *
                     * _.gte(3, 1);
                     * // => true
                     *
                     * _.gte(3, 3);
                     * // => true
                     *
                     * _.gte(1, 3);
                     * // => false
                     */
                    var gte = createRelationalOperation(function(value, other) {
                        return value >= other;
                    });

                    /**
                     * Checks if `value` is likely an `arguments` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
                     *  else `false`.
                     * @example
                     *
                     * _.isArguments(function() { return arguments; }());
                     * // => true
                     *
                     * _.isArguments([1, 2, 3]);
                     * // => false
                     */
                    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
                        return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
                            !propertyIsEnumerable.call(value, 'callee');
                    };

                    /**
                     * Checks if `value` is classified as an `Array` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
                     * @example
                     *
                     * _.isArray([1, 2, 3]);
                     * // => true
                     *
                     * _.isArray(document.body.children);
                     * // => false
                     *
                     * _.isArray('abc');
                     * // => false
                     *
                     * _.isArray(_.noop);
                     * // => false
                     */
                    var isArray = Array.isArray;

                    /**
                     * Checks if `value` is classified as an `ArrayBuffer` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.3.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
                     * @example
                     *
                     * _.isArrayBuffer(new ArrayBuffer(2));
                     * // => true
                     *
                     * _.isArrayBuffer(new Array(2));
                     * // => false
                     */
                    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;

                    /**
                     * Checks if `value` is array-like. A value is considered array-like if it's
                     * not a function and has a `value.length` that's an integer greater than or
                     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
                     * @example
                     *
                     * _.isArrayLike([1, 2, 3]);
                     * // => true
                     *
                     * _.isArrayLike(document.body.children);
                     * // => true
                     *
                     * _.isArrayLike('abc');
                     * // => true
                     *
                     * _.isArrayLike(_.noop);
                     * // => false
                     */
                    function isArrayLike(value) {
                        return value != null && isLength(value.length) && !isFunction(value);
                    }

                    /**
                     * This method is like `_.isArrayLike` except that it also checks if `value`
                     * is an object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an array-like object,
                     *  else `false`.
                     * @example
                     *
                     * _.isArrayLikeObject([1, 2, 3]);
                     * // => true
                     *
                     * _.isArrayLikeObject(document.body.children);
                     * // => true
                     *
                     * _.isArrayLikeObject('abc');
                     * // => false
                     *
                     * _.isArrayLikeObject(_.noop);
                     * // => false
                     */
                    function isArrayLikeObject(value) {
                        return isObjectLike(value) && isArrayLike(value);
                    }

                    /**
                     * Checks if `value` is classified as a boolean primitive or object.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
                     * @example
                     *
                     * _.isBoolean(false);
                     * // => true
                     *
                     * _.isBoolean(null);
                     * // => false
                     */
                    function isBoolean(value) {
                        return value === true || value === false ||
                            (isObjectLike(value) && baseGetTag(value) == boolTag);
                    }

                    /**
                     * Checks if `value` is a buffer.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.3.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
                     * @example
                     *
                     * _.isBuffer(new Buffer(2));
                     * // => true
                     *
                     * _.isBuffer(new Uint8Array(2));
                     * // => false
                     */
                    var isBuffer = nativeIsBuffer || stubFalse;

                    /**
                     * Checks if `value` is classified as a `Date` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
                     * @example
                     *
                     * _.isDate(new Date);
                     * // => true
                     *
                     * _.isDate('Mon April 23 2012');
                     * // => false
                     */
                    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;

                    /**
                     * Checks if `value` is likely a DOM element.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
                     * @example
                     *
                     * _.isElement(document.body);
                     * // => true
                     *
                     * _.isElement('<body>');
                     * // => false
                     */
                    function isElement(value) {
                        return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
                    }

                    /**
                     * Checks if `value` is an empty object, collection, map, or set.
                     *
                     * Objects are considered empty if they have no own enumerable string keyed
                     * properties.
                     *
                     * Array-like values such as `arguments` objects, arrays, buffers, strings, or
                     * jQuery-like collections are considered empty if they have a `length` of `0`.
                     * Similarly, maps and sets are considered empty if they have a `size` of `0`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is empty, else `false`.
                     * @example
                     *
                     * _.isEmpty(null);
                     * // => true
                     *
                     * _.isEmpty(true);
                     * // => true
                     *
                     * _.isEmpty(1);
                     * // => true
                     *
                     * _.isEmpty([1, 2, 3]);
                     * // => false
                     *
                     * _.isEmpty({ 'a': 1 });
                     * // => false
                     */
                    function isEmpty(value) {
                        if (value == null) {
                            return true;
                        }
                        if (isArrayLike(value) &&
                            (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
                                isBuffer(value) || isTypedArray(value) || isArguments(value))) {
                            return !value.length;
                        }
                        var tag = getTag(value);
                        if (tag == mapTag || tag == setTag) {
                            return !value.size;
                        }
                        if (isPrototype(value)) {
                            return !baseKeys(value).length;
                        }
                        for (var key in value) {
                            if (hasOwnProperty.call(value, key)) {
                                return false;
                            }
                        }
                        return true;
                    }

                    /**
                     * Performs a deep comparison between two values to determine if they are
                     * equivalent.
                     *
                     * **Note:** This method supports comparing arrays, array buffers, booleans,
                     * date objects, error objects, maps, numbers, `Object` objects, regexes,
                     * sets, strings, symbols, and typed arrays. `Object` objects are compared
                     * by their own, not inherited, enumerable properties. Functions and DOM
                     * nodes are compared by strict equality, i.e. `===`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
                     * @example
                     *
                     * var object = { 'a': 1 };
                     * var other = { 'a': 1 };
                     *
                     * _.isEqual(object, other);
                     * // => true
                     *
                     * object === other;
                     * // => false
                     */
                    function isEqual(value, other) {
                        return baseIsEqual(value, other);
                    }

                    /**
                     * This method is like `_.isEqual` except that it accepts `customizer` which
                     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
                     * are handled by the method instead. The `customizer` is invoked with up to
                     * six arguments: (objValue, othValue [, index|key, object, other, stack]).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @param {Function} [customizer] The function to customize comparisons.
                     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
                     * @example
                     *
                     * function isGreeting(value) {
                     *   return /^h(?:i|ello)$/.test(value);
                     * }
                     *
                     * function customizer(objValue, othValue) {
                     *   if (isGreeting(objValue) && isGreeting(othValue)) {
                     *     return true;
                     *   }
                     * }
                     *
                     * var array = ['hello', 'goodbye'];
                     * var other = ['hi', 'goodbye'];
                     *
                     * _.isEqualWith(array, other, customizer);
                     * // => true
                     */
                    function isEqualWith(value, other, customizer) {
                        customizer = typeof customizer == 'function' ? customizer : undefined;
                        var result = customizer ? customizer(value, other) : undefined;
                        return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
                    }

                    /**
                     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
                     * `SyntaxError`, `TypeError`, or `URIError` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
                     * @example
                     *
                     * _.isError(new Error);
                     * // => true
                     *
                     * _.isError(Error);
                     * // => false
                     */
                    function isError(value) {
                        if (!isObjectLike(value)) {
                            return false;
                        }
                        var tag = baseGetTag(value);
                        return tag == errorTag || tag == domExcTag ||
                            (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
                    }

                    /**
                     * Checks if `value` is a finite primitive number.
                     *
                     * **Note:** This method is based on
                     * [`Number.isFinite`](https://mdn.io/Number/isFinite).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
                     * @example
                     *
                     * _.isFinite(3);
                     * // => true
                     *
                     * _.isFinite(Number.MIN_VALUE);
                     * // => true
                     *
                     * _.isFinite(Infinity);
                     * // => false
                     *
                     * _.isFinite('3');
                     * // => false
                     */
                    function isFinite(value) {
                        return typeof value == 'number' && nativeIsFinite(value);
                    }

                    /**
                     * Checks if `value` is classified as a `Function` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
                     * @example
                     *
                     * _.isFunction(_);
                     * // => true
                     *
                     * _.isFunction(/abc/);
                     * // => false
                     */
                    function isFunction(value) {
                        if (!isObject(value)) {
                            return false;
                        }
                        // The use of `Object#toString` avoids issues with the `typeof` operator
                        // in Safari 9 which returns 'object' for typed arrays and other constructors.
                        var tag = baseGetTag(value);
                        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
                    }

                    /**
                     * Checks if `value` is an integer.
                     *
                     * **Note:** This method is based on
                     * [`Number.isInteger`](https://mdn.io/Number/isInteger).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
                     * @example
                     *
                     * _.isInteger(3);
                     * // => true
                     *
                     * _.isInteger(Number.MIN_VALUE);
                     * // => false
                     *
                     * _.isInteger(Infinity);
                     * // => false
                     *
                     * _.isInteger('3');
                     * // => false
                     */
                    function isInteger(value) {
                        return typeof value == 'number' && value == toInteger(value);
                    }

                    /**
                     * Checks if `value` is a valid array-like length.
                     *
                     * **Note:** This method is loosely based on
                     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
                     * @example
                     *
                     * _.isLength(3);
                     * // => true
                     *
                     * _.isLength(Number.MIN_VALUE);
                     * // => false
                     *
                     * _.isLength(Infinity);
                     * // => false
                     *
                     * _.isLength('3');
                     * // => false
                     */
                    function isLength(value) {
                        return typeof value == 'number' &&
                            value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
                    }

                    /**
                     * Checks if `value` is the
                     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
                     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
                     * @example
                     *
                     * _.isObject({});
                     * // => true
                     *
                     * _.isObject([1, 2, 3]);
                     * // => true
                     *
                     * _.isObject(_.noop);
                     * // => true
                     *
                     * _.isObject(null);
                     * // => false
                     */
                    function isObject(value) {
                        var type = typeof value;
                        return value != null && (type == 'object' || type == 'function');
                    }

                    /**
                     * Checks if `value` is object-like. A value is object-like if it's not `null`
                     * and has a `typeof` result of "object".
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
                     * @example
                     *
                     * _.isObjectLike({});
                     * // => true
                     *
                     * _.isObjectLike([1, 2, 3]);
                     * // => true
                     *
                     * _.isObjectLike(_.noop);
                     * // => false
                     *
                     * _.isObjectLike(null);
                     * // => false
                     */
                    function isObjectLike(value) {
                        return value != null && typeof value == 'object';
                    }

                    /**
                     * Checks if `value` is classified as a `Map` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.3.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
                     * @example
                     *
                     * _.isMap(new Map);
                     * // => true
                     *
                     * _.isMap(new WeakMap);
                     * // => false
                     */
                    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

                    /**
                     * Performs a partial deep comparison between `object` and `source` to
                     * determine if `object` contains equivalent property values.
                     *
                     * **Note:** This method is equivalent to `_.matches` when `source` is
                     * partially applied.
                     *
                     * Partial comparisons will match empty array and empty object `source`
                     * values against any array or object value, respectively. See `_.isEqual`
                     * for a list of supported value comparisons.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Lang
                     * @param {Object} object The object to inspect.
                     * @param {Object} source The object of property values to match.
                     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': 2 };
                     *
                     * _.isMatch(object, { 'b': 2 });
                     * // => true
                     *
                     * _.isMatch(object, { 'b': 1 });
                     * // => false
                     */
                    function isMatch(object, source) {
                        return object === source || baseIsMatch(object, source, getMatchData(source));
                    }

                    /**
                     * This method is like `_.isMatch` except that it accepts `customizer` which
                     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
                     * are handled by the method instead. The `customizer` is invoked with five
                     * arguments: (objValue, srcValue, index|key, object, source).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {Object} object The object to inspect.
                     * @param {Object} source The object of property values to match.
                     * @param {Function} [customizer] The function to customize comparisons.
                     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
                     * @example
                     *
                     * function isGreeting(value) {
                     *   return /^h(?:i|ello)$/.test(value);
                     * }
                     *
                     * function customizer(objValue, srcValue) {
                     *   if (isGreeting(objValue) && isGreeting(srcValue)) {
                     *     return true;
                     *   }
                     * }
                     *
                     * var object = { 'greeting': 'hello' };
                     * var source = { 'greeting': 'hi' };
                     *
                     * _.isMatchWith(object, source, customizer);
                     * // => true
                     */
                    function isMatchWith(object, source, customizer) {
                        customizer = typeof customizer == 'function' ? customizer : undefined;
                        return baseIsMatch(object, source, getMatchData(source), customizer);
                    }

                    /**
                     * Checks if `value` is `NaN`.
                     *
                     * **Note:** This method is based on
                     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
                     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
                     * `undefined` and other non-number values.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
                     * @example
                     *
                     * _.isNaN(NaN);
                     * // => true
                     *
                     * _.isNaN(new Number(NaN));
                     * // => true
                     *
                     * isNaN(undefined);
                     * // => true
                     *
                     * _.isNaN(undefined);
                     * // => false
                     */
                    function isNaN(value) {
                        // An `NaN` primitive is the only value that is not equal to itself.
                        // Perform the `toStringTag` check first to avoid errors with some
                        // ActiveX objects in IE.
                        return isNumber(value) && value != +value;
                    }

                    /**
                     * Checks if `value` is a pristine native function.
                     *
                     * **Note:** This method can't reliably detect native functions in the presence
                     * of the core-js package because core-js circumvents this kind of detection.
                     * Despite multiple requests, the core-js maintainer has made it clear: any
                     * attempt to fix the detection will be obstructed. As a result, we're left
                     * with little choice but to throw an error. Unfortunately, this also affects
                     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
                     * which rely on core-js.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a native function,
                     *  else `false`.
                     * @example
                     *
                     * _.isNative(Array.prototype.push);
                     * // => true
                     *
                     * _.isNative(_);
                     * // => false
                     */
                    function isNative(value) {
                        if (isMaskable(value)) {
                            throw new Error(CORE_ERROR_TEXT);
                        }
                        return baseIsNative(value);
                    }

                    /**
                     * Checks if `value` is `null`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
                     * @example
                     *
                     * _.isNull(null);
                     * // => true
                     *
                     * _.isNull(void 0);
                     * // => false
                     */
                    function isNull(value) {
                        return value === null;
                    }

                    /**
                     * Checks if `value` is `null` or `undefined`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
                     * @example
                     *
                     * _.isNil(null);
                     * // => true
                     *
                     * _.isNil(void 0);
                     * // => true
                     *
                     * _.isNil(NaN);
                     * // => false
                     */
                    function isNil(value) {
                        return value == null;
                    }

                    /**
                     * Checks if `value` is classified as a `Number` primitive or object.
                     *
                     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
                     * classified as numbers, use the `_.isFinite` method.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a number, else `false`.
                     * @example
                     *
                     * _.isNumber(3);
                     * // => true
                     *
                     * _.isNumber(Number.MIN_VALUE);
                     * // => true
                     *
                     * _.isNumber(Infinity);
                     * // => true
                     *
                     * _.isNumber('3');
                     * // => false
                     */
                    function isNumber(value) {
                        return typeof value == 'number' ||
                            (isObjectLike(value) && baseGetTag(value) == numberTag);
                    }

                    /**
                     * Checks if `value` is a plain object, that is, an object created by the
                     * `Object` constructor or one with a `[[Prototype]]` of `null`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.8.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     * }
                     *
                     * _.isPlainObject(new Foo);
                     * // => false
                     *
                     * _.isPlainObject([1, 2, 3]);
                     * // => false
                     *
                     * _.isPlainObject({ 'x': 0, 'y': 0 });
                     * // => true
                     *
                     * _.isPlainObject(Object.create(null));
                     * // => true
                     */
                    function isPlainObject(value) {
                        if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
                            return false;
                        }
                        var proto = getPrototype(value);
                        if (proto === null) {
                            return true;
                        }
                        var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
                        return typeof Ctor == 'function' && Ctor instanceof Ctor &&
                            funcToString.call(Ctor) == objectCtorString;
                    }

                    /**
                     * Checks if `value` is classified as a `RegExp` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.1.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
                     * @example
                     *
                     * _.isRegExp(/abc/);
                     * // => true
                     *
                     * _.isRegExp('/abc/');
                     * // => false
                     */
                    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

                    /**
                     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
                     * double precision number which isn't the result of a rounded unsafe integer.
                     *
                     * **Note:** This method is based on
                     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
                     * @example
                     *
                     * _.isSafeInteger(3);
                     * // => true
                     *
                     * _.isSafeInteger(Number.MIN_VALUE);
                     * // => false
                     *
                     * _.isSafeInteger(Infinity);
                     * // => false
                     *
                     * _.isSafeInteger('3');
                     * // => false
                     */
                    function isSafeInteger(value) {
                        return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
                    }

                    /**
                     * Checks if `value` is classified as a `Set` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.3.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
                     * @example
                     *
                     * _.isSet(new Set);
                     * // => true
                     *
                     * _.isSet(new WeakSet);
                     * // => false
                     */
                    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

                    /**
                     * Checks if `value` is classified as a `String` primitive or object.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a string, else `false`.
                     * @example
                     *
                     * _.isString('abc');
                     * // => true
                     *
                     * _.isString(1);
                     * // => false
                     */
                    function isString(value) {
                        return typeof value == 'string' ||
                            (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
                    }

                    /**
                     * Checks if `value` is classified as a `Symbol` primitive or object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
                     * @example
                     *
                     * _.isSymbol(Symbol.iterator);
                     * // => true
                     *
                     * _.isSymbol('abc');
                     * // => false
                     */
                    function isSymbol(value) {
                        return typeof value == 'symbol' ||
                            (isObjectLike(value) && baseGetTag(value) == symbolTag);
                    }

                    /**
                     * Checks if `value` is classified as a typed array.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
                     * @example
                     *
                     * _.isTypedArray(new Uint8Array);
                     * // => true
                     *
                     * _.isTypedArray([]);
                     * // => false
                     */
                    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

                    /**
                     * Checks if `value` is `undefined`.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
                     * @example
                     *
                     * _.isUndefined(void 0);
                     * // => true
                     *
                     * _.isUndefined(null);
                     * // => false
                     */
                    function isUndefined(value) {
                        return value === undefined;
                    }

                    /**
                     * Checks if `value` is classified as a `WeakMap` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.3.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
                     * @example
                     *
                     * _.isWeakMap(new WeakMap);
                     * // => true
                     *
                     * _.isWeakMap(new Map);
                     * // => false
                     */
                    function isWeakMap(value) {
                        return isObjectLike(value) && getTag(value) == weakMapTag;
                    }

                    /**
                     * Checks if `value` is classified as a `WeakSet` object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.3.0
                     * @category Lang
                     * @param {*} value The value to check.
                     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
                     * @example
                     *
                     * _.isWeakSet(new WeakSet);
                     * // => true
                     *
                     * _.isWeakSet(new Set);
                     * // => false
                     */
                    function isWeakSet(value) {
                        return isObjectLike(value) && baseGetTag(value) == weakSetTag;
                    }

                    /**
                     * Checks if `value` is less than `other`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.9.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if `value` is less than `other`,
                     *  else `false`.
                     * @see _.gt
                     * @example
                     *
                     * _.lt(1, 3);
                     * // => true
                     *
                     * _.lt(3, 3);
                     * // => false
                     *
                     * _.lt(3, 1);
                     * // => false
                     */
                    var lt = createRelationalOperation(baseLt);

                    /**
                     * Checks if `value` is less than or equal to `other`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.9.0
                     * @category Lang
                     * @param {*} value The value to compare.
                     * @param {*} other The other value to compare.
                     * @returns {boolean} Returns `true` if `value` is less than or equal to
                     *  `other`, else `false`.
                     * @see _.gte
                     * @example
                     *
                     * _.lte(1, 3);
                     * // => true
                     *
                     * _.lte(3, 3);
                     * // => true
                     *
                     * _.lte(3, 1);
                     * // => false
                     */
                    var lte = createRelationalOperation(function(value, other) {
                        return value <= other;
                    });

                    /**
                     * Converts `value` to an array.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {Array} Returns the converted array.
                     * @example
                     *
                     * _.toArray({ 'a': 1, 'b': 2 });
                     * // => [1, 2]
                     *
                     * _.toArray('abc');
                     * // => ['a', 'b', 'c']
                     *
                     * _.toArray(1);
                     * // => []
                     *
                     * _.toArray(null);
                     * // => []
                     */
                    function toArray(value) {
                        if (!value) {
                            return [];
                        }
                        if (isArrayLike(value)) {
                            return isString(value) ? stringToArray(value) : copyArray(value);
                        }
                        if (symIterator && value[symIterator]) {
                            return iteratorToArray(value[symIterator]());
                        }
                        var tag = getTag(value),
                            func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);

                        return func(value);
                    }

                    /**
                     * Converts `value` to a finite number.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.12.0
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {number} Returns the converted number.
                     * @example
                     *
                     * _.toFinite(3.2);
                     * // => 3.2
                     *
                     * _.toFinite(Number.MIN_VALUE);
                     * // => 5e-324
                     *
                     * _.toFinite(Infinity);
                     * // => 1.7976931348623157e+308
                     *
                     * _.toFinite('3.2');
                     * // => 3.2
                     */
                    function toFinite(value) {
                        if (!value) {
                            return value === 0 ? value : 0;
                        }
                        value = toNumber(value);
                        if (value === INFINITY || value === -INFINITY) {
                            var sign = (value < 0 ? -1 : 1);
                            return sign * MAX_INTEGER;
                        }
                        return value === value ? value : 0;
                    }

                    /**
                     * Converts `value` to an integer.
                     *
                     * **Note:** This method is loosely based on
                     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {number} Returns the converted integer.
                     * @example
                     *
                     * _.toInteger(3.2);
                     * // => 3
                     *
                     * _.toInteger(Number.MIN_VALUE);
                     * // => 0
                     *
                     * _.toInteger(Infinity);
                     * // => 1.7976931348623157e+308
                     *
                     * _.toInteger('3.2');
                     * // => 3
                     */
                    function toInteger(value) {
                        var result = toFinite(value),
                            remainder = result % 1;

                        return result === result ? (remainder ? result - remainder : result) : 0;
                    }

                    /**
                     * Converts `value` to an integer suitable for use as the length of an
                     * array-like object.
                     *
                     * **Note:** This method is based on
                     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {number} Returns the converted integer.
                     * @example
                     *
                     * _.toLength(3.2);
                     * // => 3
                     *
                     * _.toLength(Number.MIN_VALUE);
                     * // => 0
                     *
                     * _.toLength(Infinity);
                     * // => 4294967295
                     *
                     * _.toLength('3.2');
                     * // => 3
                     */
                    function toLength(value) {
                        return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
                    }

                    /**
                     * Converts `value` to a number.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to process.
                     * @returns {number} Returns the number.
                     * @example
                     *
                     * _.toNumber(3.2);
                     * // => 3.2
                     *
                     * _.toNumber(Number.MIN_VALUE);
                     * // => 5e-324
                     *
                     * _.toNumber(Infinity);
                     * // => Infinity
                     *
                     * _.toNumber('3.2');
                     * // => 3.2
                     */
                    function toNumber(value) {
                        if (typeof value == 'number') {
                            return value;
                        }
                        if (isSymbol(value)) {
                            return NAN;
                        }
                        if (isObject(value)) {
                            var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
                            value = isObject(other) ? (other + '') : other;
                        }
                        if (typeof value != 'string') {
                            return value === 0 ? value : +value;
                        }
                        value = baseTrim(value);
                        var isBinary = reIsBinary.test(value);
                        return (isBinary || reIsOctal.test(value))
                            ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
                            : (reIsBadHex.test(value) ? NAN : +value);
                    }

                    /**
                     * Converts `value` to a plain object flattening inherited enumerable string
                     * keyed properties of `value` to own properties of the plain object.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {Object} Returns the converted plain object.
                     * @example
                     *
                     * function Foo() {
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.assign({ 'a': 1 }, new Foo);
                     * // => { 'a': 1, 'b': 2 }
                     *
                     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
                     * // => { 'a': 1, 'b': 2, 'c': 3 }
                     */
                    function toPlainObject(value) {
                        return copyObject(value, keysIn(value));
                    }

                    /**
                     * Converts `value` to a safe integer. A safe integer can be compared and
                     * represented correctly.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {number} Returns the converted integer.
                     * @example
                     *
                     * _.toSafeInteger(3.2);
                     * // => 3
                     *
                     * _.toSafeInteger(Number.MIN_VALUE);
                     * // => 0
                     *
                     * _.toSafeInteger(Infinity);
                     * // => 9007199254740991
                     *
                     * _.toSafeInteger('3.2');
                     * // => 3
                     */
                    function toSafeInteger(value) {
                        return value
                            ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
                            : (value === 0 ? value : 0);
                    }

                    /**
                     * Converts `value` to a string. An empty string is returned for `null`
                     * and `undefined` values. The sign of `-0` is preserved.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Lang
                     * @param {*} value The value to convert.
                     * @returns {string} Returns the converted string.
                     * @example
                     *
                     * _.toString(null);
                     * // => ''
                     *
                     * _.toString(-0);
                     * // => '-0'
                     *
                     * _.toString([1, 2, 3]);
                     * // => '1,2,3'
                     */
                    function toString(value) {
                        return value == null ? '' : baseToString(value);
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Assigns own enumerable string keyed properties of source objects to the
                     * destination object. Source objects are applied from left to right.
                     * Subsequent sources overwrite property assignments of previous sources.
                     *
                     * **Note:** This method mutates `object` and is loosely based on
                     * [`Object.assign`](https://mdn.io/Object/assign).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.10.0
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} [sources] The source objects.
                     * @returns {Object} Returns `object`.
                     * @see _.assignIn
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     * }
                     *
                     * function Bar() {
                     *   this.c = 3;
                     * }
                     *
                     * Foo.prototype.b = 2;
                     * Bar.prototype.d = 4;
                     *
                     * _.assign({ 'a': 0 }, new Foo, new Bar);
                     * // => { 'a': 1, 'c': 3 }
                     */
                    var assign = createAssigner(function(object, source) {
                        if (isPrototype(source) || isArrayLike(source)) {
                            copyObject(source, keys(source), object);
                            return;
                        }
                        for (var key in source) {
                            if (hasOwnProperty.call(source, key)) {
                                assignValue(object, key, source[key]);
                            }
                        }
                    });

                    /**
                     * This method is like `_.assign` except that it iterates over own and
                     * inherited source properties.
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @alias extend
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} [sources] The source objects.
                     * @returns {Object} Returns `object`.
                     * @see _.assign
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     * }
                     *
                     * function Bar() {
                     *   this.c = 3;
                     * }
                     *
                     * Foo.prototype.b = 2;
                     * Bar.prototype.d = 4;
                     *
                     * _.assignIn({ 'a': 0 }, new Foo, new Bar);
                     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
                     */
                    var assignIn = createAssigner(function(object, source) {
                        copyObject(source, keysIn(source), object);
                    });

                    /**
                     * This method is like `_.assignIn` except that it accepts `customizer`
                     * which is invoked to produce the assigned values. If `customizer` returns
                     * `undefined`, assignment is handled by the method instead. The `customizer`
                     * is invoked with five arguments: (objValue, srcValue, key, object, source).
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @alias extendWith
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} sources The source objects.
                     * @param {Function} [customizer] The function to customize assigned values.
                     * @returns {Object} Returns `object`.
                     * @see _.assignWith
                     * @example
                     *
                     * function customizer(objValue, srcValue) {
                     *   return _.isUndefined(objValue) ? srcValue : objValue;
                     * }
                     *
                     * var defaults = _.partialRight(_.assignInWith, customizer);
                     *
                     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
                     * // => { 'a': 1, 'b': 2 }
                     */
                    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
                        copyObject(source, keysIn(source), object, customizer);
                    });

                    /**
                     * This method is like `_.assign` except that it accepts `customizer`
                     * which is invoked to produce the assigned values. If `customizer` returns
                     * `undefined`, assignment is handled by the method instead. The `customizer`
                     * is invoked with five arguments: (objValue, srcValue, key, object, source).
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} sources The source objects.
                     * @param {Function} [customizer] The function to customize assigned values.
                     * @returns {Object} Returns `object`.
                     * @see _.assignInWith
                     * @example
                     *
                     * function customizer(objValue, srcValue) {
                     *   return _.isUndefined(objValue) ? srcValue : objValue;
                     * }
                     *
                     * var defaults = _.partialRight(_.assignWith, customizer);
                     *
                     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
                     * // => { 'a': 1, 'b': 2 }
                     */
                    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
                        copyObject(source, keys(source), object, customizer);
                    });

                    /**
                     * Creates an array of values corresponding to `paths` of `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.0.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {...(string|string[])} [paths] The property paths to pick.
                     * @returns {Array} Returns the picked values.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
                     *
                     * _.at(object, ['a[0].b.c', 'a[1]']);
                     * // => [3, 4]
                     */
                    var at = flatRest(baseAt);

                    /**
                     * Creates an object that inherits from the `prototype` object. If a
                     * `properties` object is given, its own enumerable string keyed properties
                     * are assigned to the created object.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.3.0
                     * @category Object
                     * @param {Object} prototype The object to inherit from.
                     * @param {Object} [properties] The properties to assign to the object.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * function Shape() {
                     *   this.x = 0;
                     *   this.y = 0;
                     * }
                     *
                     * function Circle() {
                     *   Shape.call(this);
                     * }
                     *
                     * Circle.prototype = _.create(Shape.prototype, {
                     *   'constructor': Circle
                     * });
                     *
                     * var circle = new Circle;
                     * circle instanceof Circle;
                     * // => true
                     *
                     * circle instanceof Shape;
                     * // => true
                     */
                    function create(prototype, properties) {
                        var result = baseCreate(prototype);
                        return properties == null ? result : baseAssign(result, properties);
                    }

                    /**
                     * Assigns own and inherited enumerable string keyed properties of source
                     * objects to the destination object for all destination properties that
                     * resolve to `undefined`. Source objects are applied from left to right.
                     * Once a property is set, additional values of the same property are ignored.
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} [sources] The source objects.
                     * @returns {Object} Returns `object`.
                     * @see _.defaultsDeep
                     * @example
                     *
                     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
                     * // => { 'a': 1, 'b': 2 }
                     */
                    var defaults = baseRest(function(object, sources) {
                        object = Object(object);

                        var index = -1;
                        var length = sources.length;
                        var guard = length > 2 ? sources[2] : undefined;

                        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
                            length = 1;
                        }

                        while (++index < length) {
                            var source = sources[index];
                            var props = keysIn(source);
                            var propsIndex = -1;
                            var propsLength = props.length;

                            while (++propsIndex < propsLength) {
                                var key = props[propsIndex];
                                var value = object[key];

                                if (value === undefined ||
                                    (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
                                    object[key] = source[key];
                                }
                            }
                        }

                        return object;
                    });

                    /**
                     * This method is like `_.defaults` except that it recursively assigns
                     * default properties.
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.10.0
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} [sources] The source objects.
                     * @returns {Object} Returns `object`.
                     * @see _.defaults
                     * @example
                     *
                     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
                     * // => { 'a': { 'b': 2, 'c': 3 } }
                     */
                    var defaultsDeep = baseRest(function(args) {
                        args.push(undefined, customDefaultsMerge);
                        return apply(mergeWith, undefined, args);
                    });

                    /**
                     * This method is like `_.find` except that it returns the key of the first
                     * element `predicate` returns truthy for instead of the element itself.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.1.0
                     * @category Object
                     * @param {Object} object The object to inspect.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {string|undefined} Returns the key of the matched element,
                     *  else `undefined`.
                     * @example
                     *
                     * var users = {
                     *   'barney':  { 'age': 36, 'active': true },
                     *   'fred':    { 'age': 40, 'active': false },
                     *   'pebbles': { 'age': 1,  'active': true }
                     * };
                     *
                     * _.findKey(users, function(o) { return o.age < 40; });
                     * // => 'barney' (iteration order is not guaranteed)
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.findKey(users, { 'age': 1, 'active': true });
                     * // => 'pebbles'
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.findKey(users, ['active', false]);
                     * // => 'fred'
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.findKey(users, 'active');
                     * // => 'barney'
                     */
                    function findKey(object, predicate) {
                        return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
                    }

                    /**
                     * This method is like `_.findKey` except that it iterates over elements of
                     * a collection in the opposite order.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Object
                     * @param {Object} object The object to inspect.
                     * @param {Function} [predicate=_.identity] The function invoked per iteration.
                     * @returns {string|undefined} Returns the key of the matched element,
                     *  else `undefined`.
                     * @example
                     *
                     * var users = {
                     *   'barney':  { 'age': 36, 'active': true },
                     *   'fred':    { 'age': 40, 'active': false },
                     *   'pebbles': { 'age': 1,  'active': true }
                     * };
                     *
                     * _.findLastKey(users, function(o) { return o.age < 40; });
                     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.findLastKey(users, { 'age': 36, 'active': true });
                     * // => 'barney'
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.findLastKey(users, ['active', false]);
                     * // => 'fred'
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.findLastKey(users, 'active');
                     * // => 'pebbles'
                     */
                    function findLastKey(object, predicate) {
                        return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
                    }

                    /**
                     * Iterates over own and inherited enumerable string keyed properties of an
                     * object and invokes `iteratee` for each property. The iteratee is invoked
                     * with three arguments: (value, key, object). Iteratee functions may exit
                     * iteration early by explicitly returning `false`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.3.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Object} Returns `object`.
                     * @see _.forInRight
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.forIn(new Foo, function(value, key) {
                     *   console.log(key);
                     * });
                     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
                     */
                    function forIn(object, iteratee) {
                        return object == null
                            ? object
                            : baseFor(object, getIteratee(iteratee, 3), keysIn);
                    }

                    /**
                     * This method is like `_.forIn` except that it iterates over properties of
                     * `object` in the opposite order.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Object} Returns `object`.
                     * @see _.forIn
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.forInRight(new Foo, function(value, key) {
                     *   console.log(key);
                     * });
                     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
                     */
                    function forInRight(object, iteratee) {
                        return object == null
                            ? object
                            : baseForRight(object, getIteratee(iteratee, 3), keysIn);
                    }

                    /**
                     * Iterates over own enumerable string keyed properties of an object and
                     * invokes `iteratee` for each property. The iteratee is invoked with three
                     * arguments: (value, key, object). Iteratee functions may exit iteration
                     * early by explicitly returning `false`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.3.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Object} Returns `object`.
                     * @see _.forOwnRight
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.forOwn(new Foo, function(value, key) {
                     *   console.log(key);
                     * });
                     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
                     */
                    function forOwn(object, iteratee) {
                        return object && baseForOwn(object, getIteratee(iteratee, 3));
                    }

                    /**
                     * This method is like `_.forOwn` except that it iterates over properties of
                     * `object` in the opposite order.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.0.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Object} Returns `object`.
                     * @see _.forOwn
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.forOwnRight(new Foo, function(value, key) {
                     *   console.log(key);
                     * });
                     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
                     */
                    function forOwnRight(object, iteratee) {
                        return object && baseForOwnRight(object, getIteratee(iteratee, 3));
                    }

                    /**
                     * Creates an array of function property names from own enumerable properties
                     * of `object`.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The object to inspect.
                     * @returns {Array} Returns the function names.
                     * @see _.functionsIn
                     * @example
                     *
                     * function Foo() {
                     *   this.a = _.constant('a');
                     *   this.b = _.constant('b');
                     * }
                     *
                     * Foo.prototype.c = _.constant('c');
                     *
                     * _.functions(new Foo);
                     * // => ['a', 'b']
                     */
                    function functions(object) {
                        return object == null ? [] : baseFunctions(object, keys(object));
                    }

                    /**
                     * Creates an array of function property names from own and inherited
                     * enumerable properties of `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The object to inspect.
                     * @returns {Array} Returns the function names.
                     * @see _.functions
                     * @example
                     *
                     * function Foo() {
                     *   this.a = _.constant('a');
                     *   this.b = _.constant('b');
                     * }
                     *
                     * Foo.prototype.c = _.constant('c');
                     *
                     * _.functionsIn(new Foo);
                     * // => ['a', 'b', 'c']
                     */
                    function functionsIn(object) {
                        return object == null ? [] : baseFunctions(object, keysIn(object));
                    }

                    /**
                     * Gets the value at `path` of `object`. If the resolved value is
                     * `undefined`, the `defaultValue` is returned in its place.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.7.0
                     * @category Object
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path of the property to get.
                     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
                     * @returns {*} Returns the resolved value.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
                     *
                     * _.get(object, 'a[0].b.c');
                     * // => 3
                     *
                     * _.get(object, ['a', '0', 'b', 'c']);
                     * // => 3
                     *
                     * _.get(object, 'a.b.c', 'default');
                     * // => 'default'
                     */
                    function get(object, path, defaultValue) {
                        var result = object == null ? undefined : baseGet(object, path);
                        return result === undefined ? defaultValue : result;
                    }

                    /**
                     * Checks if `path` is a direct property of `object`.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path to check.
                     * @returns {boolean} Returns `true` if `path` exists, else `false`.
                     * @example
                     *
                     * var object = { 'a': { 'b': 2 } };
                     * var other = _.create({ 'a': _.create({ 'b': 2 }) });
                     *
                     * _.has(object, 'a');
                     * // => true
                     *
                     * _.has(object, 'a.b');
                     * // => true
                     *
                     * _.has(object, ['a', 'b']);
                     * // => true
                     *
                     * _.has(other, 'a');
                     * // => false
                     */
                    function has(object, path) {
                        return object != null && hasPath(object, path, baseHas);
                    }

                    /**
                     * Checks if `path` is a direct or inherited property of `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path to check.
                     * @returns {boolean} Returns `true` if `path` exists, else `false`.
                     * @example
                     *
                     * var object = _.create({ 'a': _.create({ 'b': 2 }) });
                     *
                     * _.hasIn(object, 'a');
                     * // => true
                     *
                     * _.hasIn(object, 'a.b');
                     * // => true
                     *
                     * _.hasIn(object, ['a', 'b']);
                     * // => true
                     *
                     * _.hasIn(object, 'b');
                     * // => false
                     */
                    function hasIn(object, path) {
                        return object != null && hasPath(object, path, baseHasIn);
                    }

                    /**
                     * Creates an object composed of the inverted keys and values of `object`.
                     * If `object` contains duplicate values, subsequent values overwrite
                     * property assignments of previous values.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.7.0
                     * @category Object
                     * @param {Object} object The object to invert.
                     * @returns {Object} Returns the new inverted object.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': 2, 'c': 1 };
                     *
                     * _.invert(object);
                     * // => { '1': 'c', '2': 'b' }
                     */
                    var invert = createInverter(function(result, value, key) {
                        if (value != null &&
                            typeof value.toString != 'function') {
                            value = nativeObjectToString.call(value);
                        }

                        result[value] = key;
                    }, constant(identity));

                    /**
                     * This method is like `_.invert` except that the inverted object is generated
                     * from the results of running each element of `object` thru `iteratee`. The
                     * corresponding inverted value of each inverted key is an array of keys
                     * responsible for generating the inverted value. The iteratee is invoked
                     * with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.1.0
                     * @category Object
                     * @param {Object} object The object to invert.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {Object} Returns the new inverted object.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': 2, 'c': 1 };
                     *
                     * _.invertBy(object);
                     * // => { '1': ['a', 'c'], '2': ['b'] }
                     *
                     * _.invertBy(object, function(value) {
                     *   return 'group' + value;
                     * });
                     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
                     */
                    var invertBy = createInverter(function(result, value, key) {
                        if (value != null &&
                            typeof value.toString != 'function') {
                            value = nativeObjectToString.call(value);
                        }

                        if (hasOwnProperty.call(result, value)) {
                            result[value].push(key);
                        } else {
                            result[value] = [key];
                        }
                    }, getIteratee);

                    /**
                     * Invokes the method at `path` of `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path of the method to invoke.
                     * @param {...*} [args] The arguments to invoke the method with.
                     * @returns {*} Returns the result of the invoked method.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
                     *
                     * _.invoke(object, 'a[0].b.c.slice', 1, 3);
                     * // => [2, 3]
                     */
                    var invoke = baseRest(baseInvoke);

                    /**
                     * Creates an array of the own enumerable property names of `object`.
                     *
                     * **Note:** Non-object values are coerced to objects. See the
                     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
                     * for more details.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.keys(new Foo);
                     * // => ['a', 'b'] (iteration order is not guaranteed)
                     *
                     * _.keys('hi');
                     * // => ['0', '1']
                     */
                    function keys(object) {
                        return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
                    }

                    /**
                     * Creates an array of the own and inherited enumerable property names of `object`.
                     *
                     * **Note:** Non-object values are coerced to objects.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Object
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property names.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.keysIn(new Foo);
                     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
                     */
                    function keysIn(object) {
                        return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
                    }

                    /**
                     * The opposite of `_.mapValues`; this method creates an object with the
                     * same values as `object` and keys generated by running each own enumerable
                     * string keyed property of `object` thru `iteratee`. The iteratee is invoked
                     * with three arguments: (value, key, object).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.8.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Object} Returns the new mapped object.
                     * @see _.mapValues
                     * @example
                     *
                     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
                     *   return key + value;
                     * });
                     * // => { 'a1': 1, 'b2': 2 }
                     */
                    function mapKeys(object, iteratee) {
                        var result = {};
                        iteratee = getIteratee(iteratee, 3);

                        baseForOwn(object, function(value, key, object) {
                            baseAssignValue(result, iteratee(value, key, object), value);
                        });
                        return result;
                    }

                    /**
                     * Creates an object with the same keys as `object` and values generated
                     * by running each own enumerable string keyed property of `object` thru
                     * `iteratee`. The iteratee is invoked with three arguments:
                     * (value, key, object).
                     *
                     * @static
                     * @memberOf _
                     * @since 2.4.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Object} Returns the new mapped object.
                     * @see _.mapKeys
                     * @example
                     *
                     * var users = {
                     *   'fred':    { 'user': 'fred',    'age': 40 },
                     *   'pebbles': { 'user': 'pebbles', 'age': 1 }
                     * };
                     *
                     * _.mapValues(users, function(o) { return o.age; });
                     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.mapValues(users, 'age');
                     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
                     */
                    function mapValues(object, iteratee) {
                        var result = {};
                        iteratee = getIteratee(iteratee, 3);

                        baseForOwn(object, function(value, key, object) {
                            baseAssignValue(result, key, iteratee(value, key, object));
                        });
                        return result;
                    }

                    /**
                     * This method is like `_.assign` except that it recursively merges own and
                     * inherited enumerable string keyed properties of source objects into the
                     * destination object. Source properties that resolve to `undefined` are
                     * skipped if a destination value exists. Array and plain object properties
                     * are merged recursively. Other objects and value types are overridden by
                     * assignment. Source objects are applied from left to right. Subsequent
                     * sources overwrite property assignments of previous sources.
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.5.0
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} [sources] The source objects.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * var object = {
                     *   'a': [{ 'b': 2 }, { 'd': 4 }]
                     * };
                     *
                     * var other = {
                     *   'a': [{ 'c': 3 }, { 'e': 5 }]
                     * };
                     *
                     * _.merge(object, other);
                     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
                     */
                    var merge = createAssigner(function(object, source, srcIndex) {
                        baseMerge(object, source, srcIndex);
                    });

                    /**
                     * This method is like `_.merge` except that it accepts `customizer` which
                     * is invoked to produce the merged values of the destination and source
                     * properties. If `customizer` returns `undefined`, merging is handled by the
                     * method instead. The `customizer` is invoked with six arguments:
                     * (objValue, srcValue, key, object, source, stack).
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The destination object.
                     * @param {...Object} sources The source objects.
                     * @param {Function} customizer The function to customize assigned values.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * function customizer(objValue, srcValue) {
                     *   if (_.isArray(objValue)) {
                     *     return objValue.concat(srcValue);
                     *   }
                     * }
                     *
                     * var object = { 'a': [1], 'b': [2] };
                     * var other = { 'a': [3], 'b': [4] };
                     *
                     * _.mergeWith(object, other, customizer);
                     * // => { 'a': [1, 3], 'b': [2, 4] }
                     */
                    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
                        baseMerge(object, source, srcIndex, customizer);
                    });

                    /**
                     * The opposite of `_.pick`; this method creates an object composed of the
                     * own and inherited enumerable property paths of `object` that are not omitted.
                     *
                     * **Note:** This method is considerably slower than `_.pick`.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The source object.
                     * @param {...(string|string[])} [paths] The property paths to omit.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': '2', 'c': 3 };
                     *
                     * _.omit(object, ['a', 'c']);
                     * // => { 'b': '2' }
                     */
                    var omit = flatRest(function(object, paths) {
                        var result = {};
                        if (object == null) {
                            return result;
                        }
                        var isDeep = false;
                        paths = arrayMap(paths, function(path) {
                            path = castPath(path, object);
                            isDeep || (isDeep = path.length > 1);
                            return path;
                        });
                        copyObject(object, getAllKeysIn(object), result);
                        if (isDeep) {
                            result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
                        }
                        var length = paths.length;
                        while (length--) {
                            baseUnset(result, paths[length]);
                        }
                        return result;
                    });

                    /**
                     * The opposite of `_.pickBy`; this method creates an object composed of
                     * the own and inherited enumerable string keyed properties of `object` that
                     * `predicate` doesn't return truthy for. The predicate is invoked with two
                     * arguments: (value, key).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The source object.
                     * @param {Function} [predicate=_.identity] The function invoked per property.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': '2', 'c': 3 };
                     *
                     * _.omitBy(object, _.isNumber);
                     * // => { 'b': '2' }
                     */
                    function omitBy(object, predicate) {
                        return pickBy(object, negate(getIteratee(predicate)));
                    }

                    /**
                     * Creates an object composed of the picked `object` properties.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The source object.
                     * @param {...(string|string[])} [paths] The property paths to pick.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': '2', 'c': 3 };
                     *
                     * _.pick(object, ['a', 'c']);
                     * // => { 'a': 1, 'c': 3 }
                     */
                    var pick = flatRest(function(object, paths) {
                        return object == null ? {} : basePick(object, paths);
                    });

                    /**
                     * Creates an object composed of the `object` properties `predicate` returns
                     * truthy for. The predicate is invoked with two arguments: (value, key).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The source object.
                     * @param {Function} [predicate=_.identity] The function invoked per property.
                     * @returns {Object} Returns the new object.
                     * @example
                     *
                     * var object = { 'a': 1, 'b': '2', 'c': 3 };
                     *
                     * _.pickBy(object, _.isNumber);
                     * // => { 'a': 1, 'c': 3 }
                     */
                    function pickBy(object, predicate) {
                        if (object == null) {
                            return {};
                        }
                        var props = arrayMap(getAllKeysIn(object), function(prop) {
                            return [prop];
                        });
                        predicate = getIteratee(predicate);
                        return basePickBy(object, props, function(value, path) {
                            return predicate(value, path[0]);
                        });
                    }

                    /**
                     * This method is like `_.get` except that if the resolved value is a
                     * function it's invoked with the `this` binding of its parent object and
                     * its result is returned.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The object to query.
                     * @param {Array|string} path The path of the property to resolve.
                     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
                     * @returns {*} Returns the resolved value.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
                     *
                     * _.result(object, 'a[0].b.c1');
                     * // => 3
                     *
                     * _.result(object, 'a[0].b.c2');
                     * // => 4
                     *
                     * _.result(object, 'a[0].b.c3', 'default');
                     * // => 'default'
                     *
                     * _.result(object, 'a[0].b.c3', _.constant('default'));
                     * // => 'default'
                     */
                    function result(object, path, defaultValue) {
                        path = castPath(path, object);

                        var index = -1,
                            length = path.length;

                        // Ensure the loop is entered when path is empty.
                        if (!length) {
                            length = 1;
                            object = undefined;
                        }
                        while (++index < length) {
                            var value = object == null ? undefined : object[toKey(path[index])];
                            if (value === undefined) {
                                index = length;
                                value = defaultValue;
                            }
                            object = isFunction(value) ? value.call(object) : value;
                        }
                        return object;
                    }

                    /**
                     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
                     * it's created. Arrays are created for missing index properties while objects
                     * are created for all other missing properties. Use `_.setWith` to customize
                     * `path` creation.
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.7.0
                     * @category Object
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to set.
                     * @param {*} value The value to set.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
                     *
                     * _.set(object, 'a[0].b.c', 4);
                     * console.log(object.a[0].b.c);
                     * // => 4
                     *
                     * _.set(object, ['x', '0', 'y', 'z'], 5);
                     * console.log(object.x[0].y.z);
                     * // => 5
                     */
                    function set(object, path, value) {
                        return object == null ? object : baseSet(object, path, value);
                    }

                    /**
                     * This method is like `_.set` except that it accepts `customizer` which is
                     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
                     * path creation is handled by the method instead. The `customizer` is invoked
                     * with three arguments: (nsValue, key, nsObject).
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to set.
                     * @param {*} value The value to set.
                     * @param {Function} [customizer] The function to customize assigned values.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * var object = {};
                     *
                     * _.setWith(object, '[0][1]', 'a', Object);
                     * // => { '0': { '1': 'a' } }
                     */
                    function setWith(object, path, value, customizer) {
                        customizer = typeof customizer == 'function' ? customizer : undefined;
                        return object == null ? object : baseSet(object, path, value, customizer);
                    }

                    /**
                     * Creates an array of own enumerable string keyed-value pairs for `object`
                     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
                     * entries are returned.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @alias entries
                     * @category Object
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the key-value pairs.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.toPairs(new Foo);
                     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
                     */
                    var toPairs = createToPairs(keys);

                    /**
                     * Creates an array of own and inherited enumerable string keyed-value pairs
                     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
                     * or set, its entries are returned.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @alias entriesIn
                     * @category Object
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the key-value pairs.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.toPairsIn(new Foo);
                     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
                     */
                    var toPairsIn = createToPairs(keysIn);

                    /**
                     * An alternative to `_.reduce`; this method transforms `object` to a new
                     * `accumulator` object which is the result of running each of its own
                     * enumerable string keyed properties thru `iteratee`, with each invocation
                     * potentially mutating the `accumulator` object. If `accumulator` is not
                     * provided, a new object with the same `[[Prototype]]` will be used. The
                     * iteratee is invoked with four arguments: (accumulator, value, key, object).
                     * Iteratee functions may exit iteration early by explicitly returning `false`.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.3.0
                     * @category Object
                     * @param {Object} object The object to iterate over.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @param {*} [accumulator] The custom accumulator value.
                     * @returns {*} Returns the accumulated value.
                     * @example
                     *
                     * _.transform([2, 3, 4], function(result, n) {
                     *   result.push(n *= n);
                     *   return n % 2 == 0;
                     * }, []);
                     * // => [4, 9]
                     *
                     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
                     *   (result[value] || (result[value] = [])).push(key);
                     * }, {});
                     * // => { '1': ['a', 'c'], '2': ['b'] }
                     */
                    function transform(object, iteratee, accumulator) {
                        var isArr = isArray(object),
                            isArrLike = isArr || isBuffer(object) || isTypedArray(object);

                        iteratee = getIteratee(iteratee, 4);
                        if (accumulator == null) {
                            var Ctor = object && object.constructor;
                            if (isArrLike) {
                                accumulator = isArr ? new Ctor : [];
                            }
                            else if (isObject(object)) {
                                accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
                            }
                            else {
                                accumulator = {};
                            }
                        }
                        (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
                            return iteratee(accumulator, value, index, object);
                        });
                        return accumulator;
                    }

                    /**
                     * Removes the property at `path` of `object`.
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Object
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to unset.
                     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': 7 } }] };
                     * _.unset(object, 'a[0].b.c');
                     * // => true
                     *
                     * console.log(object);
                     * // => { 'a': [{ 'b': {} }] };
                     *
                     * _.unset(object, ['a', '0', 'b', 'c']);
                     * // => true
                     *
                     * console.log(object);
                     * // => { 'a': [{ 'b': {} }] };
                     */
                    function unset(object, path) {
                        return object == null ? true : baseUnset(object, path);
                    }

                    /**
                     * This method is like `_.set` except that accepts `updater` to produce the
                     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
                     * is invoked with one argument: (value).
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.6.0
                     * @category Object
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to set.
                     * @param {Function} updater The function to produce the updated value.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
                     *
                     * _.update(object, 'a[0].b.c', function(n) { return n * n; });
                     * console.log(object.a[0].b.c);
                     * // => 9
                     *
                     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
                     * console.log(object.x[0].y.z);
                     * // => 0
                     */
                    function update(object, path, updater) {
                        return object == null ? object : baseUpdate(object, path, castFunction(updater));
                    }

                    /**
                     * This method is like `_.update` except that it accepts `customizer` which is
                     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
                     * path creation is handled by the method instead. The `customizer` is invoked
                     * with three arguments: (nsValue, key, nsObject).
                     *
                     * **Note:** This method mutates `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.6.0
                     * @category Object
                     * @param {Object} object The object to modify.
                     * @param {Array|string} path The path of the property to set.
                     * @param {Function} updater The function to produce the updated value.
                     * @param {Function} [customizer] The function to customize assigned values.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * var object = {};
                     *
                     * _.updateWith(object, '[0][1]', _.constant('a'), Object);
                     * // => { '0': { '1': 'a' } }
                     */
                    function updateWith(object, path, updater, customizer) {
                        customizer = typeof customizer == 'function' ? customizer : undefined;
                        return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
                    }

                    /**
                     * Creates an array of the own enumerable string keyed property values of `object`.
                     *
                     * **Note:** Non-object values are coerced to objects.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Object
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property values.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.values(new Foo);
                     * // => [1, 2] (iteration order is not guaranteed)
                     *
                     * _.values('hi');
                     * // => ['h', 'i']
                     */
                    function values(object) {
                        return object == null ? [] : baseValues(object, keys(object));
                    }

                    /**
                     * Creates an array of the own and inherited enumerable string keyed property
                     * values of `object`.
                     *
                     * **Note:** Non-object values are coerced to objects.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Object
                     * @param {Object} object The object to query.
                     * @returns {Array} Returns the array of property values.
                     * @example
                     *
                     * function Foo() {
                     *   this.a = 1;
                     *   this.b = 2;
                     * }
                     *
                     * Foo.prototype.c = 3;
                     *
                     * _.valuesIn(new Foo);
                     * // => [1, 2, 3] (iteration order is not guaranteed)
                     */
                    function valuesIn(object) {
                        return object == null ? [] : baseValues(object, keysIn(object));
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Clamps `number` within the inclusive `lower` and `upper` bounds.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Number
                     * @param {number} number The number to clamp.
                     * @param {number} [lower] The lower bound.
                     * @param {number} upper The upper bound.
                     * @returns {number} Returns the clamped number.
                     * @example
                     *
                     * _.clamp(-10, -5, 5);
                     * // => -5
                     *
                     * _.clamp(10, -5, 5);
                     * // => 5
                     */
                    function clamp(number, lower, upper) {
                        if (upper === undefined) {
                            upper = lower;
                            lower = undefined;
                        }
                        if (upper !== undefined) {
                            upper = toNumber(upper);
                            upper = upper === upper ? upper : 0;
                        }
                        if (lower !== undefined) {
                            lower = toNumber(lower);
                            lower = lower === lower ? lower : 0;
                        }
                        return baseClamp(toNumber(number), lower, upper);
                    }

                    /**
                     * Checks if `n` is between `start` and up to, but not including, `end`. If
                     * `end` is not specified, it's set to `start` with `start` then set to `0`.
                     * If `start` is greater than `end` the params are swapped to support
                     * negative ranges.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.3.0
                     * @category Number
                     * @param {number} number The number to check.
                     * @param {number} [start=0] The start of the range.
                     * @param {number} end The end of the range.
                     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
                     * @see _.range, _.rangeRight
                     * @example
                     *
                     * _.inRange(3, 2, 4);
                     * // => true
                     *
                     * _.inRange(4, 8);
                     * // => true
                     *
                     * _.inRange(4, 2);
                     * // => false
                     *
                     * _.inRange(2, 2);
                     * // => false
                     *
                     * _.inRange(1.2, 2);
                     * // => true
                     *
                     * _.inRange(5.2, 4);
                     * // => false
                     *
                     * _.inRange(-3, -2, -6);
                     * // => true
                     */
                    function inRange(number, start, end) {
                        start = toFinite(start);
                        if (end === undefined) {
                            end = start;
                            start = 0;
                        } else {
                            end = toFinite(end);
                        }
                        number = toNumber(number);
                        return baseInRange(number, start, end);
                    }

                    /**
                     * Produces a random number between the inclusive `lower` and `upper` bounds.
                     * If only one argument is provided a number between `0` and the given number
                     * is returned. If `floating` is `true`, or either `lower` or `upper` are
                     * floats, a floating-point number is returned instead of an integer.
                     *
                     * **Note:** JavaScript follows the IEEE-754 standard for resolving
                     * floating-point values which can produce unexpected results.
                     *
                     * @static
                     * @memberOf _
                     * @since 0.7.0
                     * @category Number
                     * @param {number} [lower=0] The lower bound.
                     * @param {number} [upper=1] The upper bound.
                     * @param {boolean} [floating] Specify returning a floating-point number.
                     * @returns {number} Returns the random number.
                     * @example
                     *
                     * _.random(0, 5);
                     * // => an integer between 0 and 5
                     *
                     * _.random(5);
                     * // => also an integer between 0 and 5
                     *
                     * _.random(5, true);
                     * // => a floating-point number between 0 and 5
                     *
                     * _.random(1.2, 5.2);
                     * // => a floating-point number between 1.2 and 5.2
                     */
                    function random(lower, upper, floating) {
                        if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
                            upper = floating = undefined;
                        }
                        if (floating === undefined) {
                            if (typeof upper == 'boolean') {
                                floating = upper;
                                upper = undefined;
                            }
                            else if (typeof lower == 'boolean') {
                                floating = lower;
                                lower = undefined;
                            }
                        }
                        if (lower === undefined && upper === undefined) {
                            lower = 0;
                            upper = 1;
                        }
                        else {
                            lower = toFinite(lower);
                            if (upper === undefined) {
                                upper = lower;
                                lower = 0;
                            } else {
                                upper = toFinite(upper);
                            }
                        }
                        if (lower > upper) {
                            var temp = lower;
                            lower = upper;
                            upper = temp;
                        }
                        if (floating || lower % 1 || upper % 1) {
                            var rand = nativeRandom();
                            return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
                        }
                        return baseRandom(lower, upper);
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the camel cased string.
                     * @example
                     *
                     * _.camelCase('Foo Bar');
                     * // => 'fooBar'
                     *
                     * _.camelCase('--foo-bar--');
                     * // => 'fooBar'
                     *
                     * _.camelCase('__FOO_BAR__');
                     * // => 'fooBar'
                     */
                    var camelCase = createCompounder(function(result, word, index) {
                        word = word.toLowerCase();
                        return result + (index ? capitalize(word) : word);
                    });

                    /**
                     * Converts the first character of `string` to upper case and the remaining
                     * to lower case.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to capitalize.
                     * @returns {string} Returns the capitalized string.
                     * @example
                     *
                     * _.capitalize('FRED');
                     * // => 'Fred'
                     */
                    function capitalize(string) {
                        return upperFirst(toString(string).toLowerCase());
                    }

                    /**
                     * Deburrs `string` by converting
                     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
                     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
                     * letters to basic Latin letters and removing
                     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to deburr.
                     * @returns {string} Returns the deburred string.
                     * @example
                     *
                     * _.deburr('déjà vu');
                     * // => 'deja vu'
                     */
                    function deburr(string) {
                        string = toString(string);
                        return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
                    }

                    /**
                     * Checks if `string` ends with the given target string.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to inspect.
                     * @param {string} [target] The string to search for.
                     * @param {number} [position=string.length] The position to search up to.
                     * @returns {boolean} Returns `true` if `string` ends with `target`,
                     *  else `false`.
                     * @example
                     *
                     * _.endsWith('abc', 'c');
                     * // => true
                     *
                     * _.endsWith('abc', 'b');
                     * // => false
                     *
                     * _.endsWith('abc', 'b', 2);
                     * // => true
                     */
                    function endsWith(string, target, position) {
                        string = toString(string);
                        target = baseToString(target);

                        var length = string.length;
                        position = position === undefined
                            ? length
                            : baseClamp(toInteger(position), 0, length);

                        var end = position;
                        position -= target.length;
                        return position >= 0 && string.slice(position, end) == target;
                    }

                    /**
                     * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
                     * corresponding HTML entities.
                     *
                     * **Note:** No other characters are escaped. To escape additional
                     * characters use a third-party library like [_he_](https://mths.be/he).
                     *
                     * Though the ">" character is escaped for symmetry, characters like
                     * ">" and "/" don't need escaping in HTML and have no special meaning
                     * unless they're part of a tag or unquoted attribute value. See
                     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
                     * (under "semi-related fun fact") for more details.
                     *
                     * When working with HTML you should always
                     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
                     * XSS vectors.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category String
                     * @param {string} [string=''] The string to escape.
                     * @returns {string} Returns the escaped string.
                     * @example
                     *
                     * _.escape('fred, barney, & pebbles');
                     * // => 'fred, barney, &amp; pebbles'
                     */
                    function escape(string) {
                        string = toString(string);
                        return (string && reHasUnescapedHtml.test(string))
                            ? string.replace(reUnescapedHtml, escapeHtmlChar)
                            : string;
                    }

                    /**
                     * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
                     * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to escape.
                     * @returns {string} Returns the escaped string.
                     * @example
                     *
                     * _.escapeRegExp('[lodash](https://lodash.com/)');
                     * // => '\[lodash\]\(https://lodash\.com/\)'
                     */
                    function escapeRegExp(string) {
                        string = toString(string);
                        return (string && reHasRegExpChar.test(string))
                            ? string.replace(reRegExpChar, '\\$&')
                            : string;
                    }

                    /**
                     * Converts `string` to
                     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the kebab cased string.
                     * @example
                     *
                     * _.kebabCase('Foo Bar');
                     * // => 'foo-bar'
                     *
                     * _.kebabCase('fooBar');
                     * // => 'foo-bar'
                     *
                     * _.kebabCase('__FOO_BAR__');
                     * // => 'foo-bar'
                     */
                    var kebabCase = createCompounder(function(result, word, index) {
                        return result + (index ? '-' : '') + word.toLowerCase();
                    });

                    /**
                     * Converts `string`, as space separated words, to lower case.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the lower cased string.
                     * @example
                     *
                     * _.lowerCase('--Foo-Bar--');
                     * // => 'foo bar'
                     *
                     * _.lowerCase('fooBar');
                     * // => 'foo bar'
                     *
                     * _.lowerCase('__FOO_BAR__');
                     * // => 'foo bar'
                     */
                    var lowerCase = createCompounder(function(result, word, index) {
                        return result + (index ? ' ' : '') + word.toLowerCase();
                    });

                    /**
                     * Converts the first character of `string` to lower case.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the converted string.
                     * @example
                     *
                     * _.lowerFirst('Fred');
                     * // => 'fred'
                     *
                     * _.lowerFirst('FRED');
                     * // => 'fRED'
                     */
                    var lowerFirst = createCaseFirst('toLowerCase');

                    /**
                     * Pads `string` on the left and right sides if it's shorter than `length`.
                     * Padding characters are truncated if they can't be evenly divided by `length`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to pad.
                     * @param {number} [length=0] The padding length.
                     * @param {string} [chars=' '] The string used as padding.
                     * @returns {string} Returns the padded string.
                     * @example
                     *
                     * _.pad('abc', 8);
                     * // => '  abc   '
                     *
                     * _.pad('abc', 8, '_-');
                     * // => '_-abc_-_'
                     *
                     * _.pad('abc', 3);
                     * // => 'abc'
                     */
                    function pad(string, length, chars) {
                        string = toString(string);
                        length = toInteger(length);

                        var strLength = length ? stringSize(string) : 0;
                        if (!length || strLength >= length) {
                            return string;
                        }
                        var mid = (length - strLength) / 2;
                        return (
                            createPadding(nativeFloor(mid), chars) +
                            string +
                            createPadding(nativeCeil(mid), chars)
                        );
                    }

                    /**
                     * Pads `string` on the right side if it's shorter than `length`. Padding
                     * characters are truncated if they exceed `length`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to pad.
                     * @param {number} [length=0] The padding length.
                     * @param {string} [chars=' '] The string used as padding.
                     * @returns {string} Returns the padded string.
                     * @example
                     *
                     * _.padEnd('abc', 6);
                     * // => 'abc   '
                     *
                     * _.padEnd('abc', 6, '_-');
                     * // => 'abc_-_'
                     *
                     * _.padEnd('abc', 3);
                     * // => 'abc'
                     */
                    function padEnd(string, length, chars) {
                        string = toString(string);
                        length = toInteger(length);

                        var strLength = length ? stringSize(string) : 0;
                        return (length && strLength < length)
                            ? (string + createPadding(length - strLength, chars))
                            : string;
                    }

                    /**
                     * Pads `string` on the left side if it's shorter than `length`. Padding
                     * characters are truncated if they exceed `length`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to pad.
                     * @param {number} [length=0] The padding length.
                     * @param {string} [chars=' '] The string used as padding.
                     * @returns {string} Returns the padded string.
                     * @example
                     *
                     * _.padStart('abc', 6);
                     * // => '   abc'
                     *
                     * _.padStart('abc', 6, '_-');
                     * // => '_-_abc'
                     *
                     * _.padStart('abc', 3);
                     * // => 'abc'
                     */
                    function padStart(string, length, chars) {
                        string = toString(string);
                        length = toInteger(length);

                        var strLength = length ? stringSize(string) : 0;
                        return (length && strLength < length)
                            ? (createPadding(length - strLength, chars) + string)
                            : string;
                    }

                    /**
                     * Converts `string` to an integer of the specified radix. If `radix` is
                     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
                     * hexadecimal, in which case a `radix` of `16` is used.
                     *
                     * **Note:** This method aligns with the
                     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
                     *
                     * @static
                     * @memberOf _
                     * @since 1.1.0
                     * @category String
                     * @param {string} string The string to convert.
                     * @param {number} [radix=10] The radix to interpret `value` by.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {number} Returns the converted integer.
                     * @example
                     *
                     * _.parseInt('08');
                     * // => 8
                     *
                     * _.map(['6', '08', '10'], _.parseInt);
                     * // => [6, 8, 10]
                     */
                    function parseInt(string, radix, guard) {
                        if (guard || radix == null) {
                            radix = 0;
                        } else if (radix) {
                            radix = +radix;
                        }
                        return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
                    }

                    /**
                     * Repeats the given string `n` times.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to repeat.
                     * @param {number} [n=1] The number of times to repeat the string.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {string} Returns the repeated string.
                     * @example
                     *
                     * _.repeat('*', 3);
                     * // => '***'
                     *
                     * _.repeat('abc', 2);
                     * // => 'abcabc'
                     *
                     * _.repeat('abc', 0);
                     * // => ''
                     */
                    function repeat(string, n, guard) {
                        if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
                            n = 1;
                        } else {
                            n = toInteger(n);
                        }
                        return baseRepeat(toString(string), n);
                    }

                    /**
                     * Replaces matches for `pattern` in `string` with `replacement`.
                     *
                     * **Note:** This method is based on
                     * [`String#replace`](https://mdn.io/String/replace).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to modify.
                     * @param {RegExp|string} pattern The pattern to replace.
                     * @param {Function|string} replacement The match replacement.
                     * @returns {string} Returns the modified string.
                     * @example
                     *
                     * _.replace('Hi Fred', 'Fred', 'Barney');
                     * // => 'Hi Barney'
                     */
                    function replace() {
                        var args = arguments,
                            string = toString(args[0]);

                        return args.length < 3 ? string : string.replace(args[1], args[2]);
                    }

                    /**
                     * Converts `string` to
                     * [snake case](https://en.wikipedia.org/wiki/Snake_case).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the snake cased string.
                     * @example
                     *
                     * _.snakeCase('Foo Bar');
                     * // => 'foo_bar'
                     *
                     * _.snakeCase('fooBar');
                     * // => 'foo_bar'
                     *
                     * _.snakeCase('--FOO-BAR--');
                     * // => 'foo_bar'
                     */
                    var snakeCase = createCompounder(function(result, word, index) {
                        return result + (index ? '_' : '') + word.toLowerCase();
                    });

                    /**
                     * Splits `string` by `separator`.
                     *
                     * **Note:** This method is based on
                     * [`String#split`](https://mdn.io/String/split).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to split.
                     * @param {RegExp|string} separator The separator pattern to split by.
                     * @param {number} [limit] The length to truncate results to.
                     * @returns {Array} Returns the string segments.
                     * @example
                     *
                     * _.split('a-b-c', '-', 2);
                     * // => ['a', 'b']
                     */
                    function split(string, separator, limit) {
                        if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
                            separator = limit = undefined;
                        }
                        limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;
                        if (!limit) {
                            return [];
                        }
                        string = toString(string);
                        if (string && (
                            typeof separator == 'string' ||
                            (separator != null && !isRegExp(separator))
                        )) {
                            separator = baseToString(separator);
                            if (!separator && hasUnicode(string)) {
                                return castSlice(stringToArray(string), 0, limit);
                            }
                        }
                        return string.split(separator, limit);
                    }

                    /**
                     * Converts `string` to
                     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
                     *
                     * @static
                     * @memberOf _
                     * @since 3.1.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the start cased string.
                     * @example
                     *
                     * _.startCase('--foo-bar--');
                     * // => 'Foo Bar'
                     *
                     * _.startCase('fooBar');
                     * // => 'Foo Bar'
                     *
                     * _.startCase('__FOO_BAR__');
                     * // => 'FOO BAR'
                     */
                    var startCase = createCompounder(function(result, word, index) {
                        return result + (index ? ' ' : '') + upperFirst(word);
                    });

                    /**
                     * Checks if `string` starts with the given target string.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to inspect.
                     * @param {string} [target] The string to search for.
                     * @param {number} [position=0] The position to search from.
                     * @returns {boolean} Returns `true` if `string` starts with `target`,
                     *  else `false`.
                     * @example
                     *
                     * _.startsWith('abc', 'a');
                     * // => true
                     *
                     * _.startsWith('abc', 'b');
                     * // => false
                     *
                     * _.startsWith('abc', 'b', 1);
                     * // => true
                     */
                    function startsWith(string, target, position) {
                        string = toString(string);
                        position = position == null
                            ? 0
                            : baseClamp(toInteger(position), 0, string.length);

                        target = baseToString(target);
                        return string.slice(position, position + target.length) == target;
                    }

                    /**
                     * Creates a compiled template function that can interpolate data properties
                     * in "interpolate" delimiters, HTML-escape interpolated data properties in
                     * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
                     * properties may be accessed as free variables in the template. If a setting
                     * object is given, it takes precedence over `_.templateSettings` values.
                     *
                     * **Note:** In the development build `_.template` utilizes
                     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
                     * for easier debugging.
                     *
                     * For more information on precompiling templates see
                     * [lodash's custom builds documentation](https://lodash.com/custom-builds).
                     *
                     * For more information on Chrome extension sandboxes see
                     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category String
                     * @param {string} [string=''] The template string.
                     * @param {Object} [options={}] The options object.
                     * @param {RegExp} [options.escape=_.templateSettings.escape]
                     *  The HTML "escape" delimiter.
                     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
                     *  The "evaluate" delimiter.
                     * @param {Object} [options.imports=_.templateSettings.imports]
                     *  An object to import into the template as free variables.
                     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
                     *  The "interpolate" delimiter.
                     * @param {string} [options.sourceURL='lodash.templateSources[n]']
                     *  The sourceURL of the compiled template.
                     * @param {string} [options.variable='obj']
                     *  The data object variable name.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Function} Returns the compiled template function.
                     * @example
                     *
                     * // Use the "interpolate" delimiter to create a compiled template.
                     * var compiled = _.template('hello <%= user %>!');
                     * compiled({ 'user': 'fred' });
                     * // => 'hello fred!'
                     *
                     * // Use the HTML "escape" delimiter to escape data property values.
                     * var compiled = _.template('<b><%- value %></b>');
                     * compiled({ 'value': '<script>' });
                     * // => '<b>&lt;script&gt;</b>'
                     *
                     * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
                     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
                     * compiled({ 'users': ['fred', 'barney'] });
                     * // => '<li>fred</li><li>barney</li>'
                     *
                     * // Use the internal `print` function in "evaluate" delimiters.
                     * var compiled = _.template('<% print("hello " + user); %>!');
                     * compiled({ 'user': 'barney' });
                     * // => 'hello barney!'
                     *
                     * // Use the ES template literal delimiter as an "interpolate" delimiter.
                     * // Disable support by replacing the "interpolate" delimiter.
                     * var compiled = _.template('hello ${ user }!');
                     * compiled({ 'user': 'pebbles' });
                     * // => 'hello pebbles!'
                     *
                     * // Use backslashes to treat delimiters as plain text.
                     * var compiled = _.template('<%= "\\<%- value %\\>" %>');
                     * compiled({ 'value': 'ignored' });
                     * // => '<%- value %>'
                     *
                     * // Use the `imports` option to import `jQuery` as `jq`.
                     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
                     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
                     * compiled({ 'users': ['fred', 'barney'] });
                     * // => '<li>fred</li><li>barney</li>'
                     *
                     * // Use the `sourceURL` option to specify a custom sourceURL for the template.
                     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
                     * compiled(data);
                     * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
                     *
                     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
                     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
                     * compiled.source;
                     * // => function(data) {
                     * //   var __t, __p = '';
                     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
                     * //   return __p;
                     * // }
                     *
                     * // Use custom template delimiters.
                     * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
                     * var compiled = _.template('hello {{ user }}!');
                     * compiled({ 'user': 'mustache' });
                     * // => 'hello mustache!'
                     *
                     * // Use the `source` property to inline compiled templates for meaningful
                     * // line numbers in error messages and stack traces.
                     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
                     *   var JST = {\
                     *     "main": ' + _.template(mainText).source + '\
                     *   };\
                     * ');
                     */
                    function template(string, options, guard) {
                        // Based on John Resig's `tmpl` implementation
                        // (http://ejohn.org/blog/javascript-micro-templating/)
                        // and Laura Doktorova's doT.js (https://github.com/olado/doT).
                        var settings = lodash.templateSettings;

                        if (guard && isIterateeCall(string, options, guard)) {
                            options = undefined;
                        }
                        string = toString(string);
                        options = assignInWith({}, options, settings, customDefaultsAssignIn);

                        var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
                            importsKeys = keys(imports),
                            importsValues = baseValues(imports, importsKeys);

                        var isEscaping,
                            isEvaluating,
                            index = 0,
                            interpolate = options.interpolate || reNoMatch,
                            source = "__p += '";

                        // Compile the regexp to match each delimiter.
                        var reDelimiters = RegExp(
                            (options.escape || reNoMatch).source + '|' +
                            interpolate.source + '|' +
                            (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
                            (options.evaluate || reNoMatch).source + '|$'
                            , 'g');

                        // Use a sourceURL for easier debugging.
                        // The sourceURL gets injected into the source that's eval-ed, so be careful
                        // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in
                        // and escape the comment, thus injecting code that gets evaled.
                        var sourceURL = '//# sourceURL=' +
                            (hasOwnProperty.call(options, 'sourceURL')
                                    ? (options.sourceURL + '').replace(/\s/g, ' ')
                                    : ('lodash.templateSources[' + (++templateCounter) + ']')
                            ) + '\n';

                        string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
                            interpolateValue || (interpolateValue = esTemplateValue);

                            // Escape characters that can't be included in string literals.
                            source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);

                            // Replace delimiters with snippets.
                            if (escapeValue) {
                                isEscaping = true;
                                source += "' +\n__e(" + escapeValue + ") +\n'";
                            }
                            if (evaluateValue) {
                                isEvaluating = true;
                                source += "';\n" + evaluateValue + ";\n__p += '";
                            }
                            if (interpolateValue) {
                                source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
                            }
                            index = offset + match.length;

                            // The JS engine embedded in Adobe products needs `match` returned in
                            // order to produce the correct `offset` value.
                            return match;
                        });

                        source += "';\n";

                        // If `variable` is not specified wrap a with-statement around the generated
                        // code to add the data object to the top of the scope chain.
                        var variable = hasOwnProperty.call(options, 'variable') && options.variable;
                        if (!variable) {
                            source = 'with (obj) {\n' + source + '\n}\n';
                        }
                            // Throw an error if a forbidden character was found in `variable`, to prevent
                        // potential command injection attacks.
                        else if (reForbiddenIdentifierChars.test(variable)) {
                            throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
                        }

                        // Cleanup code by stripping empty strings.
                        source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
                            .replace(reEmptyStringMiddle, '$1')
                            .replace(reEmptyStringTrailing, '$1;');

                        // Frame code as the function body.
                        source = 'function(' + (variable || 'obj') + ') {\n' +
                            (variable
                                    ? ''
                                    : 'obj || (obj = {});\n'
                            ) +
                            "var __t, __p = ''" +
                            (isEscaping
                                    ? ', __e = _.escape'
                                    : ''
                            ) +
                            (isEvaluating
                                    ? ', __j = Array.prototype.join;\n' +
                                    "function print() { __p += __j.call(arguments, '') }\n"
                                    : ';\n'
                            ) +
                            source +
                            'return __p\n}';

                        var result = attempt(function() {
                            return Function(importsKeys, sourceURL + 'return ' + source)
                                .apply(undefined, importsValues);
                        });

                        // Provide the compiled function's source by its `toString` method or
                        // the `source` property as a convenience for inlining compiled templates.
                        result.source = source;
                        if (isError(result)) {
                            throw result;
                        }
                        return result;
                    }

                    /**
                     * Converts `string`, as a whole, to lower case just like
                     * [String#toLowerCase](https://mdn.io/toLowerCase).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the lower cased string.
                     * @example
                     *
                     * _.toLower('--Foo-Bar--');
                     * // => '--foo-bar--'
                     *
                     * _.toLower('fooBar');
                     * // => 'foobar'
                     *
                     * _.toLower('__FOO_BAR__');
                     * // => '__foo_bar__'
                     */
                    function toLower(value) {
                        return toString(value).toLowerCase();
                    }

                    /**
                     * Converts `string`, as a whole, to upper case just like
                     * [String#toUpperCase](https://mdn.io/toUpperCase).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the upper cased string.
                     * @example
                     *
                     * _.toUpper('--foo-bar--');
                     * // => '--FOO-BAR--'
                     *
                     * _.toUpper('fooBar');
                     * // => 'FOOBAR'
                     *
                     * _.toUpper('__foo_bar__');
                     * // => '__FOO_BAR__'
                     */
                    function toUpper(value) {
                        return toString(value).toUpperCase();
                    }

                    /**
                     * Removes leading and trailing whitespace or specified characters from `string`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to trim.
                     * @param {string} [chars=whitespace] The characters to trim.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {string} Returns the trimmed string.
                     * @example
                     *
                     * _.trim('  abc  ');
                     * // => 'abc'
                     *
                     * _.trim('-_-abc-_-', '_-');
                     * // => 'abc'
                     *
                     * _.map(['  foo  ', '  bar  '], _.trim);
                     * // => ['foo', 'bar']
                     */
                    function trim(string, chars, guard) {
                        string = toString(string);
                        if (string && (guard || chars === undefined)) {
                            return baseTrim(string);
                        }
                        if (!string || !(chars = baseToString(chars))) {
                            return string;
                        }
                        var strSymbols = stringToArray(string),
                            chrSymbols = stringToArray(chars),
                            start = charsStartIndex(strSymbols, chrSymbols),
                            end = charsEndIndex(strSymbols, chrSymbols) + 1;

                        return castSlice(strSymbols, start, end).join('');
                    }

                    /**
                     * Removes trailing whitespace or specified characters from `string`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to trim.
                     * @param {string} [chars=whitespace] The characters to trim.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {string} Returns the trimmed string.
                     * @example
                     *
                     * _.trimEnd('  abc  ');
                     * // => '  abc'
                     *
                     * _.trimEnd('-_-abc-_-', '_-');
                     * // => '-_-abc'
                     */
                    function trimEnd(string, chars, guard) {
                        string = toString(string);
                        if (string && (guard || chars === undefined)) {
                            return string.slice(0, trimmedEndIndex(string) + 1);
                        }
                        if (!string || !(chars = baseToString(chars))) {
                            return string;
                        }
                        var strSymbols = stringToArray(string),
                            end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;

                        return castSlice(strSymbols, 0, end).join('');
                    }

                    /**
                     * Removes leading whitespace or specified characters from `string`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to trim.
                     * @param {string} [chars=whitespace] The characters to trim.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {string} Returns the trimmed string.
                     * @example
                     *
                     * _.trimStart('  abc  ');
                     * // => 'abc  '
                     *
                     * _.trimStart('-_-abc-_-', '_-');
                     * // => 'abc-_-'
                     */
                    function trimStart(string, chars, guard) {
                        string = toString(string);
                        if (string && (guard || chars === undefined)) {
                            return string.replace(reTrimStart, '');
                        }
                        if (!string || !(chars = baseToString(chars))) {
                            return string;
                        }
                        var strSymbols = stringToArray(string),
                            start = charsStartIndex(strSymbols, stringToArray(chars));

                        return castSlice(strSymbols, start).join('');
                    }

                    /**
                     * Truncates `string` if it's longer than the given maximum string length.
                     * The last characters of the truncated string are replaced with the omission
                     * string which defaults to "...".
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to truncate.
                     * @param {Object} [options={}] The options object.
                     * @param {number} [options.length=30] The maximum string length.
                     * @param {string} [options.omission='...'] The string to indicate text is omitted.
                     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
                     * @returns {string} Returns the truncated string.
                     * @example
                     *
                     * _.truncate('hi-diddly-ho there, neighborino');
                     * // => 'hi-diddly-ho there, neighbo...'
                     *
                     * _.truncate('hi-diddly-ho there, neighborino', {
                     *   'length': 24,
                     *   'separator': ' '
                     * });
                     * // => 'hi-diddly-ho there,...'
                     *
                     * _.truncate('hi-diddly-ho there, neighborino', {
                     *   'length': 24,
                     *   'separator': /,? +/
                     * });
                     * // => 'hi-diddly-ho there...'
                     *
                     * _.truncate('hi-diddly-ho there, neighborino', {
                     *   'omission': ' [...]'
                     * });
                     * // => 'hi-diddly-ho there, neig [...]'
                     */
                    function truncate(string, options) {
                        var length = DEFAULT_TRUNC_LENGTH,
                            omission = DEFAULT_TRUNC_OMISSION;

                        if (isObject(options)) {
                            var separator = 'separator' in options ? options.separator : separator;
                            length = 'length' in options ? toInteger(options.length) : length;
                            omission = 'omission' in options ? baseToString(options.omission) : omission;
                        }
                        string = toString(string);

                        var strLength = string.length;
                        if (hasUnicode(string)) {
                            var strSymbols = stringToArray(string);
                            strLength = strSymbols.length;
                        }
                        if (length >= strLength) {
                            return string;
                        }
                        var end = length - stringSize(omission);
                        if (end < 1) {
                            return omission;
                        }
                        var result = strSymbols
                            ? castSlice(strSymbols, 0, end).join('')
                            : string.slice(0, end);

                        if (separator === undefined) {
                            return result + omission;
                        }
                        if (strSymbols) {
                            end += (result.length - end);
                        }
                        if (isRegExp(separator)) {
                            if (string.slice(end).search(separator)) {
                                var match,
                                    substring = result;

                                if (!separator.global) {
                                    separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
                                }
                                separator.lastIndex = 0;
                                while ((match = separator.exec(substring))) {
                                    var newEnd = match.index;
                                }
                                result = result.slice(0, newEnd === undefined ? end : newEnd);
                            }
                        } else if (string.indexOf(baseToString(separator), end) != end) {
                            var index = result.lastIndexOf(separator);
                            if (index > -1) {
                                result = result.slice(0, index);
                            }
                        }
                        return result + omission;
                    }

                    /**
                     * The inverse of `_.escape`; this method converts the HTML entities
                     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
                     * their corresponding characters.
                     *
                     * **Note:** No other HTML entities are unescaped. To unescape additional
                     * HTML entities use a third-party library like [_he_](https://mths.be/he).
                     *
                     * @static
                     * @memberOf _
                     * @since 0.6.0
                     * @category String
                     * @param {string} [string=''] The string to unescape.
                     * @returns {string} Returns the unescaped string.
                     * @example
                     *
                     * _.unescape('fred, barney, &amp; pebbles');
                     * // => 'fred, barney, & pebbles'
                     */
                    function unescape(string) {
                        string = toString(string);
                        return (string && reHasEscapedHtml.test(string))
                            ? string.replace(reEscapedHtml, unescapeHtmlChar)
                            : string;
                    }

                    /**
                     * Converts `string`, as space separated words, to upper case.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the upper cased string.
                     * @example
                     *
                     * _.upperCase('--foo-bar');
                     * // => 'FOO BAR'
                     *
                     * _.upperCase('fooBar');
                     * // => 'FOO BAR'
                     *
                     * _.upperCase('__foo_bar__');
                     * // => 'FOO BAR'
                     */
                    var upperCase = createCompounder(function(result, word, index) {
                        return result + (index ? ' ' : '') + word.toUpperCase();
                    });

                    /**
                     * Converts the first character of `string` to upper case.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category String
                     * @param {string} [string=''] The string to convert.
                     * @returns {string} Returns the converted string.
                     * @example
                     *
                     * _.upperFirst('fred');
                     * // => 'Fred'
                     *
                     * _.upperFirst('FRED');
                     * // => 'FRED'
                     */
                    var upperFirst = createCaseFirst('toUpperCase');

                    /**
                     * Splits `string` into an array of its words.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category String
                     * @param {string} [string=''] The string to inspect.
                     * @param {RegExp|string} [pattern] The pattern to match words.
                     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
                     * @returns {Array} Returns the words of `string`.
                     * @example
                     *
                     * _.words('fred, barney, & pebbles');
                     * // => ['fred', 'barney', 'pebbles']
                     *
                     * _.words('fred, barney, & pebbles', /[^, ]+/g);
                     * // => ['fred', 'barney', '&', 'pebbles']
                     */
                    function words(string, pattern, guard) {
                        string = toString(string);
                        pattern = guard ? undefined : pattern;

                        if (pattern === undefined) {
                            return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
                        }
                        return string.match(pattern) || [];
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Attempts to invoke `func`, returning either the result or the caught error
                     * object. Any additional arguments are provided to `func` when it's invoked.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Util
                     * @param {Function} func The function to attempt.
                     * @param {...*} [args] The arguments to invoke `func` with.
                     * @returns {*} Returns the `func` result or error object.
                     * @example
                     *
                     * // Avoid throwing errors for invalid selectors.
                     * var elements = _.attempt(function(selector) {
                     *   return document.querySelectorAll(selector);
                     * }, '>_>');
                     *
                     * if (_.isError(elements)) {
                     *   elements = [];
                     * }
                     */
                    var attempt = baseRest(function(func, args) {
                        try {
                            return apply(func, undefined, args);
                        } catch (e) {
                            return isError(e) ? e : new Error(e);
                        }
                    });

                    /**
                     * Binds methods of an object to the object itself, overwriting the existing
                     * method.
                     *
                     * **Note:** This method doesn't set the "length" property of bound functions.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @param {Object} object The object to bind and assign the bound methods to.
                     * @param {...(string|string[])} methodNames The object method names to bind.
                     * @returns {Object} Returns `object`.
                     * @example
                     *
                     * var view = {
                     *   'label': 'docs',
                     *   'click': function() {
                     *     console.log('clicked ' + this.label);
                     *   }
                     * };
                     *
                     * _.bindAll(view, ['click']);
                     * jQuery(element).on('click', view.click);
                     * // => Logs 'clicked docs' when clicked.
                     */
                    var bindAll = flatRest(function(object, methodNames) {
                        arrayEach(methodNames, function(key) {
                            key = toKey(key);
                            baseAssignValue(object, key, bind(object[key], object));
                        });
                        return object;
                    });

                    /**
                     * Creates a function that iterates over `pairs` and invokes the corresponding
                     * function of the first predicate to return truthy. The predicate-function
                     * pairs are invoked with the `this` binding and arguments of the created
                     * function.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {Array} pairs The predicate-function pairs.
                     * @returns {Function} Returns the new composite function.
                     * @example
                     *
                     * var func = _.cond([
                     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
                     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
                     *   [_.stubTrue,                      _.constant('no match')]
                     * ]);
                     *
                     * func({ 'a': 1, 'b': 2 });
                     * // => 'matches A'
                     *
                     * func({ 'a': 0, 'b': 1 });
                     * // => 'matches B'
                     *
                     * func({ 'a': '1', 'b': '2' });
                     * // => 'no match'
                     */
                    function cond(pairs) {
                        var length = pairs == null ? 0 : pairs.length,
                            toIteratee = getIteratee();

                        pairs = !length ? [] : arrayMap(pairs, function(pair) {
                            if (typeof pair[1] != 'function') {
                                throw new TypeError(FUNC_ERROR_TEXT);
                            }
                            return [toIteratee(pair[0]), pair[1]];
                        });

                        return baseRest(function(args) {
                            var index = -1;
                            while (++index < length) {
                                var pair = pairs[index];
                                if (apply(pair[0], this, args)) {
                                    return apply(pair[1], this, args);
                                }
                            }
                        });
                    }

                    /**
                     * Creates a function that invokes the predicate properties of `source` with
                     * the corresponding property values of a given object, returning `true` if
                     * all predicates return truthy, else `false`.
                     *
                     * **Note:** The created function is equivalent to `_.conformsTo` with
                     * `source` partially applied.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {Object} source The object of property predicates to conform to.
                     * @returns {Function} Returns the new spec function.
                     * @example
                     *
                     * var objects = [
                     *   { 'a': 2, 'b': 1 },
                     *   { 'a': 1, 'b': 2 }
                     * ];
                     *
                     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
                     * // => [{ 'a': 1, 'b': 2 }]
                     */
                    function conforms(source) {
                        return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
                    }

                    /**
                     * Creates a function that returns `value`.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.4.0
                     * @category Util
                     * @param {*} value The value to return from the new function.
                     * @returns {Function} Returns the new constant function.
                     * @example
                     *
                     * var objects = _.times(2, _.constant({ 'a': 1 }));
                     *
                     * console.log(objects);
                     * // => [{ 'a': 1 }, { 'a': 1 }]
                     *
                     * console.log(objects[0] === objects[1]);
                     * // => true
                     */
                    function constant(value) {
                        return function() {
                            return value;
                        };
                    }

                    /**
                     * Checks `value` to determine whether a default value should be returned in
                     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
                     * or `undefined`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.14.0
                     * @category Util
                     * @param {*} value The value to check.
                     * @param {*} defaultValue The default value.
                     * @returns {*} Returns the resolved value.
                     * @example
                     *
                     * _.defaultTo(1, 10);
                     * // => 1
                     *
                     * _.defaultTo(undefined, 10);
                     * // => 10
                     */
                    function defaultTo(value, defaultValue) {
                        return (value == null || value !== value) ? defaultValue : value;
                    }

                    /**
                     * Creates a function that returns the result of invoking the given functions
                     * with the `this` binding of the created function, where each successive
                     * invocation is supplied the return value of the previous.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Util
                     * @param {...(Function|Function[])} [funcs] The functions to invoke.
                     * @returns {Function} Returns the new composite function.
                     * @see _.flowRight
                     * @example
                     *
                     * function square(n) {
                     *   return n * n;
                     * }
                     *
                     * var addSquare = _.flow([_.add, square]);
                     * addSquare(1, 2);
                     * // => 9
                     */
                    var flow = createFlow();

                    /**
                     * This method is like `_.flow` except that it creates a function that
                     * invokes the given functions from right to left.
                     *
                     * @static
                     * @since 3.0.0
                     * @memberOf _
                     * @category Util
                     * @param {...(Function|Function[])} [funcs] The functions to invoke.
                     * @returns {Function} Returns the new composite function.
                     * @see _.flow
                     * @example
                     *
                     * function square(n) {
                     *   return n * n;
                     * }
                     *
                     * var addSquare = _.flowRight([square, _.add]);
                     * addSquare(1, 2);
                     * // => 9
                     */
                    var flowRight = createFlow(true);

                    /**
                     * This method returns the first argument it receives.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @param {*} value Any value.
                     * @returns {*} Returns `value`.
                     * @example
                     *
                     * var object = { 'a': 1 };
                     *
                     * console.log(_.identity(object) === object);
                     * // => true
                     */
                    function identity(value) {
                        return value;
                    }

                    /**
                     * Creates a function that invokes `func` with the arguments of the created
                     * function. If `func` is a property name, the created function returns the
                     * property value for a given element. If `func` is an array or object, the
                     * created function returns `true` for elements that contain the equivalent
                     * source properties, otherwise it returns `false`.
                     *
                     * @static
                     * @since 4.0.0
                     * @memberOf _
                     * @category Util
                     * @param {*} [func=_.identity] The value to convert to a callback.
                     * @returns {Function} Returns the callback.
                     * @example
                     *
                     * var users = [
                     *   { 'user': 'barney', 'age': 36, 'active': true },
                     *   { 'user': 'fred',   'age': 40, 'active': false }
                     * ];
                     *
                     * // The `_.matches` iteratee shorthand.
                     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
                     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
                     *
                     * // The `_.matchesProperty` iteratee shorthand.
                     * _.filter(users, _.iteratee(['user', 'fred']));
                     * // => [{ 'user': 'fred', 'age': 40 }]
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.map(users, _.iteratee('user'));
                     * // => ['barney', 'fred']
                     *
                     * // Create custom iteratee shorthands.
                     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
                     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
                     *     return func.test(string);
                     *   };
                     * });
                     *
                     * _.filter(['abc', 'def'], /ef/);
                     * // => ['def']
                     */
                    function iteratee(func) {
                        return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
                    }

                    /**
                     * Creates a function that performs a partial deep comparison between a given
                     * object and `source`, returning `true` if the given object has equivalent
                     * property values, else `false`.
                     *
                     * **Note:** The created function is equivalent to `_.isMatch` with `source`
                     * partially applied.
                     *
                     * Partial comparisons will match empty array and empty object `source`
                     * values against any array or object value, respectively. See `_.isEqual`
                     * for a list of supported value comparisons.
                     *
                     * **Note:** Multiple values can be checked by combining several matchers
                     * using `_.overSome`
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Util
                     * @param {Object} source The object of property values to match.
                     * @returns {Function} Returns the new spec function.
                     * @example
                     *
                     * var objects = [
                     *   { 'a': 1, 'b': 2, 'c': 3 },
                     *   { 'a': 4, 'b': 5, 'c': 6 }
                     * ];
                     *
                     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
                     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
                     *
                     * // Checking for several possible values
                     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
                     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
                     */
                    function matches(source) {
                        return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
                    }

                    /**
                     * Creates a function that performs a partial deep comparison between the
                     * value at `path` of a given object to `srcValue`, returning `true` if the
                     * object value is equivalent, else `false`.
                     *
                     * **Note:** Partial comparisons will match empty array and empty object
                     * `srcValue` values against any array or object value, respectively. See
                     * `_.isEqual` for a list of supported value comparisons.
                     *
                     * **Note:** Multiple values can be checked by combining several matchers
                     * using `_.overSome`
                     *
                     * @static
                     * @memberOf _
                     * @since 3.2.0
                     * @category Util
                     * @param {Array|string} path The path of the property to get.
                     * @param {*} srcValue The value to match.
                     * @returns {Function} Returns the new spec function.
                     * @example
                     *
                     * var objects = [
                     *   { 'a': 1, 'b': 2, 'c': 3 },
                     *   { 'a': 4, 'b': 5, 'c': 6 }
                     * ];
                     *
                     * _.find(objects, _.matchesProperty('a', 4));
                     * // => { 'a': 4, 'b': 5, 'c': 6 }
                     *
                     * // Checking for several possible values
                     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));
                     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
                     */
                    function matchesProperty(path, srcValue) {
                        return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
                    }

                    /**
                     * Creates a function that invokes the method at `path` of a given object.
                     * Any additional arguments are provided to the invoked method.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.7.0
                     * @category Util
                     * @param {Array|string} path The path of the method to invoke.
                     * @param {...*} [args] The arguments to invoke the method with.
                     * @returns {Function} Returns the new invoker function.
                     * @example
                     *
                     * var objects = [
                     *   { 'a': { 'b': _.constant(2) } },
                     *   { 'a': { 'b': _.constant(1) } }
                     * ];
                     *
                     * _.map(objects, _.method('a.b'));
                     * // => [2, 1]
                     *
                     * _.map(objects, _.method(['a', 'b']));
                     * // => [2, 1]
                     */
                    var method = baseRest(function(path, args) {
                        return function(object) {
                            return baseInvoke(object, path, args);
                        };
                    });

                    /**
                     * The opposite of `_.method`; this method creates a function that invokes
                     * the method at a given path of `object`. Any additional arguments are
                     * provided to the invoked method.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.7.0
                     * @category Util
                     * @param {Object} object The object to query.
                     * @param {...*} [args] The arguments to invoke the method with.
                     * @returns {Function} Returns the new invoker function.
                     * @example
                     *
                     * var array = _.times(3, _.constant),
                     *     object = { 'a': array, 'b': array, 'c': array };
                     *
                     * _.map(['a[2]', 'c[0]'], _.methodOf(object));
                     * // => [2, 0]
                     *
                     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
                     * // => [2, 0]
                     */
                    var methodOf = baseRest(function(object, args) {
                        return function(path) {
                            return baseInvoke(object, path, args);
                        };
                    });

                    /**
                     * Adds all own enumerable string keyed function properties of a source
                     * object to the destination object. If `object` is a function, then methods
                     * are added to its prototype as well.
                     *
                     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
                     * avoid conflicts caused by modifying the original.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @param {Function|Object} [object=lodash] The destination object.
                     * @param {Object} source The object of functions to add.
                     * @param {Object} [options={}] The options object.
                     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
                     * @returns {Function|Object} Returns `object`.
                     * @example
                     *
                     * function vowels(string) {
                     *   return _.filter(string, function(v) {
                     *     return /[aeiou]/i.test(v);
                     *   });
                     * }
                     *
                     * _.mixin({ 'vowels': vowels });
                     * _.vowels('fred');
                     * // => ['e']
                     *
                     * _('fred').vowels().value();
                     * // => ['e']
                     *
                     * _.mixin({ 'vowels': vowels }, { 'chain': false });
                     * _('fred').vowels();
                     * // => ['e']
                     */
                    function mixin(object, source, options) {
                        var props = keys(source),
                            methodNames = baseFunctions(source, props);

                        if (options == null &&
                            !(isObject(source) && (methodNames.length || !props.length))) {
                            options = source;
                            source = object;
                            object = this;
                            methodNames = baseFunctions(source, keys(source));
                        }
                        var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
                            isFunc = isFunction(object);

                        arrayEach(methodNames, function(methodName) {
                            var func = source[methodName];
                            object[methodName] = func;
                            if (isFunc) {
                                object.prototype[methodName] = function() {
                                    var chainAll = this.__chain__;
                                    if (chain || chainAll) {
                                        var result = object(this.__wrapped__),
                                            actions = result.__actions__ = copyArray(this.__actions__);

                                        actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
                                        result.__chain__ = chainAll;
                                        return result;
                                    }
                                    return func.apply(object, arrayPush([this.value()], arguments));
                                };
                            }
                        });

                        return object;
                    }

                    /**
                     * Reverts the `_` variable to its previous value and returns a reference to
                     * the `lodash` function.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @returns {Function} Returns the `lodash` function.
                     * @example
                     *
                     * var lodash = _.noConflict();
                     */
                    function noConflict() {
                        if (root._ === this) {
                            root._ = oldDash;
                        }
                        return this;
                    }

                    /**
                     * This method returns `undefined`.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.3.0
                     * @category Util
                     * @example
                     *
                     * _.times(2, _.noop);
                     * // => [undefined, undefined]
                     */
                    function noop() {
                        // No operation performed.
                    }

                    /**
                     * Creates a function that gets the argument at index `n`. If `n` is negative,
                     * the nth argument from the end is returned.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {number} [n=0] The index of the argument to return.
                     * @returns {Function} Returns the new pass-thru function.
                     * @example
                     *
                     * var func = _.nthArg(1);
                     * func('a', 'b', 'c', 'd');
                     * // => 'b'
                     *
                     * var func = _.nthArg(-2);
                     * func('a', 'b', 'c', 'd');
                     * // => 'c'
                     */
                    function nthArg(n) {
                        n = toInteger(n);
                        return baseRest(function(args) {
                            return baseNth(args, n);
                        });
                    }

                    /**
                     * Creates a function that invokes `iteratees` with the arguments it receives
                     * and returns their results.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {...(Function|Function[])} [iteratees=[_.identity]]
                     *  The iteratees to invoke.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var func = _.over([Math.max, Math.min]);
                     *
                     * func(1, 2, 3, 4);
                     * // => [4, 1]
                     */
                    var over = createOver(arrayMap);

                    /**
                     * Creates a function that checks if **all** of the `predicates` return
                     * truthy when invoked with the arguments it receives.
                     *
                     * Following shorthands are possible for providing predicates.
                     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
                     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {...(Function|Function[])} [predicates=[_.identity]]
                     *  The predicates to check.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var func = _.overEvery([Boolean, isFinite]);
                     *
                     * func('1');
                     * // => true
                     *
                     * func(null);
                     * // => false
                     *
                     * func(NaN);
                     * // => false
                     */
                    var overEvery = createOver(arrayEvery);

                    /**
                     * Creates a function that checks if **any** of the `predicates` return
                     * truthy when invoked with the arguments it receives.
                     *
                     * Following shorthands are possible for providing predicates.
                     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
                     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {...(Function|Function[])} [predicates=[_.identity]]
                     *  The predicates to check.
                     * @returns {Function} Returns the new function.
                     * @example
                     *
                     * var func = _.overSome([Boolean, isFinite]);
                     *
                     * func('1');
                     * // => true
                     *
                     * func(null);
                     * // => true
                     *
                     * func(NaN);
                     * // => false
                     *
                     * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])
                     * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])
                     */
                    var overSome = createOver(arraySome);

                    /**
                     * Creates a function that returns the value at `path` of a given object.
                     *
                     * @static
                     * @memberOf _
                     * @since 2.4.0
                     * @category Util
                     * @param {Array|string} path The path of the property to get.
                     * @returns {Function} Returns the new accessor function.
                     * @example
                     *
                     * var objects = [
                     *   { 'a': { 'b': 2 } },
                     *   { 'a': { 'b': 1 } }
                     * ];
                     *
                     * _.map(objects, _.property('a.b'));
                     * // => [2, 1]
                     *
                     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
                     * // => [1, 2]
                     */
                    function property(path) {
                        return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
                    }

                    /**
                     * The opposite of `_.property`; this method creates a function that returns
                     * the value at a given path of `object`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.0.0
                     * @category Util
                     * @param {Object} object The object to query.
                     * @returns {Function} Returns the new accessor function.
                     * @example
                     *
                     * var array = [0, 1, 2],
                     *     object = { 'a': array, 'b': array, 'c': array };
                     *
                     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
                     * // => [2, 0]
                     *
                     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
                     * // => [2, 0]
                     */
                    function propertyOf(object) {
                        return function(path) {
                            return object == null ? undefined : baseGet(object, path);
                        };
                    }

                    /**
                     * Creates an array of numbers (positive and/or negative) progressing from
                     * `start` up to, but not including, `end`. A step of `-1` is used if a negative
                     * `start` is specified without an `end` or `step`. If `end` is not specified,
                     * it's set to `start` with `start` then set to `0`.
                     *
                     * **Note:** JavaScript follows the IEEE-754 standard for resolving
                     * floating-point values which can produce unexpected results.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @param {number} [start=0] The start of the range.
                     * @param {number} end The end of the range.
                     * @param {number} [step=1] The value to increment or decrement by.
                     * @returns {Array} Returns the range of numbers.
                     * @see _.inRange, _.rangeRight
                     * @example
                     *
                     * _.range(4);
                     * // => [0, 1, 2, 3]
                     *
                     * _.range(-4);
                     * // => [0, -1, -2, -3]
                     *
                     * _.range(1, 5);
                     * // => [1, 2, 3, 4]
                     *
                     * _.range(0, 20, 5);
                     * // => [0, 5, 10, 15]
                     *
                     * _.range(0, -4, -1);
                     * // => [0, -1, -2, -3]
                     *
                     * _.range(1, 4, 0);
                     * // => [1, 1, 1]
                     *
                     * _.range(0);
                     * // => []
                     */
                    var range = createRange();

                    /**
                     * This method is like `_.range` except that it populates values in
                     * descending order.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {number} [start=0] The start of the range.
                     * @param {number} end The end of the range.
                     * @param {number} [step=1] The value to increment or decrement by.
                     * @returns {Array} Returns the range of numbers.
                     * @see _.inRange, _.range
                     * @example
                     *
                     * _.rangeRight(4);
                     * // => [3, 2, 1, 0]
                     *
                     * _.rangeRight(-4);
                     * // => [-3, -2, -1, 0]
                     *
                     * _.rangeRight(1, 5);
                     * // => [4, 3, 2, 1]
                     *
                     * _.rangeRight(0, 20, 5);
                     * // => [15, 10, 5, 0]
                     *
                     * _.rangeRight(0, -4, -1);
                     * // => [-3, -2, -1, 0]
                     *
                     * _.rangeRight(1, 4, 0);
                     * // => [1, 1, 1]
                     *
                     * _.rangeRight(0);
                     * // => []
                     */
                    var rangeRight = createRange(true);

                    /**
                     * This method returns a new empty array.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.13.0
                     * @category Util
                     * @returns {Array} Returns the new empty array.
                     * @example
                     *
                     * var arrays = _.times(2, _.stubArray);
                     *
                     * console.log(arrays);
                     * // => [[], []]
                     *
                     * console.log(arrays[0] === arrays[1]);
                     * // => false
                     */
                    function stubArray() {
                        return [];
                    }

                    /**
                     * This method returns `false`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.13.0
                     * @category Util
                     * @returns {boolean} Returns `false`.
                     * @example
                     *
                     * _.times(2, _.stubFalse);
                     * // => [false, false]
                     */
                    function stubFalse() {
                        return false;
                    }

                    /**
                     * This method returns a new empty object.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.13.0
                     * @category Util
                     * @returns {Object} Returns the new empty object.
                     * @example
                     *
                     * var objects = _.times(2, _.stubObject);
                     *
                     * console.log(objects);
                     * // => [{}, {}]
                     *
                     * console.log(objects[0] === objects[1]);
                     * // => false
                     */
                    function stubObject() {
                        return {};
                    }

                    /**
                     * This method returns an empty string.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.13.0
                     * @category Util
                     * @returns {string} Returns the empty string.
                     * @example
                     *
                     * _.times(2, _.stubString);
                     * // => ['', '']
                     */
                    function stubString() {
                        return '';
                    }

                    /**
                     * This method returns `true`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.13.0
                     * @category Util
                     * @returns {boolean} Returns `true`.
                     * @example
                     *
                     * _.times(2, _.stubTrue);
                     * // => [true, true]
                     */
                    function stubTrue() {
                        return true;
                    }

                    /**
                     * Invokes the iteratee `n` times, returning an array of the results of
                     * each invocation. The iteratee is invoked with one argument; (index).
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @param {number} n The number of times to invoke `iteratee`.
                     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
                     * @returns {Array} Returns the array of results.
                     * @example
                     *
                     * _.times(3, String);
                     * // => ['0', '1', '2']
                     *
                     *  _.times(4, _.constant(0));
                     * // => [0, 0, 0, 0]
                     */
                    function times(n, iteratee) {
                        n = toInteger(n);
                        if (n < 1 || n > MAX_SAFE_INTEGER) {
                            return [];
                        }
                        var index = MAX_ARRAY_LENGTH,
                            length = nativeMin(n, MAX_ARRAY_LENGTH);

                        iteratee = getIteratee(iteratee);
                        n -= MAX_ARRAY_LENGTH;

                        var result = baseTimes(length, iteratee);
                        while (++index < n) {
                            iteratee(index);
                        }
                        return result;
                    }

                    /**
                     * Converts `value` to a property path array.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Util
                     * @param {*} value The value to convert.
                     * @returns {Array} Returns the new property path array.
                     * @example
                     *
                     * _.toPath('a.b.c');
                     * // => ['a', 'b', 'c']
                     *
                     * _.toPath('a[0].b.c');
                     * // => ['a', '0', 'b', 'c']
                     */
                    function toPath(value) {
                        if (isArray(value)) {
                            return arrayMap(value, toKey);
                        }
                        return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
                    }

                    /**
                     * Generates a unique ID. If `prefix` is given, the ID is appended to it.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Util
                     * @param {string} [prefix=''] The value to prefix the ID with.
                     * @returns {string} Returns the unique ID.
                     * @example
                     *
                     * _.uniqueId('contact_');
                     * // => 'contact_104'
                     *
                     * _.uniqueId();
                     * // => '105'
                     */
                    function uniqueId(prefix) {
                        var id = ++idCounter;
                        return toString(prefix) + id;
                    }

                    /*------------------------------------------------------------------------*/

                    /**
                     * Adds two numbers.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.4.0
                     * @category Math
                     * @param {number} augend The first number in an addition.
                     * @param {number} addend The second number in an addition.
                     * @returns {number} Returns the total.
                     * @example
                     *
                     * _.add(6, 4);
                     * // => 10
                     */
                    var add = createMathOperation(function(augend, addend) {
                        return augend + addend;
                    }, 0);

                    /**
                     * Computes `number` rounded up to `precision`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.10.0
                     * @category Math
                     * @param {number} number The number to round up.
                     * @param {number} [precision=0] The precision to round up to.
                     * @returns {number} Returns the rounded up number.
                     * @example
                     *
                     * _.ceil(4.006);
                     * // => 5
                     *
                     * _.ceil(6.004, 2);
                     * // => 6.01
                     *
                     * _.ceil(6040, -2);
                     * // => 6100
                     */
                    var ceil = createRound('ceil');

                    /**
                     * Divide two numbers.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.7.0
                     * @category Math
                     * @param {number} dividend The first number in a division.
                     * @param {number} divisor The second number in a division.
                     * @returns {number} Returns the quotient.
                     * @example
                     *
                     * _.divide(6, 4);
                     * // => 1.5
                     */
                    var divide = createMathOperation(function(dividend, divisor) {
                        return dividend / divisor;
                    }, 1);

                    /**
                     * Computes `number` rounded down to `precision`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.10.0
                     * @category Math
                     * @param {number} number The number to round down.
                     * @param {number} [precision=0] The precision to round down to.
                     * @returns {number} Returns the rounded down number.
                     * @example
                     *
                     * _.floor(4.006);
                     * // => 4
                     *
                     * _.floor(0.046, 2);
                     * // => 0.04
                     *
                     * _.floor(4060, -2);
                     * // => 4000
                     */
                    var floor = createRound('floor');

                    /**
                     * Computes the maximum value of `array`. If `array` is empty or falsey,
                     * `undefined` is returned.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @returns {*} Returns the maximum value.
                     * @example
                     *
                     * _.max([4, 2, 8, 6]);
                     * // => 8
                     *
                     * _.max([]);
                     * // => undefined
                     */
                    function max(array) {
                        return (array && array.length)
                            ? baseExtremum(array, identity, baseGt)
                            : undefined;
                    }

                    /**
                     * This method is like `_.max` except that it accepts `iteratee` which is
                     * invoked for each element in `array` to generate the criterion by which
                     * the value is ranked. The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {*} Returns the maximum value.
                     * @example
                     *
                     * var objects = [{ 'n': 1 }, { 'n': 2 }];
                     *
                     * _.maxBy(objects, function(o) { return o.n; });
                     * // => { 'n': 2 }
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.maxBy(objects, 'n');
                     * // => { 'n': 2 }
                     */
                    function maxBy(array, iteratee) {
                        return (array && array.length)
                            ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
                            : undefined;
                    }

                    /**
                     * Computes the mean of the values in `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @returns {number} Returns the mean.
                     * @example
                     *
                     * _.mean([4, 2, 8, 6]);
                     * // => 5
                     */
                    function mean(array) {
                        return baseMean(array, identity);
                    }

                    /**
                     * This method is like `_.mean` except that it accepts `iteratee` which is
                     * invoked for each element in `array` to generate the value to be averaged.
                     * The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.7.0
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {number} Returns the mean.
                     * @example
                     *
                     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
                     *
                     * _.meanBy(objects, function(o) { return o.n; });
                     * // => 5
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.meanBy(objects, 'n');
                     * // => 5
                     */
                    function meanBy(array, iteratee) {
                        return baseMean(array, getIteratee(iteratee, 2));
                    }

                    /**
                     * Computes the minimum value of `array`. If `array` is empty or falsey,
                     * `undefined` is returned.
                     *
                     * @static
                     * @since 0.1.0
                     * @memberOf _
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @returns {*} Returns the minimum value.
                     * @example
                     *
                     * _.min([4, 2, 8, 6]);
                     * // => 2
                     *
                     * _.min([]);
                     * // => undefined
                     */
                    function min(array) {
                        return (array && array.length)
                            ? baseExtremum(array, identity, baseLt)
                            : undefined;
                    }

                    /**
                     * This method is like `_.min` except that it accepts `iteratee` which is
                     * invoked for each element in `array` to generate the criterion by which
                     * the value is ranked. The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {*} Returns the minimum value.
                     * @example
                     *
                     * var objects = [{ 'n': 1 }, { 'n': 2 }];
                     *
                     * _.minBy(objects, function(o) { return o.n; });
                     * // => { 'n': 1 }
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.minBy(objects, 'n');
                     * // => { 'n': 1 }
                     */
                    function minBy(array, iteratee) {
                        return (array && array.length)
                            ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
                            : undefined;
                    }

                    /**
                     * Multiply two numbers.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.7.0
                     * @category Math
                     * @param {number} multiplier The first number in a multiplication.
                     * @param {number} multiplicand The second number in a multiplication.
                     * @returns {number} Returns the product.
                     * @example
                     *
                     * _.multiply(6, 4);
                     * // => 24
                     */
                    var multiply = createMathOperation(function(multiplier, multiplicand) {
                        return multiplier * multiplicand;
                    }, 1);

                    /**
                     * Computes `number` rounded to `precision`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.10.0
                     * @category Math
                     * @param {number} number The number to round.
                     * @param {number} [precision=0] The precision to round to.
                     * @returns {number} Returns the rounded number.
                     * @example
                     *
                     * _.round(4.006);
                     * // => 4
                     *
                     * _.round(4.006, 2);
                     * // => 4.01
                     *
                     * _.round(4060, -2);
                     * // => 4100
                     */
                    var round = createRound('round');

                    /**
                     * Subtract two numbers.
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Math
                     * @param {number} minuend The first number in a subtraction.
                     * @param {number} subtrahend The second number in a subtraction.
                     * @returns {number} Returns the difference.
                     * @example
                     *
                     * _.subtract(6, 4);
                     * // => 2
                     */
                    var subtract = createMathOperation(function(minuend, subtrahend) {
                        return minuend - subtrahend;
                    }, 0);

                    /**
                     * Computes the sum of the values in `array`.
                     *
                     * @static
                     * @memberOf _
                     * @since 3.4.0
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @returns {number} Returns the sum.
                     * @example
                     *
                     * _.sum([4, 2, 8, 6]);
                     * // => 20
                     */
                    function sum(array) {
                        return (array && array.length)
                            ? baseSum(array, identity)
                            : 0;
                    }

                    /**
                     * This method is like `_.sum` except that it accepts `iteratee` which is
                     * invoked for each element in `array` to generate the value to be summed.
                     * The iteratee is invoked with one argument: (value).
                     *
                     * @static
                     * @memberOf _
                     * @since 4.0.0
                     * @category Math
                     * @param {Array} array The array to iterate over.
                     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
                     * @returns {number} Returns the sum.
                     * @example
                     *
                     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
                     *
                     * _.sumBy(objects, function(o) { return o.n; });
                     * // => 20
                     *
                     * // The `_.property` iteratee shorthand.
                     * _.sumBy(objects, 'n');
                     * // => 20
                     */
                    function sumBy(array, iteratee) {
                        return (array && array.length)
                            ? baseSum(array, getIteratee(iteratee, 2))
                            : 0;
                    }

                    /*------------------------------------------------------------------------*/

                    // Add methods that return wrapped values in chain sequences.
                    lodash.after = after;
                    lodash.ary = ary;
                    lodash.assign = assign;
                    lodash.assignIn = assignIn;
                    lodash.assignInWith = assignInWith;
                    lodash.assignWith = assignWith;
                    lodash.at = at;
                    lodash.before = before;
                    lodash.bind = bind;
                    lodash.bindAll = bindAll;
                    lodash.bindKey = bindKey;
                    lodash.castArray = castArray;
                    lodash.chain = chain;
                    lodash.chunk = chunk;
                    lodash.compact = compact;
                    lodash.concat = concat;
                    lodash.cond = cond;
                    lodash.conforms = conforms;
                    lodash.constant = constant;
                    lodash.countBy = countBy;
                    lodash.create = create;
                    lodash.curry = curry;
                    lodash.curryRight = curryRight;
                    lodash.debounce = debounce;
                    lodash.defaults = defaults;
                    lodash.defaultsDeep = defaultsDeep;
                    lodash.defer = defer;
                    lodash.delay = delay;
                    lodash.difference = difference;
                    lodash.differenceBy = differenceBy;
                    lodash.differenceWith = differenceWith;
                    lodash.drop = drop;
                    lodash.dropRight = dropRight;
                    lodash.dropRightWhile = dropRightWhile;
                    lodash.dropWhile = dropWhile;
                    lodash.fill = fill;
                    lodash.filter = filter;
                    lodash.flatMap = flatMap;
                    lodash.flatMapDeep = flatMapDeep;
                    lodash.flatMapDepth = flatMapDepth;
                    lodash.flatten = flatten;
                    lodash.flattenDeep = flattenDeep;
                    lodash.flattenDepth = flattenDepth;
                    lodash.flip = flip;
                    lodash.flow = flow;
                    lodash.flowRight = flowRight;
                    lodash.fromPairs = fromPairs;
                    lodash.functions = functions;
                    lodash.functionsIn = functionsIn;
                    lodash.groupBy = groupBy;
                    lodash.initial = initial;
                    lodash.intersection = intersection;
                    lodash.intersectionBy = intersectionBy;
                    lodash.intersectionWith = intersectionWith;
                    lodash.invert = invert;
                    lodash.invertBy = invertBy;
                    lodash.invokeMap = invokeMap;
                    lodash.iteratee = iteratee;
                    lodash.keyBy = keyBy;
                    lodash.keys = keys;
                    lodash.keysIn = keysIn;
                    lodash.map = map;
                    lodash.mapKeys = mapKeys;
                    lodash.mapValues = mapValues;
                    lodash.matches = matches;
                    lodash.matchesProperty = matchesProperty;
                    lodash.memoize = memoize;
                    lodash.merge = merge;
                    lodash.mergeWith = mergeWith;
                    lodash.method = method;
                    lodash.methodOf = methodOf;
                    lodash.mixin = mixin;
                    lodash.negate = negate;
                    lodash.nthArg = nthArg;
                    lodash.omit = omit;
                    lodash.omitBy = omitBy;
                    lodash.once = once;
                    lodash.orderBy = orderBy;
                    lodash.over = over;
                    lodash.overArgs = overArgs;
                    lodash.overEvery = overEvery;
                    lodash.overSome = overSome;
                    lodash.partial = partial;
                    lodash.partialRight = partialRight;
                    lodash.partition = partition;
                    lodash.pick = pick;
                    lodash.pickBy = pickBy;
                    lodash.property = property;
                    lodash.propertyOf = propertyOf;
                    lodash.pull = pull;
                    lodash.pullAll = pullAll;
                    lodash.pullAllBy = pullAllBy;
                    lodash.pullAllWith = pullAllWith;
                    lodash.pullAt = pullAt;
                    lodash.range = range;
                    lodash.rangeRight = rangeRight;
                    lodash.rearg = rearg;
                    lodash.reject = reject;
                    lodash.remove = remove;
                    lodash.rest = rest;
                    lodash.reverse = reverse;
                    lodash.sampleSize = sampleSize;
                    lodash.set = set;
                    lodash.setWith = setWith;
                    lodash.shuffle = shuffle;
                    lodash.slice = slice;
                    lodash.sortBy = sortBy;
                    lodash.sortedUniq = sortedUniq;
                    lodash.sortedUniqBy = sortedUniqBy;
                    lodash.split = split;
                    lodash.spread = spread;
                    lodash.tail = tail;
                    lodash.take = take;
                    lodash.takeRight = takeRight;
                    lodash.takeRightWhile = takeRightWhile;
                    lodash.takeWhile = takeWhile;
                    lodash.tap = tap;
                    lodash.throttle = throttle;
                    lodash.thru = thru;
                    lodash.toArray = toArray;
                    lodash.toPairs = toPairs;
                    lodash.toPairsIn = toPairsIn;
                    lodash.toPath = toPath;
                    lodash.toPlainObject = toPlainObject;
                    lodash.transform = transform;
                    lodash.unary = unary;
                    lodash.union = union;
                    lodash.unionBy = unionBy;
                    lodash.unionWith = unionWith;
                    lodash.uniq = uniq;
                    lodash.uniqBy = uniqBy;
                    lodash.uniqWith = uniqWith;
                    lodash.unset = unset;
                    lodash.unzip = unzip;
                    lodash.unzipWith = unzipWith;
                    lodash.update = update;
                    lodash.updateWith = updateWith;
                    lodash.values = values;
                    lodash.valuesIn = valuesIn;
                    lodash.without = without;
                    lodash.words = words;
                    lodash.wrap = wrap;
                    lodash.xor = xor;
                    lodash.xorBy = xorBy;
                    lodash.xorWith = xorWith;
                    lodash.zip = zip;
                    lodash.zipObject = zipObject;
                    lodash.zipObjectDeep = zipObjectDeep;
                    lodash.zipWith = zipWith;

                    // Add aliases.
                    lodash.entries = toPairs;
                    lodash.entriesIn = toPairsIn;
                    lodash.extend = assignIn;
                    lodash.extendWith = assignInWith;

                    // Add methods to `lodash.prototype`.
                    mixin(lodash, lodash);

                    /*------------------------------------------------------------------------*/

                    // Add methods that return unwrapped values in chain sequences.
                    lodash.add = add;
                    lodash.attempt = attempt;
                    lodash.camelCase = camelCase;
                    lodash.capitalize = capitalize;
                    lodash.ceil = ceil;
                    lodash.clamp = clamp;
                    lodash.clone = clone;
                    lodash.cloneDeep = cloneDeep;
                    lodash.cloneDeepWith = cloneDeepWith;
                    lodash.cloneWith = cloneWith;
                    lodash.conformsTo = conformsTo;
                    lodash.deburr = deburr;
                    lodash.defaultTo = defaultTo;
                    lodash.divide = divide;
                    lodash.endsWith = endsWith;
                    lodash.eq = eq;
                    lodash.escape = escape;
                    lodash.escapeRegExp = escapeRegExp;
                    lodash.every = every;
                    lodash.find = find;
                    lodash.findIndex = findIndex;
                    lodash.findKey = findKey;
                    lodash.findLast = findLast;
                    lodash.findLastIndex = findLastIndex;
                    lodash.findLastKey = findLastKey;
                    lodash.floor = floor;
                    lodash.forEach = forEach;
                    lodash.forEachRight = forEachRight;
                    lodash.forIn = forIn;
                    lodash.forInRight = forInRight;
                    lodash.forOwn = forOwn;
                    lodash.forOwnRight = forOwnRight;
                    lodash.get = get;
                    lodash.gt = gt;
                    lodash.gte = gte;
                    lodash.has = has;
                    lodash.hasIn = hasIn;
                    lodash.head = head;
                    lodash.identity = identity;
                    lodash.includes = includes;
                    lodash.indexOf = indexOf;
                    lodash.inRange = inRange;
                    lodash.invoke = invoke;
                    lodash.isArguments = isArguments;
                    lodash.isArray = isArray;
                    lodash.isArrayBuffer = isArrayBuffer;
                    lodash.isArrayLike = isArrayLike;
                    lodash.isArrayLikeObject = isArrayLikeObject;
                    lodash.isBoolean = isBoolean;
                    lodash.isBuffer = isBuffer;
                    lodash.isDate = isDate;
                    lodash.isElement = isElement;
                    lodash.isEmpty = isEmpty;
                    lodash.isEqual = isEqual;
                    lodash.isEqualWith = isEqualWith;
                    lodash.isError = isError;
                    lodash.isFinite = isFinite;
                    lodash.isFunction = isFunction;
                    lodash.isInteger = isInteger;
                    lodash.isLength = isLength;
                    lodash.isMap = isMap;
                    lodash.isMatch = isMatch;
                    lodash.isMatchWith = isMatchWith;
                    lodash.isNaN = isNaN;
                    lodash.isNative = isNative;
                    lodash.isNil = isNil;
                    lodash.isNull = isNull;
                    lodash.isNumber = isNumber;
                    lodash.isObject = isObject;
                    lodash.isObjectLike = isObjectLike;
                    lodash.isPlainObject = isPlainObject;
                    lodash.isRegExp = isRegExp;
                    lodash.isSafeInteger = isSafeInteger;
                    lodash.isSet = isSet;
                    lodash.isString = isString;
                    lodash.isSymbol = isSymbol;
                    lodash.isTypedArray = isTypedArray;
                    lodash.isUndefined = isUndefined;
                    lodash.isWeakMap = isWeakMap;
                    lodash.isWeakSet = isWeakSet;
                    lodash.join = join;
                    lodash.kebabCase = kebabCase;
                    lodash.last = last;
                    lodash.lastIndexOf = lastIndexOf;
                    lodash.lowerCase = lowerCase;
                    lodash.lowerFirst = lowerFirst;
                    lodash.lt = lt;
                    lodash.lte = lte;
                    lodash.max = max;
                    lodash.maxBy = maxBy;
                    lodash.mean = mean;
                    lodash.meanBy = meanBy;
                    lodash.min = min;
                    lodash.minBy = minBy;
                    lodash.stubArray = stubArray;
                    lodash.stubFalse = stubFalse;
                    lodash.stubObject = stubObject;
                    lodash.stubString = stubString;
                    lodash.stubTrue = stubTrue;
                    lodash.multiply = multiply;
                    lodash.nth = nth;
                    lodash.noConflict = noConflict;
                    lodash.noop = noop;
                    lodash.now = now;
                    lodash.pad = pad;
                    lodash.padEnd = padEnd;
                    lodash.padStart = padStart;
                    lodash.parseInt = parseInt;
                    lodash.random = random;
                    lodash.reduce = reduce;
                    lodash.reduceRight = reduceRight;
                    lodash.repeat = repeat;
                    lodash.replace = replace;
                    lodash.result = result;
                    lodash.round = round;
                    lodash.runInContext = runInContext;
                    lodash.sample = sample;
                    lodash.size = size;
                    lodash.snakeCase = snakeCase;
                    lodash.some = some;
                    lodash.sortedIndex = sortedIndex;
                    lodash.sortedIndexBy = sortedIndexBy;
                    lodash.sortedIndexOf = sortedIndexOf;
                    lodash.sortedLastIndex = sortedLastIndex;
                    lodash.sortedLastIndexBy = sortedLastIndexBy;
                    lodash.sortedLastIndexOf = sortedLastIndexOf;
                    lodash.startCase = startCase;
                    lodash.startsWith = startsWith;
                    lodash.subtract = subtract;
                    lodash.sum = sum;
                    lodash.sumBy = sumBy;
                    lodash.template = template;
                    lodash.times = times;
                    lodash.toFinite = toFinite;
                    lodash.toInteger = toInteger;
                    lodash.toLength = toLength;
                    lodash.toLower = toLower;
                    lodash.toNumber = toNumber;
                    lodash.toSafeInteger = toSafeInteger;
                    lodash.toString = toString;
                    lodash.toUpper = toUpper;
                    lodash.trim = trim;
                    lodash.trimEnd = trimEnd;
                    lodash.trimStart = trimStart;
                    lodash.truncate = truncate;
                    lodash.unescape = unescape;
                    lodash.uniqueId = uniqueId;
                    lodash.upperCase = upperCase;
                    lodash.upperFirst = upperFirst;

                    // Add aliases.
                    lodash.each = forEach;
                    lodash.eachRight = forEachRight;
                    lodash.first = head;

                    mixin(lodash, (function() {
                        var source = {};
                        baseForOwn(lodash, function(func, methodName) {
                            if (!hasOwnProperty.call(lodash.prototype, methodName)) {
                                source[methodName] = func;
                            }
                        });
                        return source;
                    }()), { 'chain': false });

                    /*------------------------------------------------------------------------*/

                    /**
                     * The semantic version number.
                     *
                     * @static
                     * @memberOf _
                     * @type {string}
                     */
                    lodash.VERSION = VERSION;

                    // Assign default placeholders.
                    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
                        lodash[methodName].placeholder = lodash;
                    });

                    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
                    arrayEach(['drop', 'take'], function(methodName, index) {
                        LazyWrapper.prototype[methodName] = function(n) {
                            n = n === undefined ? 1 : nativeMax(toInteger(n), 0);

                            var result = (this.__filtered__ && !index)
                                ? new LazyWrapper(this)
                                : this.clone();

                            if (result.__filtered__) {
                                result.__takeCount__ = nativeMin(n, result.__takeCount__);
                            } else {
                                result.__views__.push({
                                    'size': nativeMin(n, MAX_ARRAY_LENGTH),
                                    'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
                                });
                            }
                            return result;
                        };

                        LazyWrapper.prototype[methodName + 'Right'] = function(n) {
                            return this.reverse()[methodName](n).reverse();
                        };
                    });

                    // Add `LazyWrapper` methods that accept an `iteratee` value.
                    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
                        var type = index + 1,
                            isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;

                        LazyWrapper.prototype[methodName] = function(iteratee) {
                            var result = this.clone();
                            result.__iteratees__.push({
                                'iteratee': getIteratee(iteratee, 3),
                                'type': type
                            });
                            result.__filtered__ = result.__filtered__ || isFilter;
                            return result;
                        };
                    });

                    // Add `LazyWrapper` methods for `_.head` and `_.last`.
                    arrayEach(['head', 'last'], function(methodName, index) {
                        var takeName = 'take' + (index ? 'Right' : '');

                        LazyWrapper.prototype[methodName] = function() {
                            return this[takeName](1).value()[0];
                        };
                    });

                    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
                    arrayEach(['initial', 'tail'], function(methodName, index) {
                        var dropName = 'drop' + (index ? '' : 'Right');

                        LazyWrapper.prototype[methodName] = function() {
                            return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
                        };
                    });

                    LazyWrapper.prototype.compact = function() {
                        return this.filter(identity);
                    };

                    LazyWrapper.prototype.find = function(predicate) {
                        return this.filter(predicate).head();
                    };

                    LazyWrapper.prototype.findLast = function(predicate) {
                        return this.reverse().find(predicate);
                    };

                    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
                        if (typeof path == 'function') {
                            return new LazyWrapper(this);
                        }
                        return this.map(function(value) {
                            return baseInvoke(value, path, args);
                        });
                    });

                    LazyWrapper.prototype.reject = function(predicate) {
                        return this.filter(negate(getIteratee(predicate)));
                    };

                    LazyWrapper.prototype.slice = function(start, end) {
                        start = toInteger(start);

                        var result = this;
                        if (result.__filtered__ && (start > 0 || end < 0)) {
                            return new LazyWrapper(result);
                        }
                        if (start < 0) {
                            result = result.takeRight(-start);
                        } else if (start) {
                            result = result.drop(start);
                        }
                        if (end !== undefined) {
                            end = toInteger(end);
                            result = end < 0 ? result.dropRight(-end) : result.take(end - start);
                        }
                        return result;
                    };

                    LazyWrapper.prototype.takeRightWhile = function(predicate) {
                        return this.reverse().takeWhile(predicate).reverse();
                    };

                    LazyWrapper.prototype.toArray = function() {
                        return this.take(MAX_ARRAY_LENGTH);
                    };

                    // Add `LazyWrapper` methods to `lodash.prototype`.
                    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
                        var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
                            isTaker = /^(?:head|last)$/.test(methodName),
                            lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
                            retUnwrapped = isTaker || /^find/.test(methodName);

                        if (!lodashFunc) {
                            return;
                        }
                        lodash.prototype[methodName] = function() {
                            var value = this.__wrapped__,
                                args = isTaker ? [1] : arguments,
                                isLazy = value instanceof LazyWrapper,
                                iteratee = args[0],
                                useLazy = isLazy || isArray(value);

                            var interceptor = function(value) {
                                var result = lodashFunc.apply(lodash, arrayPush([value], args));
                                return (isTaker && chainAll) ? result[0] : result;
                            };

                            if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
                                // Avoid lazy use if the iteratee has a "length" value other than `1`.
                                isLazy = useLazy = false;
                            }
                            var chainAll = this.__chain__,
                                isHybrid = !!this.__actions__.length,
                                isUnwrapped = retUnwrapped && !chainAll,
                                onlyLazy = isLazy && !isHybrid;

                            if (!retUnwrapped && useLazy) {
                                value = onlyLazy ? value : new LazyWrapper(this);
                                var result = func.apply(value, args);
                                result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
                                return new LodashWrapper(result, chainAll);
                            }
                            if (isUnwrapped && onlyLazy) {
                                return func.apply(this, args);
                            }
                            result = this.thru(interceptor);
                            return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
                        };
                    });

                    // Add `Array` methods to `lodash.prototype`.
                    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
                        var func = arrayProto[methodName],
                            chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
                            retUnwrapped = /^(?:pop|shift)$/.test(methodName);

                        lodash.prototype[methodName] = function() {
                            var args = arguments;
                            if (retUnwrapped && !this.__chain__) {
                                var value = this.value();
                                return func.apply(isArray(value) ? value : [], args);
                            }
                            return this[chainName](function(value) {
                                return func.apply(isArray(value) ? value : [], args);
                            });
                        };
                    });

                    // Map minified method names to their real names.
                    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
                        var lodashFunc = lodash[methodName];
                        if (lodashFunc) {
                            var key = lodashFunc.name + '';
                            if (!hasOwnProperty.call(realNames, key)) {
                                realNames[key] = [];
                            }
                            realNames[key].push({ 'name': methodName, 'func': lodashFunc });
                        }
                    });

                    realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
                        'name': 'wrapper',
                        'func': undefined
                    }];

                    // Add methods to `LazyWrapper`.
                    LazyWrapper.prototype.clone = lazyClone;
                    LazyWrapper.prototype.reverse = lazyReverse;
                    LazyWrapper.prototype.value = lazyValue;

                    // Add chain sequence methods to the `lodash` wrapper.
                    lodash.prototype.at = wrapperAt;
                    lodash.prototype.chain = wrapperChain;
                    lodash.prototype.commit = wrapperCommit;
                    lodash.prototype.next = wrapperNext;
                    lodash.prototype.plant = wrapperPlant;
                    lodash.prototype.reverse = wrapperReverse;
                    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;

                    // Add lazy aliases.
                    lodash.prototype.first = lodash.prototype.head;

                    if (symIterator) {
                        lodash.prototype[symIterator] = wrapperToIterator;
                    }
                    return lodash;
                });

                /*--------------------------------------------------------------------------*/

                // Export lodash.
                var _ = runInContext();

                // Some AMD build optimizers, like r.js, check for condition patterns like:
                if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
                    // Expose Lodash on the global object to prevent errors when Lodash is
                    // loaded by a script tag in the presence of an AMD loader.
                    // See http://requirejs.org/docs/errors.html#mismatch for more details.
                    // Use `_.noConflict` to remove Lodash from the global object.
                    root._ = _;

                    // Define as an anonymous module so, through path mapping, it can be
                    // referenced as the "underscore" module.
                    define(function() {
                        return _;
                    });
                }
                // Check for `exports` after `define` in case a build optimizer adds it.
                else if (freeModule) {
                    // Export for Node.js.
                    (freeModule.exports = _)._ = _;
                    // Export for CommonJS support.
                    freeExports._ = _;
                }
                else {
                    // Export to the global object.
                    root._ = _;
                }
            }.call(this));

        }).call(this)}).call(this,typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],88:[function(require,module,exports){
        exports.Parser = require("./lib/parser").Parser;
        exports.rules = require("./lib/rules");
        exports.errors = require("./lib/errors");
        exports.results = require("./lib/parsing-results");
        exports.StringSource = require("./lib/StringSource");
        exports.Token = require("./lib/Token");
        exports.bottomUp = require("./lib/bottom-up");
        exports.RegexTokeniser = require("./lib/regex-tokeniser").RegexTokeniser;

        exports.rule = function(ruleBuilder) {
            var rule;
            return function(input) {
                if (!rule) {
                    rule = ruleBuilder();
                }
                return rule(input);
            };
        };

    },{"./lib/StringSource":89,"./lib/Token":90,"./lib/bottom-up":92,"./lib/errors":93,"./lib/parser":95,"./lib/parsing-results":96,"./lib/regex-tokeniser":97,"./lib/rules":98}],89:[function(require,module,exports){
        var util = require("util");

        var StringSource = module.exports = function(string, description) {
            var self = {
                asString: function() {
                    return string;
                },
                range: function(startIndex, endIndex) {
                    return new StringSourceRange(string, description, startIndex, endIndex);
                }
            };
            return self;
        };

        var StringSourceRange = function(string, description, startIndex, endIndex) {
            this._string = string;
            this._description = description;
            this._startIndex = startIndex;
            this._endIndex = endIndex;
        };

        StringSourceRange.prototype.to = function(otherRange) {
            // TODO: Assert that tokens are the same across both iterators
            return new StringSourceRange(this._string, this._description, this._startIndex, otherRange._endIndex);
        };

        StringSourceRange.prototype.describe = function() {
            var position = this._position();
            var description = this._description ? this._description + "\n" : "";
            return util.format("%sLine number: %s\nCharacter number: %s",
                description, position.lineNumber, position.characterNumber);
        };

        StringSourceRange.prototype.lineNumber = function() {
            return this._position().lineNumber;
        };

        StringSourceRange.prototype.characterNumber = function() {
            return this._position().characterNumber;
        };

        StringSourceRange.prototype._position = function() {
            var self = this;
            var index = 0;
            var nextNewLine = function() {
                return self._string.indexOf("\n", index);
            };

            var lineNumber = 1;
            while (nextNewLine() !== -1 && nextNewLine() < this._startIndex) {
                index = nextNewLine() + 1;
                lineNumber += 1;
            }
            var characterNumber = this._startIndex - index + 1;
            return {lineNumber: lineNumber, characterNumber: characterNumber};
        };

    },{"util":125}],90:[function(require,module,exports){
        module.exports = function(name, value, source) {
            this.name = name;
            this.value = value;
            if (source) {
                this.source = source;
            }
        };

    },{}],91:[function(require,module,exports){
        var TokenIterator = module.exports = function(tokens, startIndex) {
            this._tokens = tokens;
            this._startIndex = startIndex || 0;
        };

        TokenIterator.prototype.head = function() {
            return this._tokens[this._startIndex];
        };

        TokenIterator.prototype.tail = function(startIndex) {
            return new TokenIterator(this._tokens, this._startIndex + 1);
        };

        TokenIterator.prototype.toArray = function() {
            return this._tokens.slice(this._startIndex);
        };

        TokenIterator.prototype.end = function() {
            return this._tokens[this._tokens.length - 1];
        };

// TODO: doesn't need to be a method, can be a separate function,
// which simplifies implementation of the TokenIterator interface
        TokenIterator.prototype.to = function(end) {
            var start = this.head().source;
            var endToken = end.head() || end.end();
            return start.to(endToken.source);
        };

    },{}],92:[function(require,module,exports){
        var rules = require("./rules");
        var results = require("./parsing-results");

        exports.parser = function(name, prefixRules, infixRuleBuilders) {
            var self = {
                rule: rule,
                leftAssociative: leftAssociative,
                rightAssociative: rightAssociative
            };

            var infixRules = new InfixRules(infixRuleBuilders.map(createInfixRule));
            var prefixRule = rules.firstOf(name, prefixRules);

            function createInfixRule(infixRuleBuilder) {
                return {
                    name: infixRuleBuilder.name,
                    rule: lazyRule(infixRuleBuilder.ruleBuilder.bind(null, self))
                };
            }

            function rule() {
                return createRule(infixRules);
            }

            function leftAssociative(name) {
                return createRule(infixRules.untilExclusive(name));
            }

            function rightAssociative(name) {
                return createRule(infixRules.untilInclusive(name));
            }

            function createRule(infixRules) {
                return apply.bind(null, infixRules);
            }

            function apply(infixRules, tokens) {
                var leftResult = prefixRule(tokens);
                if (leftResult.isSuccess()) {
                    return infixRules.apply(leftResult);
                } else {
                    return leftResult;
                }
            }

            return self;
        };

        function InfixRules(infixRules) {
            function untilExclusive(name) {
                return new InfixRules(infixRules.slice(0, ruleNames().indexOf(name)));
            }

            function untilInclusive(name) {
                return new InfixRules(infixRules.slice(0, ruleNames().indexOf(name) + 1));
            }

            function ruleNames() {
                return infixRules.map(function(rule) {
                    return rule.name;
                });
            }

            function apply(leftResult) {
                var currentResult;
                var source;
                while (true) {
                    currentResult = applyToTokens(leftResult.remaining());
                    if (currentResult.isSuccess()) {
                        source = leftResult.source().to(currentResult.source());
                        leftResult = results.success(
                            currentResult.value()(leftResult.value(), source),
                            currentResult.remaining(),
                            source
                        )
                    } else if (currentResult.isFailure()) {
                        return leftResult;
                    } else {
                        return currentResult;
                    }
                }
            }

            function applyToTokens(tokens) {
                return rules.firstOf("infix", infixRules.map(function(infix) {
                    return infix.rule;
                }))(tokens);
            }

            return {
                apply: apply,
                untilExclusive: untilExclusive,
                untilInclusive: untilInclusive
            }
        }

        exports.infix = function(name, ruleBuilder) {
            function map(func) {
                return exports.infix(name, function(parser) {
                    var rule = ruleBuilder(parser);
                    return function(tokens) {
                        var result = rule(tokens);
                        return result.map(function(right) {
                            return function(left, source) {
                                return func(left, right, source);
                            };
                        });
                    };
                });
            }

            return {
                name: name,
                ruleBuilder: ruleBuilder,
                map: map
            };
        }

// TODO: move into a sensible place and remove duplication
        var lazyRule = function(ruleBuilder) {
            var rule;
            return function(input) {
                if (!rule) {
                    rule = ruleBuilder();
                }
                return rule(input);
            };
        };

    },{"./parsing-results":96,"./rules":98}],93:[function(require,module,exports){
        exports.error = function(options) {
            return new Error(options);
        };

        var Error = function(options) {
            this.expected = options.expected;
            this.actual = options.actual;
            this._location = options.location;
        };

        Error.prototype.describe = function() {
            var locationDescription = this._location ? this._location.describe() + ":\n" : "";
            return locationDescription + "Expected " + this.expected + "\nbut got " + this.actual;
        };

        Error.prototype.lineNumber = function() {
            return this._location.lineNumber();
        };

        Error.prototype.characterNumber = function() {
            return this._location.characterNumber();
        };

    },{}],94:[function(require,module,exports){
        var fromArray = exports.fromArray = function(array) {
            var index = 0;
            var hasNext = function() {
                return index < array.length;
            };
            return new LazyIterator({
                hasNext: hasNext,
                next: function() {
                    if (!hasNext()) {
                        throw new Error("No more elements");
                    } else {
                        return array[index++];
                    }
                }
            });
        };

        var LazyIterator = function(iterator) {
            this._iterator = iterator;
        };

        LazyIterator.prototype.map = function(func) {
            var iterator = this._iterator;
            return new LazyIterator({
                hasNext: function() {
                    return iterator.hasNext();
                },
                next: function() {
                    return func(iterator.next());
                }
            });
        };

        LazyIterator.prototype.filter = function(condition) {
            var iterator = this._iterator;

            var moved = false;
            var hasNext = false;
            var next;
            var moveIfNecessary = function() {
                if (moved) {
                    return;
                }
                moved = true;
                hasNext = false;
                while (iterator.hasNext() && !hasNext) {
                    next = iterator.next();
                    hasNext = condition(next);
                }
            };

            return new LazyIterator({
                hasNext: function() {
                    moveIfNecessary();
                    return hasNext;
                },
                next: function() {
                    moveIfNecessary();
                    var toReturn = next;
                    moved = false;
                    return toReturn;
                }
            });
        };

        LazyIterator.prototype.first = function() {
            var iterator = this._iterator;
            if (this._iterator.hasNext()) {
                return iterator.next();
            } else {
                return null;
            }
        };

        LazyIterator.prototype.toArray = function() {
            var result = [];
            while (this._iterator.hasNext()) {
                result.push(this._iterator.next());
            }
            return result;
        };

    },{}],95:[function(require,module,exports){
        var TokenIterator = require("./TokenIterator");

        exports.Parser = function(options) {
            var parseTokens = function(parser, tokens) {
                return parser(new TokenIterator(tokens));
            };

            return {
                parseTokens: parseTokens
            };
        };

    },{"./TokenIterator":91}],96:[function(require,module,exports){
        module.exports = {
            failure: function(errors, remaining) {
                if (errors.length < 1) {
                    throw new Error("Failure must have errors");
                }
                return new Result({
                    status: "failure",
                    remaining: remaining,
                    errors: errors
                });
            },
            error: function(errors, remaining) {
                if (errors.length < 1) {
                    throw new Error("Failure must have errors");
                }
                return new Result({
                    status: "error",
                    remaining: remaining,
                    errors: errors
                });
            },
            success: function(value, remaining, source) {
                return new Result({
                    status: "success",
                    value: value,
                    source: source,
                    remaining: remaining,
                    errors: []
                });
            },
            cut: function(remaining) {
                return new Result({
                    status: "cut",
                    remaining: remaining,
                    errors: []
                });
            }
        };

        var Result = function(options) {
            this._value = options.value;
            this._status = options.status;
            this._hasValue = options.value !== undefined;
            this._remaining = options.remaining;
            this._source = options.source;
            this._errors = options.errors;
        };

        Result.prototype.map = function(func) {
            if (this._hasValue) {
                return new Result({
                    value: func(this._value, this._source),
                    status: this._status,
                    remaining: this._remaining,
                    source: this._source,
                    errors: this._errors
                });
            } else {
                return this;
            }
        };

        Result.prototype.changeRemaining = function(remaining) {
            return new Result({
                value: this._value,
                status: this._status,
                remaining: remaining,
                source: this._source,
                errors: this._errors
            });
        };

        Result.prototype.isSuccess = function() {
            return this._status === "success" || this._status === "cut";
        };

        Result.prototype.isFailure = function() {
            return this._status === "failure";
        };

        Result.prototype.isError = function() {
            return this._status === "error";
        };

        Result.prototype.isCut = function() {
            return this._status === "cut";
        };

        Result.prototype.value = function() {
            return this._value;
        };

        Result.prototype.remaining = function() {
            return this._remaining;
        };

        Result.prototype.source = function() {
            return this._source;
        };

        Result.prototype.errors = function() {
            return this._errors;
        };

    },{}],97:[function(require,module,exports){
        var Token = require("./Token");
        var StringSource = require("./StringSource");

        exports.RegexTokeniser = RegexTokeniser;

        function RegexTokeniser(rules) {
            rules = rules.map(function(rule) {
                return {
                    name: rule.name,
                    regex: new RegExp(rule.regex.source, "g")
                };
            });

            function tokenise(input, description) {
                var source = new StringSource(input, description);
                var index = 0;
                var tokens = [];

                while (index < input.length) {
                    var result = readNextToken(input, index, source);
                    index = result.endIndex;
                    tokens.push(result.token);
                }

                tokens.push(endToken(input, source));
                return tokens;
            }

            function readNextToken(string, startIndex, source) {
                for (var i = 0; i < rules.length; i++) {
                    var regex = rules[i].regex;
                    regex.lastIndex = startIndex;
                    var result = regex.exec(string);

                    if (result) {
                        var endIndex = startIndex + result[0].length;
                        if (result.index === startIndex && endIndex > startIndex) {
                            var value = result[1];
                            var token = new Token(
                                rules[i].name,
                                value,
                                source.range(startIndex, endIndex)
                            );
                            return {token: token, endIndex: endIndex};
                        }
                    }
                }
                var endIndex = startIndex + 1;
                var token = new Token(
                    "unrecognisedCharacter",
                    string.substring(startIndex, endIndex),
                    source.range(startIndex, endIndex)
                );
                return {token: token, endIndex: endIndex};
            }

            function endToken(input, source) {
                return new Token(
                    "end",
                    null,
                    source.range(input.length, input.length)
                );
            }

            return {
                tokenise: tokenise
            }
        }



    },{"./StringSource":89,"./Token":90}],98:[function(require,module,exports){
        var _ = require("underscore");
        var options = require("option");
        var results = require("./parsing-results");
        var errors = require("./errors");
        var lazyIterators = require("./lazy-iterators");

        exports.token = function(tokenType, value) {
            var matchValue = value !== undefined;
            return function(input) {
                var token = input.head();
                if (token && token.name === tokenType && (!matchValue || token.value === value)) {
                    return results.success(token.value, input.tail(), token.source);
                } else {
                    var expected = describeToken({name: tokenType, value: value});
                    return describeTokenMismatch(input, expected);
                }
            };
        };

        exports.tokenOfType = function(tokenType) {
            return exports.token(tokenType);
        };

        exports.firstOf = function(name, parsers) {
            if (!_.isArray(parsers)) {
                parsers = Array.prototype.slice.call(arguments, 1);
            }
            return function(input) {
                return lazyIterators
                    .fromArray(parsers)
                    .map(function(parser) {
                        return parser(input);
                    })
                    .filter(function(result) {
                        return result.isSuccess() || result.isError();
                    })
                    .first() || describeTokenMismatch(input, name);
            };
        };

        exports.then = function(parser, func) {
            return function(input) {
                var result = parser(input);
                if (!result.map) {
                    console.log(result);
                }
                return result.map(func);
            };
        };

        exports.sequence = function() {
            var parsers = Array.prototype.slice.call(arguments, 0);
            var rule = function(input) {
                var result = _.foldl(parsers, function(memo, parser) {
                    var result = memo.result;
                    var hasCut = memo.hasCut;
                    if (!result.isSuccess()) {
                        return {result: result, hasCut: hasCut};
                    }
                    var subResult = parser(result.remaining());
                    if (subResult.isCut()) {
                        return {result: result, hasCut: true};
                    } else if (subResult.isSuccess()) {
                        var values;
                        if (parser.isCaptured) {
                            values = result.value().withValue(parser, subResult.value());
                        } else {
                            values = result.value();
                        }
                        var remaining = subResult.remaining();
                        var source = input.to(remaining);
                        return {
                            result: results.success(values, remaining, source),
                            hasCut: hasCut
                        };
                    } else if (hasCut) {
                        return {result: results.error(subResult.errors(), subResult.remaining()), hasCut: hasCut};
                    } else {
                        return {result: subResult, hasCut: hasCut};
                    }
                }, {result: results.success(new SequenceValues(), input), hasCut: false}).result;
                var source = input.to(result.remaining());
                return result.map(function(values) {
                    return values.withValue(exports.sequence.source, source);
                });
            };
            rule.head = function() {
                var firstCapture = _.find(parsers, isCapturedRule);
                return exports.then(
                    rule,
                    exports.sequence.extract(firstCapture)
                );
            };
            rule.map = function(func) {
                return exports.then(
                    rule,
                    function(result) {
                        return func.apply(this, result.toArray());
                    }
                );
            };

            function isCapturedRule(subRule) {
                return subRule.isCaptured;
            }

            return rule;
        };

        var SequenceValues = function(values, valuesArray) {
            this._values = values || {};
            this._valuesArray = valuesArray || [];
        };

        SequenceValues.prototype.withValue = function(rule, value) {
            if (rule.captureName && rule.captureName in this._values) {
                throw new Error("Cannot add second value for capture \"" + rule.captureName + "\"");
            } else {
                var newValues = _.clone(this._values);
                newValues[rule.captureName] = value;
                var newValuesArray = this._valuesArray.concat([value]);
                return new SequenceValues(newValues, newValuesArray);
            }
        };

        SequenceValues.prototype.get = function(rule) {
            if (rule.captureName in this._values) {
                return this._values[rule.captureName];
            } else {
                throw new Error("No value for capture \"" + rule.captureName + "\"");
            }
        };

        SequenceValues.prototype.toArray = function() {
            return this._valuesArray;
        };

        exports.sequence.capture = function(rule, name) {
            var captureRule = function() {
                return rule.apply(this, arguments);
            };
            captureRule.captureName = name;
            captureRule.isCaptured = true;
            return captureRule;
        };

        exports.sequence.extract = function(rule) {
            return function(result) {
                return result.get(rule);
            };
        };

        exports.sequence.applyValues = function(func) {
            // TODO: check captureName doesn't conflict with source or other captures
            var rules = Array.prototype.slice.call(arguments, 1);
            return function(result) {
                var values = rules.map(function(rule) {
                    return result.get(rule);
                });
                return func.apply(this, values);
            };
        };

        exports.sequence.source = {
            captureName: "☃source☃"
        };

        exports.sequence.cut = function() {
            return function(input) {
                return results.cut(input);
            };
        };

        exports.optional = function(rule) {
            return function(input) {
                var result = rule(input);
                if (result.isSuccess()) {
                    return result.map(options.some);
                } else if (result.isFailure()) {
                    return results.success(options.none, input);
                } else {
                    return result;
                }
            };
        };

        exports.zeroOrMoreWithSeparator = function(rule, separator) {
            return repeatedWithSeparator(rule, separator, false);
        };

        exports.oneOrMoreWithSeparator = function(rule, separator) {
            return repeatedWithSeparator(rule, separator, true);
        };

        var zeroOrMore = exports.zeroOrMore = function(rule) {
            return function(input) {
                var values = [];
                var result;
                while ((result = rule(input)) && result.isSuccess()) {
                    input = result.remaining();
                    values.push(result.value());
                }
                if (result.isError()) {
                    return result;
                } else {
                    return results.success(values, input);
                }
            };
        };

        exports.oneOrMore = function(rule) {
            return exports.oneOrMoreWithSeparator(rule, noOpRule);
        };

        function noOpRule(input) {
            return results.success(null, input);
        }

        var repeatedWithSeparator = function(rule, separator, isOneOrMore) {
            return function(input) {
                var result = rule(input);
                if (result.isSuccess()) {
                    var mainRule = exports.sequence.capture(rule, "main");
                    var remainingRule = zeroOrMore(exports.then(
                        exports.sequence(separator, mainRule),
                        exports.sequence.extract(mainRule)
                    ));
                    var remainingResult = remainingRule(result.remaining());
                    return results.success([result.value()].concat(remainingResult.value()), remainingResult.remaining());
                } else if (isOneOrMore || result.isError()) {
                    return result;
                } else {
                    return results.success([], input);
                }
            };
        };

        exports.leftAssociative = function(leftRule, rightRule, func) {
            var rights;
            if (func) {
                rights = [{func: func, rule: rightRule}];
            } else {
                rights = rightRule;
            }
            rights = rights.map(function(right) {
                return exports.then(right.rule, function(rightValue) {
                    return function(leftValue, source) {
                        return right.func(leftValue, rightValue, source);
                    };
                });
            });
            var repeatedRule = exports.firstOf.apply(null, ["rules"].concat(rights));

            return function(input) {
                var start = input;
                var leftResult = leftRule(input);
                if (!leftResult.isSuccess()) {
                    return leftResult;
                }
                var repeatedResult = repeatedRule(leftResult.remaining());
                while (repeatedResult.isSuccess()) {
                    var remaining = repeatedResult.remaining();
                    var source = start.to(repeatedResult.remaining());
                    var right = repeatedResult.value();
                    leftResult = results.success(
                        right(leftResult.value(), source),
                        remaining,
                        source
                    );
                    repeatedResult = repeatedRule(leftResult.remaining());
                }
                if (repeatedResult.isError()) {
                    return repeatedResult;
                }
                return leftResult;
            };
        };

        exports.leftAssociative.firstOf = function() {
            return Array.prototype.slice.call(arguments, 0);
        };

        exports.nonConsuming = function(rule) {
            return function(input) {
                return rule(input).changeRemaining(input);
            };
        };

        var describeToken = function(token) {
            if (token.value) {
                return token.name + " \"" + token.value + "\"";
            } else {
                return token.name;
            }
        };

        function describeTokenMismatch(input, expected) {
            var error;
            var token = input.head();
            if (token) {
                error = errors.error({
                    expected: expected,
                    actual: describeToken(token),
                    location: token.source
                });
            } else {
                error = errors.error({
                    expected: expected,
                    actual: "end of tokens"
                });
            }
            return results.failure([error], input);
        }

    },{"./errors":93,"./lazy-iterators":94,"./parsing-results":96,"option":99,"underscore":122}],99:[function(require,module,exports){
        exports.none = Object.create({
            value: function() {
                throw new Error('Called value on none');
            },
            isNone: function() {
                return true;
            },
            isSome: function() {
                return false;
            },
            map: function() {
                return exports.none;
            },
            flatMap: function() {
                return exports.none;
            },
            filter: function() {
                return exports.none;
            },
            toArray: function() {
                return [];
            },
            orElse: callOrReturn,
            valueOrElse: callOrReturn
        });

        function callOrReturn(value) {
            if (typeof(value) == "function") {
                return value();
            } else {
                return value;
            }
        }

        exports.some = function(value) {
            return new Some(value);
        };

        var Some = function(value) {
            this._value = value;
        };

        Some.prototype.value = function() {
            return this._value;
        };

        Some.prototype.isNone = function() {
            return false;
        };

        Some.prototype.isSome = function() {
            return true;
        };

        Some.prototype.map = function(func) {
            return new Some(func(this._value));
        };

        Some.prototype.flatMap = function(func) {
            return func(this._value);
        };

        Some.prototype.filter = function(predicate) {
            return predicate(this._value) ? this : exports.none;
        };

        Some.prototype.toArray = function() {
            return [this._value];
        };

        Some.prototype.orElse = function(value) {
            return this;
        };

        Some.prototype.valueOrElse = function(value) {
            return this._value;
        };

        exports.isOption = function(value) {
            return value === exports.none || value instanceof Some;
        };

        exports.fromNullable = function(value) {
            if (value == null) {
                return exports.none;
            }
            return new Some(value);
        }

    },{}],100:[function(require,module,exports){
        (function (process){(function (){
// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,
// backported and transplited with Babel, with backwards-compat fixes

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

// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
            function normalizeArray(parts, allowAboveRoot) {
                // if the path tries to go above the root, `up` ends up > 0
                var up = 0;
                for (var i = parts.length - 1; i >= 0; i--) {
                    var last = parts[i];
                    if (last === '.') {
                        parts.splice(i, 1);
                    } else if (last === '..') {
                        parts.splice(i, 1);
                        up++;
                    } else if (up) {
                        parts.splice(i, 1);
                        up--;
                    }
                }

                // if the path is allowed to go above the root, restore leading ..s
                if (allowAboveRoot) {
                    for (; up--; up) {
                        parts.unshift('..');
                    }
                }

                return parts;
            }

// path.resolve([from ...], to)
// posix version
            exports.resolve = function() {
                var resolvedPath = '',
                    resolvedAbsolute = false;

                for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
                    var path = (i >= 0) ? arguments[i] : process.cwd();

                    // Skip empty and invalid entries
                    if (typeof path !== 'string') {
                        throw new TypeError('Arguments to path.resolve must be strings');
                    } else if (!path) {
                        continue;
                    }

                    resolvedPath = path + '/' + resolvedPath;
                    resolvedAbsolute = path.charAt(0) === '/';
                }

                // At this point the path should be resolved to a full absolute path, but
                // handle relative paths to be safe (might happen when process.cwd() fails)

                // Normalize the path
                resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
                    return !!p;
                }), !resolvedAbsolute).join('/');

                return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
            };

// path.normalize(path)
// posix version
            exports.normalize = function(path) {
                var isAbsolute = exports.isAbsolute(path),
                    trailingSlash = substr(path, -1) === '/';

                // Normalize the path
                path = normalizeArray(filter(path.split('/'), function(p) {
                    return !!p;
                }), !isAbsolute).join('/');

                if (!path && !isAbsolute) {
                    path = '.';
                }
                if (path && trailingSlash) {
                    path += '/';
                }

                return (isAbsolute ? '/' : '') + path;
            };

// posix version
            exports.isAbsolute = function(path) {
                return path.charAt(0) === '/';
            };

// posix version
            exports.join = function() {
                var paths = Array.prototype.slice.call(arguments, 0);
                return exports.normalize(filter(paths, function(p, index) {
                    if (typeof p !== 'string') {
                        throw new TypeError('Arguments to path.join must be strings');
                    }
                    return p;
                }).join('/'));
            };


// path.relative(from, to)
// posix version
            exports.relative = function(from, to) {
                from = exports.resolve(from).substr(1);
                to = exports.resolve(to).substr(1);

                function trim(arr) {
                    var start = 0;
                    for (; start < arr.length; start++) {
                        if (arr[start] !== '') break;
                    }

                    var end = arr.length - 1;
                    for (; end >= 0; end--) {
                        if (arr[end] !== '') break;
                    }

                    if (start > end) return [];
                    return arr.slice(start, end - start + 1);
                }

                var fromParts = trim(from.split('/'));
                var toParts = trim(to.split('/'));

                var length = Math.min(fromParts.length, toParts.length);
                var samePartsLength = length;
                for (var i = 0; i < length; i++) {
                    if (fromParts[i] !== toParts[i]) {
                        samePartsLength = i;
                        break;
                    }
                }

                var outputParts = [];
                for (var i = samePartsLength; i < fromParts.length; i++) {
                    outputParts.push('..');
                }

                outputParts = outputParts.concat(toParts.slice(samePartsLength));

                return outputParts.join('/');
            };

            exports.sep = '/';
            exports.delimiter = ':';

            exports.dirname = function (path) {
                if (typeof path !== 'string') path = path + '';
                if (path.length === 0) return '.';
                var code = path.charCodeAt(0);
                var hasRoot = code === 47 /*/*/;
                var end = -1;
                var matchedSlash = true;
                for (var i = path.length - 1; i >= 1; --i) {
                    code = path.charCodeAt(i);
                    if (code === 47 /*/*/) {
                        if (!matchedSlash) {
                            end = i;
                            break;
                        }
                    } else {
                        // We saw the first non-path separator
                        matchedSlash = false;
                    }
                }

                if (end === -1) return hasRoot ? '/' : '.';
                if (hasRoot && end === 1) {
                    // return '//';
                    // Backwards-compat fix:
                    return '/';
                }
                return path.slice(0, end);
            };

            function basename(path) {
                if (typeof path !== 'string') path = path + '';

                var start = 0;
                var end = -1;
                var matchedSlash = true;
                var i;

                for (i = path.length - 1; i >= 0; --i) {
                    if (path.charCodeAt(i) === 47 /*/*/) {
                        // If we reached a path separator that was not part of a set of path
                        // separators at the end of the string, stop now
                        if (!matchedSlash) {
                            start = i + 1;
                            break;
                        }
                    } else if (end === -1) {
                        // We saw the first non-path separator, mark this as the end of our
                        // path component
                        matchedSlash = false;
                        end = i + 1;
                    }
                }

                if (end === -1) return '';
                return path.slice(start, end);
            }

// Uses a mixed approach for backwards-compatibility, as ext behavior changed
// in new Node.js versions, so only basename() above is backported here
            exports.basename = function (path, ext) {
                var f = basename(path);
                if (ext && f.substr(-1 * ext.length) === ext) {
                    f = f.substr(0, f.length - ext.length);
                }
                return f;
            };

            exports.extname = function (path) {
                if (typeof path !== 'string') path = path + '';
                var startDot = -1;
                var startPart = 0;
                var end = -1;
                var matchedSlash = true;
                // Track the state of characters (if any) we see before our first dot and
                // after any path separator we find
                var preDotState = 0;
                for (var i = path.length - 1; i >= 0; --i) {
                    var code = path.charCodeAt(i);
                    if (code === 47 /*/*/) {
                        // If we reached a path separator that was not part of a set of path
                        // separators at the end of the string, stop now
                        if (!matchedSlash) {
                            startPart = i + 1;
                            break;
                        }
                        continue;
                    }
                    if (end === -1) {
                        // We saw the first non-path separator, mark this as the end of our
                        // extension
                        matchedSlash = false;
                        end = i + 1;
                    }
                    if (code === 46 /*.*/) {
                        // If this is our first dot, mark it as the start of our extension
                        if (startDot === -1)
                            startDot = i;
                        else if (preDotState !== 1)
                            preDotState = 1;
                    } else if (startDot !== -1) {
                        // We saw a non-dot and non-path separator before our dot, so we should
                        // have a good chance at having a non-empty extension
                        preDotState = -1;
                    }
                }

                if (startDot === -1 || end === -1 ||
                    // We saw a non-dot character immediately before the dot
                    preDotState === 0 ||
                    // The (right-most) trimmed path component is exactly '..'
                    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
                    return '';
                }
                return path.slice(startDot, end);
            };

            function filter (xs, f) {
                if (xs.filter) return xs.filter(f);
                var res = [];
                for (var i = 0; i < xs.length; i++) {
                    if (f(xs[i], i, xs)) res.push(xs[i]);
                }
                return res;
            }

// String.prototype.substr - negative index don't work in IE8
            var substr =  true
                ? function (str, start, len) { return str.substr(start, len) }
                : 0
            ;

        }).call(this)}).call(this,require('_process'))
    },{"_process":102}],101:[function(require,module,exports){
        (function (process){(function (){
            'use strict';

            if (typeof process === 'undefined' ||
                !process.version ||
                process.version.indexOf('v0.') === 0 ||
                process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
                module.exports = { nextTick: nextTick };
            } else {
                module.exports = process
            }

            function nextTick(fn, arg1, arg2, arg3) {
                if (typeof fn !== 'function') {
                    throw new TypeError('"callback" argument must be a function');
                }
                var len = arguments.length;
                var args, i;
                switch (len) {
                    case 0:
                    case 1:
                        return process.nextTick(fn);
                    case 2:
                        return process.nextTick(function afterTickOne() {
                            fn.call(null, arg1);
                        });
                    case 3:
                        return process.nextTick(function afterTickTwo() {
                            fn.call(null, arg1, arg2);
                        });
                    case 4:
                        return process.nextTick(function afterTickThree() {
                            fn.call(null, arg1, arg2, arg3);
                        });
                    default:
                        args = new Array(len - 1);
                        i = 0;
                        while (i < args.length) {
                            args[i++] = arguments[i];
                        }
                        return process.nextTick(function afterTick() {
                            fn.apply(null, args);
                        });
                }
            }


        }).call(this)}).call(this,require('_process'))
    },{"_process":102}],102:[function(require,module,exports){
// shim for using process in browser
        var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

        var cachedSetTimeout;
        var cachedClearTimeout;

        function defaultSetTimout() {
            throw new Error('setTimeout has not been defined');
        }
        function defaultClearTimeout () {
            throw new Error('clearTimeout has not been defined');
        }
        (function () {
            try {
                if (typeof setTimeout === 'function') {
                    cachedSetTimeout = setTimeout;
                } else {
                    cachedSetTimeout = defaultSetTimout;
                }
            } catch (e) {
                cachedSetTimeout = defaultSetTimout;
            }
            try {
                if (typeof clearTimeout === 'function') {
                    cachedClearTimeout = clearTimeout;
                } else {
                    cachedClearTimeout = defaultClearTimeout;
                }
            } catch (e) {
                cachedClearTimeout = defaultClearTimeout;
            }
        } ())
        function runTimeout(fun) {
            if (cachedSetTimeout === setTimeout) {
                //normal enviroments in sane situations
                return setTimeout(fun, 0);
            }
            // if setTimeout wasn't available but was latter defined
            if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
                cachedSetTimeout = setTimeout;
                return setTimeout(fun, 0);
            }
            try {
                // when when somebody has screwed with setTimeout but no I.E. maddness
                return cachedSetTimeout(fun, 0);
            } catch(e){
                try {
                    // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
                    return cachedSetTimeout.call(null, fun, 0);
                } catch(e){
                    // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
                    return cachedSetTimeout.call(this, fun, 0);
                }
            }


        }
        function runClearTimeout(marker) {
            if (cachedClearTimeout === clearTimeout) {
                //normal enviroments in sane situations
                return clearTimeout(marker);
            }
            // if clearTimeout wasn't available but was latter defined
            if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
                cachedClearTimeout = clearTimeout;
                return clearTimeout(marker);
            }
            try {
                // when when somebody has screwed with setTimeout but no I.E. maddness
                return cachedClearTimeout(marker);
            } catch (e){
                try {
                    // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
                    return cachedClearTimeout.call(null, marker);
                } catch (e){
                    // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
                    // Some versions of I.E. have different rules for clearTimeout vs setTimeout
                    return cachedClearTimeout.call(this, marker);
                }
            }



        }
        var queue = [];
        var draining = false;
        var currentQueue;
        var queueIndex = -1;

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

        function drainQueue() {
            if (draining) {
                return;
            }
            var timeout = runTimeout(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;
            runClearTimeout(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) {
                runTimeout(drainQueue);
            }
        };

// 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.prependListener = noop;
        process.prependOnceListener = noop;

        process.listeners = function (name) { return [] }

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

    },{}],103:[function(require,module,exports){
        module.exports = require('./lib/_stream_duplex.js');

    },{"./lib/_stream_duplex.js":104}],104:[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.

// 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 pna = require('process-nextick-args');
        /*</replacement>*/

        /*<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 util = Object.create(require('core-util-is'));
        util.inherits = require('inherits');
        /*</replacement>*/

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

        util.inherits(Duplex, Readable);

        {
            // avoid scope creep, the keys array can then be collected
            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);
        }

        Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
            // making it explicit this property is not enumerable
            // because otherwise some prototype manipulation in
            // userland will fail
            enumerable: false,
            get: function () {
                return this._writableState.highWaterMark;
            }
        });

// 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.
            pna.nextTick(onEndNT, this);
        }

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

        Object.defineProperty(Duplex.prototype, 'destroyed', {
            get: function () {
                if (this._readableState === undefined || this._writableState === undefined) {
                    return false;
                }
                return this._readableState.destroyed && this._writableState.destroyed;
            },
            set: function (value) {
                // we ignore the value if the stream
                // has not been initialized yet
                if (this._readableState === undefined || this._writableState === undefined) {
                    return;
                }

                // backward compatibility, the user is explicitly
                // managing destroyed
                this._readableState.destroyed = value;
                this._writableState.destroyed = value;
            }
        });

        Duplex.prototype._destroy = function (err, cb) {
            this.push(null);
            this.end();

            pna.nextTick(cb, err);
        };
    },{"./_stream_readable":106,"./_stream_writable":108,"core-util-is":78,"inherits":84,"process-nextick-args":101}],105:[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.

// 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 = Object.create(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":107,"core-util-is":78,"inherits":84}],106:[function(require,module,exports){
        (function (process,global){(function (){
// 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.

            'use strict';

            /*<replacement>*/

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

            module.exports = Readable;

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

            /*<replacement>*/
            var Duplex;
            /*</replacement>*/

            Readable.ReadableState = ReadableState;

            /*<replacement>*/
            var EE = require('events').EventEmitter;

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

            /*<replacement>*/
            var Stream = require('./internal/streams/stream');
            /*</replacement>*/

            /*<replacement>*/

            var Buffer = require('safe-buffer').Buffer;
            var OurUint8Array = global.Uint8Array || function () {};
            function _uint8ArrayToBuffer(chunk) {
                return Buffer.from(chunk);
            }
            function _isUint8Array(obj) {
                return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
            }

            /*</replacement>*/

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

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

            var BufferList = require('./internal/streams/BufferList');
            var destroyImpl = require('./internal/streams/destroy');
            var StringDecoder;

            util.inherits(Readable, Stream);

            var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];

            function prependListener(emitter, event, fn) {
                // Sadly this is not cacheable as some libraries bundle their own
                // event emitter implementation with them.
                if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);

                // This is a hack to make sure that our error handler is attached before any
                // userland ones.  NEVER DO THIS. This is here only because this code needs
                // to continue to work with older versions of Node.js that do not include
                // the prependListener() method. The goal is to eventually remove this hack.
                if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
            }

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

                options = options || {};

                // Duplex streams are both readable and writable, but share
                // the same options object.
                // However, some cases require setting options to different
                // values for the readable and the writable sides of the duplex stream.
                // These options can be provided separately as readableXXX and writableXXX.
                var isDuplex = stream instanceof Duplex;

                // 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 (isDuplex) 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 readableHwm = options.readableHighWaterMark;
                var defaultHwm = this.objectMode ? 16 : 16 * 1024;

                if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;

                // cast to ints.
                this.highWaterMark = Math.floor(this.highWaterMark);

                // A linked list is used to store data chunks instead of an array because the
                // linked list can remove elements from the beginning faster than
                // array.shift()
                this.buffer = new BufferList();
                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 event 'readable'/'data' is emitted
                // 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 read 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;

                // has it been destroyed
                this.destroyed = 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';

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

            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) {
                    if (typeof options.read === 'function') this._read = options.read;

                    if (typeof options.destroy === 'function') this._destroy = options.destroy;
                }

                Stream.call(this);
            }

            Object.defineProperty(Readable.prototype, 'destroyed', {
                get: function () {
                    if (this._readableState === undefined) {
                        return false;
                    }
                    return this._readableState.destroyed;
                },
                set: function (value) {
                    // we ignore the value if the stream
                    // has not been initialized yet
                    if (!this._readableState) {
                        return;
                    }

                    // backward compatibility, the user is explicitly
                    // managing destroyed
                    this._readableState.destroyed = value;
                }
            });

            Readable.prototype.destroy = destroyImpl.destroy;
            Readable.prototype._undestroy = destroyImpl.undestroy;
            Readable.prototype._destroy = function (err, cb) {
                this.push(null);
                cb(err);
            };

// 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;
                var skipChunkCheck;

                if (!state.objectMode) {
                    if (typeof chunk === 'string') {
                        encoding = encoding || state.defaultEncoding;
                        if (encoding !== state.encoding) {
                            chunk = Buffer.from(chunk, encoding);
                            encoding = '';
                        }
                        skipChunkCheck = true;
                    }
                } else {
                    skipChunkCheck = true;
                }

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

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

            function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
                var state = stream._readableState;
                if (chunk === null) {
                    state.reading = false;
                    onEofChunk(stream, state);
                } else {
                    var er;
                    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
                    if (er) {
                        stream.emit('error', er);
                    } else if (state.objectMode || chunk && chunk.length > 0) {
                        if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
                            chunk = _uint8ArrayToBuffer(chunk);
                        }

                        if (addToFront) {
                            if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
                        } else if (state.ended) {
                            stream.emit('error', new Error('stream.push() after EOF'));
                        } else {
                            state.reading = false;
                            if (state.decoder && !encoding) {
                                chunk = state.decoder.write(chunk);
                                if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
                            } else {
                                addChunk(stream, state, chunk, false);
                            }
                        }
                    } else if (!addToFront) {
                        state.reading = false;
                    }
                }

                return needMoreData(state);
            }

            function addChunk(stream, state, chunk, addToFront) {
                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);
            }

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

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

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

// 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 to prevent increasing hwm excessively in
                    // tiny amounts
                    n--;
                    n |= n >>> 1;
                    n |= n >>> 2;
                    n |= n >>> 4;
                    n |= n >>> 8;
                    n |= n >>> 16;
                    n++;
                }
                return n;
            }

// This function is designed to be inlinable, so please take care when making
// changes to the function body.
            function howMuchToRead(n, state) {
                if (n <= 0 || state.length === 0 && state.ended) return 0;
                if (state.objectMode) return 1;
                if (n !== n) {
                    // Only flow one buffer at a time
                    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
                }
                // If we're asking for more than the current hwm, then raise the hwm.
                if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
                if (n <= state.length) return n;
                // Don't have enough
                if (!state.ended) {
                    state.needReadable = true;
                    return 0;
                }
                return state.length;
            }

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

                if (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);
                } else 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 (!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;
                } else {
                    state.length -= n;
                }

                if (state.length === 0) {
                    // If we have nothing in the buffer, then we want to know
                    // as soon as we *do* get something into the buffer.
                    if (!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) endReadable(this);
                }

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

                return ret;
            };

            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) pna.nextTick(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;
                    pna.nextTick(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('_read() is 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 : unpipe;
                if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);

                dest.on('unpipe', onunpipe);
                function onunpipe(readable, unpipeInfo) {
                    debug('onunpipe');
                    if (readable === src) {
                        if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
                            unpipeInfo.hasUnpiped = true;
                            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', unpipe);
                    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();
                }

                // If the user pushes more data while we're writing to dest then we'll end up
                // in ondata again. However, we only want to increase awaitDrain once because
                // dest will only emit one 'drain' event for the multiple writes.
                // => Introduce a guard on increasing awaitDrain.
                var increasedAwaitDrain = false;
                src.on('data', ondata);
                function ondata(chunk) {
                    debug('ondata');
                    increasedAwaitDrain = false;
                    var ret = dest.write(chunk);
                    if (false === ret && !increasedAwaitDrain) {
                        // If the user unpiped during `dest.write()`, it is possible
                        // to get stuck in a permanently paused state if that write
                        // also returned false.
                        // => Check whether `dest` is still a piping destination.
                        if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
                            debug('false write response, pause', src._readableState.awaitDrain);
                            src._readableState.awaitDrain++;
                            increasedAwaitDrain = true;
                        }
                        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);
                }

                // Make sure our error handler is attached before userland ones.
                prependListener(dest, 'error', onerror);

                // 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;
                var unpipeInfo = { hasUnpiped: false };

                // 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, unpipeInfo);
                    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, unpipeInfo);
                    }return this;
                }

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

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

                dest.emit('unpipe', this, unpipeInfo);

                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 (ev === 'data') {
                    // Start flowing on next tick if stream isn't explicitly paused
                    if (this._readableState.flowing !== false) this.resume();
                } else if (ev === 'readable') {
                    var state = this._readableState;
                    if (!state.endEmitted && !state.readableListening) {
                        state.readableListening = state.needReadable = true;
                        state.emittedReadable = false;
                        if (!state.reading) {
                            pna.nextTick(nReadingNextTick, this);
                        } else if (state.length) {
                            emitReadable(this);
                        }
                    }
                }

                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;
                    pna.nextTick(resume_, stream, state);
                }
            }

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

                state.resumeScheduled = false;
                state.awaitDrain = 0;
                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);
                while (state.flowing && stream.read() !== null) {}
            }

// 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 _this = this;

                var state = this._readableState;
                var paused = false;

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

                    _this.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 = _this.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.
                for (var n = 0; n < kProxyEvents.length; n++) {
                    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
                }

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

                return this;
            };

            Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
                // making it explicit this property is not enumerable
                // because otherwise some prototype manipulation in
                // userland will fail
                enumerable: false,
                get: function () {
                    return this._readableState.highWaterMark;
                }
            });

// 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.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
            function fromList(n, state) {
                // nothing buffered
                if (state.length === 0) return null;

                var ret;
                if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
                    // read it all, truncate the list
                    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
                    state.buffer.clear();
                } else {
                    // read part of list
                    ret = fromListPartial(n, state.buffer, state.decoder);
                }

                return ret;
            }

// Extracts only enough buffered data to satisfy the amount requested.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
            function fromListPartial(n, list, hasStrings) {
                var ret;
                if (n < list.head.data.length) {
                    // slice is the same for buffers and strings
                    ret = list.head.data.slice(0, n);
                    list.head.data = list.head.data.slice(n);
                } else if (n === list.head.data.length) {
                    // first chunk is a perfect match
                    ret = list.shift();
                } else {
                    // result spans more than one buffer
                    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
                }
                return ret;
            }

// Copies a specified amount of characters from the list of buffered data
// chunks.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
            function copyFromBufferString(n, list) {
                var p = list.head;
                var c = 1;
                var ret = p.data;
                n -= ret.length;
                while (p = p.next) {
                    var str = p.data;
                    var nb = n > str.length ? str.length : n;
                    if (nb === str.length) ret += str;else ret += str.slice(0, n);
                    n -= nb;
                    if (n === 0) {
                        if (nb === str.length) {
                            ++c;
                            if (p.next) list.head = p.next;else list.head = list.tail = null;
                        } else {
                            list.head = p;
                            p.data = str.slice(nb);
                        }
                        break;
                    }
                    ++c;
                }
                list.length -= c;
                return ret;
            }

// Copies a specified amount of bytes from the list of buffered data chunks.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
            function copyFromBuffer(n, list) {
                var ret = Buffer.allocUnsafe(n);
                var p = list.head;
                var c = 1;
                p.data.copy(ret);
                n -= p.data.length;
                while (p = p.next) {
                    var buf = p.data;
                    var nb = n > buf.length ? buf.length : n;
                    buf.copy(ret, ret.length - n, 0, nb);
                    n -= nb;
                    if (n === 0) {
                        if (nb === buf.length) {
                            ++c;
                            if (p.next) list.head = p.next;else list.head = list.tail = null;
                        } else {
                            list.head = p;
                            p.data = buf.slice(nb);
                        }
                        break;
                    }
                    ++c;
                }
                list.length -= c;
                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;
                    pna.nextTick(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 indexOf(xs, x) {
                for (var i = 0, l = xs.length; i < l; i++) {
                    if (xs[i] === x) return i;
                }
                return -1;
            }
        }).call(this)}).call(this,require('_process'),typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./_stream_duplex":104,"./internal/streams/BufferList":109,"./internal/streams/destroy":110,"./internal/streams/stream":111,"_process":102,"core-util-is":78,"events":81,"inherits":84,"isarray":85,"process-nextick-args":101,"safe-buffer":116,"string_decoder/":120,"util":76}],107:[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.

// 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 = Object.create(require('core-util-is'));
        util.inherits = require('inherits');
        /*</replacement>*/

        util.inherits(Transform, Duplex);

        function afterTransform(er, data) {
            var ts = this._transformState;
            ts.transforming = false;

            var cb = ts.writecb;

            if (!cb) {
                return this.emit('error', new Error('write callback called multiple times'));
            }

            ts.writechunk = null;
            ts.writecb = null;

            if (data != null) // single equals check for both `null` and `undefined`
                this.push(data);

            cb(er);

            var rs = this._readableState;
            rs.reading = false;
            if (rs.needReadable || rs.length < rs.highWaterMark) {
                this._read(rs.highWaterMark);
            }
        }

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

            Duplex.call(this, options);

            this._transformState = {
                afterTransform: afterTransform.bind(this),
                needTransform: false,
                transforming: false,
                writecb: null,
                writechunk: null,
                writeencoding: null
            };

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

            // When the writable side finishes, then flush out anything remaining.
            this.on('prefinish', prefinish);
        }

        function prefinish() {
            var _this = this;

            if (typeof this._flush === 'function') {
                this._flush(function (er, data) {
                    done(_this, er, data);
                });
            } else {
                done(this, null, null);
            }
        }

        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('_transform() is 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;
            }
        };

        Transform.prototype._destroy = function (err, cb) {
            var _this2 = this;

            Duplex.prototype._destroy.call(this, err, function (err2) {
                cb(err2);
                _this2.emit('close');
            });
        };

        function done(stream, er, data) {
            if (er) return stream.emit('error', er);

            if (data != null) // single equals check for both `null` and `undefined`
                stream.push(data);

            // if there's nothing in the write buffer, then that means
            // that nothing more will ever be provided
            if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');

            if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');

            return stream.push(null);
        }
    },{"./_stream_duplex":104,"core-util-is":78,"inherits":84}],108:[function(require,module,exports){
        (function (process,global,setImmediate){(function (){
// 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.

// 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';

            /*<replacement>*/

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

            module.exports = Writable;

            /* <replacement> */
            function WriteReq(chunk, encoding, cb) {
                this.chunk = chunk;
                this.encoding = encoding;
                this.callback = cb;
                this.next = null;
            }

// 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 () {
                    onCorkedFinish(_this, state);
                };
            }
            /* </replacement> */

            /*<replacement>*/
            var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
            /*</replacement>*/

            /*<replacement>*/
            var Duplex;
            /*</replacement>*/

            Writable.WritableState = WritableState;

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

            /*<replacement>*/
            var internalUtil = {
                deprecate: require('util-deprecate')
            };
            /*</replacement>*/

            /*<replacement>*/
            var Stream = require('./internal/streams/stream');
            /*</replacement>*/

            /*<replacement>*/

            var Buffer = require('safe-buffer').Buffer;
            var OurUint8Array = global.Uint8Array || function () {};
            function _uint8ArrayToBuffer(chunk) {
                return Buffer.from(chunk);
            }
            function _isUint8Array(obj) {
                return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
            }

            /*</replacement>*/

            var destroyImpl = require('./internal/streams/destroy');

            util.inherits(Writable, Stream);

            function nop() {}

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

                options = options || {};

                // Duplex streams are both readable and writable, but share
                // the same options object.
                // However, some cases require setting options to different
                // values for the readable and the writable sides of the duplex stream.
                // These options can be provided separately as readableXXX and writableXXX.
                var isDuplex = stream instanceof Duplex;

                // object stream flag to indicate whether or not this stream
                // contains buffers or objects.
                this.objectMode = !!options.objectMode;

                if (isDuplex) 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 writableHwm = options.writableHighWaterMark;
                var defaultHwm = this.objectMode ? 16 : 16 * 1024;

                if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;

                // cast to ints.
                this.highWaterMark = Math.floor(this.highWaterMark);

                // if _final has been called
                this.finalCalled = false;

                // drain event flag.
                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;

                // has it been destroyed
                this.destroyed = 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;

                // allocate the first CorkedRequest, there is always
                // one allocated and free to use, and we maintain at most two
                this.corkedRequestsFree = new CorkedRequest(this);
            }

            WritableState.prototype.getBuffer = function getBuffer() {
                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.', 'DEP0003')
                    });
                } catch (_) {}
            })();

// Test _writableState for inheritance to account for Duplex streams,
// whose prototype chain only points to Readable.
            var realHasInstance;
            if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
                realHasInstance = Function.prototype[Symbol.hasInstance];
                Object.defineProperty(Writable, Symbol.hasInstance, {
                    value: function (object) {
                        if (realHasInstance.call(this, object)) return true;
                        if (this !== Writable) return false;

                        return object && object._writableState instanceof WritableState;
                    }
                });
            } else {
                realHasInstance = function (object) {
                    return object instanceof this;
                };
            }

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

                // Writable ctor is applied to Duplexes, too.
                // `realHasInstance` is necessary because using plain `instanceof`
                // would return false, as no `_writableState` property is attached.

                // Trying to use the custom `instanceof` for Writable here will also break the
                // Node.js LazyTransform implementation, which has a non-trivial getter for
                // `_writableState` that would lead to infinite recursion.
                if (!realHasInstance.call(Writable, this) && !(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;

                    if (typeof options.destroy === 'function') this._destroy = options.destroy;

                    if (typeof options.final === 'function') this._final = options.final;
                }

                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);
                pna.nextTick(cb, er);
            }

// Checks that a user-supplied chunk is valid, especially for the particular
// mode the stream is in. Currently this means that `null` is never accepted
// and undefined/non-string values are only allowed in object mode.
            function validChunk(stream, state, chunk, cb) {
                var valid = true;
                var er = false;

                if (chunk === null) {
                    er = new TypeError('May not write null values to stream');
                } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
                    er = new TypeError('Invalid non-string/buffer chunk');
                }
                if (er) {
                    stream.emit('error', er);
                    pna.nextTick(cb, er);
                    valid = false;
                }
                return valid;
            }

            Writable.prototype.write = function (chunk, encoding, cb) {
                var state = this._writableState;
                var ret = false;
                var isBuf = !state.objectMode && _isUint8Array(chunk);

                if (isBuf && !Buffer.isBuffer(chunk)) {
                    chunk = _uint8ArrayToBuffer(chunk);
                }

                if (typeof encoding === 'function') {
                    cb = encoding;
                    encoding = null;
                }

                if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;

                if (typeof cb !== 'function') cb = nop;

                if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
                    state.pendingcb++;
                    ret = writeOrBuffer(this, state, isBuf, 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;
                return this;
            };

            function decodeChunk(state, chunk, encoding) {
                if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
                    chunk = Buffer.from(chunk, encoding);
                }
                return chunk;
            }

            Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
                // making it explicit this property is not enumerable
                // because otherwise some prototype manipulation in
                // userland will fail
                enumerable: false,
                get: function () {
                    return this._writableState.highWaterMark;
                }
            });

// 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, isBuf, chunk, encoding, cb) {
                if (!isBuf) {
                    var newChunk = decodeChunk(state, chunk, encoding);
                    if (chunk !== newChunk) {
                        isBuf = true;
                        encoding = 'buffer';
                        chunk = newChunk;
                    }
                }
                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 = {
                        chunk: chunk,
                        encoding: encoding,
                        isBuf: isBuf,
                        callback: cb,
                        next: null
                    };
                    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) {
                    // defer the callback if we are being called synchronously
                    // to avoid piling up things on the stack
                    pna.nextTick(cb, er);
                    // this can emit finish, and it will always happen
                    // after error
                    pna.nextTick(finishMaybe, stream, state);
                    stream._writableState.errorEmitted = true;
                    stream.emit('error', er);
                } else {
                    // the caller expect this to happen before if
                    // it is async
                    cb(er);
                    stream._writableState.errorEmitted = true;
                    stream.emit('error', er);
                    // this can emit finish, but finish must
                    // always follow error
                    finishMaybe(stream, state);
                }
            }

            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;
                    var allBuffers = true;
                    while (entry) {
                        buffer[count] = entry;
                        if (!entry.isBuf) allBuffers = false;
                        entry = entry.next;
                        count += 1;
                    }
                    buffer.allBuffers = allBuffers;

                    doWrite(stream, state, true, state.length, buffer, '', holder.finish);

                    // doWrite is almost always async, defer these to save a bit of time
                    // as the hot path ends with doWrite
                    state.pendingcb++;
                    state.lastBufferedRequest = null;
                    if (holder.next) {
                        state.corkedRequestsFree = holder.next;
                        holder.next = null;
                    } else {
                        state.corkedRequestsFree = new CorkedRequest(state);
                    }
                    state.bufferedRequestCount = 0;
                } 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;
                        state.bufferedRequestCount--;
                        // 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.bufferedRequest = entry;
                state.bufferProcessing = false;
            }

            Writable.prototype._write = function (chunk, encoding, cb) {
                cb(new Error('_write() is 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 callFinal(stream, state) {
                stream._final(function (err) {
                    state.pendingcb--;
                    if (err) {
                        stream.emit('error', err);
                    }
                    state.prefinished = true;
                    stream.emit('prefinish');
                    finishMaybe(stream, state);
                });
            }
            function prefinish(stream, state) {
                if (!state.prefinished && !state.finalCalled) {
                    if (typeof stream._final === 'function') {
                        state.pendingcb++;
                        state.finalCalled = true;
                        pna.nextTick(callFinal, stream, state);
                    } else {
                        state.prefinished = true;
                        stream.emit('prefinish');
                    }
                }
            }

            function finishMaybe(stream, state) {
                var need = needFinish(state);
                if (need) {
                    prefinish(stream, state);
                    if (state.pendingcb === 0) {
                        state.finished = true;
                        stream.emit('finish');
                    }
                }
                return need;
            }

            function endWritable(stream, state, cb) {
                state.ending = true;
                finishMaybe(stream, state);
                if (cb) {
                    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
                }
                state.ended = true;
                stream.writable = false;
            }

            function onCorkedFinish(corkReq, state, err) {
                var entry = corkReq.entry;
                corkReq.entry = null;
                while (entry) {
                    var cb = entry.callback;
                    state.pendingcb--;
                    cb(err);
                    entry = entry.next;
                }
                if (state.corkedRequestsFree) {
                    state.corkedRequestsFree.next = corkReq;
                } else {
                    state.corkedRequestsFree = corkReq;
                }
            }

            Object.defineProperty(Writable.prototype, 'destroyed', {
                get: function () {
                    if (this._writableState === undefined) {
                        return false;
                    }
                    return this._writableState.destroyed;
                },
                set: function (value) {
                    // we ignore the value if the stream
                    // has not been initialized yet
                    if (!this._writableState) {
                        return;
                    }

                    // backward compatibility, the user is explicitly
                    // managing destroyed
                    this._writableState.destroyed = value;
                }
            });

            Writable.prototype.destroy = destroyImpl.destroy;
            Writable.prototype._undestroy = destroyImpl.undestroy;
            Writable.prototype._destroy = function (err, cb) {
                this.end();
                cb(err);
            };
        }).call(this)}).call(this,require('_process'),typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
    },{"./_stream_duplex":104,"./internal/streams/destroy":110,"./internal/streams/stream":111,"_process":102,"core-util-is":78,"inherits":84,"process-nextick-args":101,"safe-buffer":116,"timers":121,"util-deprecate":123}],109:[function(require,module,exports){
        'use strict';

        function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

        var Buffer = require('safe-buffer').Buffer;
        var util = require('util');

        function copyBuffer(src, target, offset) {
            src.copy(target, offset);
        }

        module.exports = function () {
            function BufferList() {
                _classCallCheck(this, BufferList);

                this.head = null;
                this.tail = null;
                this.length = 0;
            }

            BufferList.prototype.push = function push(v) {
                var entry = { data: v, next: null };
                if (this.length > 0) this.tail.next = entry;else this.head = entry;
                this.tail = entry;
                ++this.length;
            };

            BufferList.prototype.unshift = function unshift(v) {
                var entry = { data: v, next: this.head };
                if (this.length === 0) this.tail = entry;
                this.head = entry;
                ++this.length;
            };

            BufferList.prototype.shift = function shift() {
                if (this.length === 0) return;
                var ret = this.head.data;
                if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
                --this.length;
                return ret;
            };

            BufferList.prototype.clear = function clear() {
                this.head = this.tail = null;
                this.length = 0;
            };

            BufferList.prototype.join = function join(s) {
                if (this.length === 0) return '';
                var p = this.head;
                var ret = '' + p.data;
                while (p = p.next) {
                    ret += s + p.data;
                }return ret;
            };

            BufferList.prototype.concat = function concat(n) {
                if (this.length === 0) return Buffer.alloc(0);
                if (this.length === 1) return this.head.data;
                var ret = Buffer.allocUnsafe(n >>> 0);
                var p = this.head;
                var i = 0;
                while (p) {
                    copyBuffer(p.data, ret, i);
                    i += p.data.length;
                    p = p.next;
                }
                return ret;
            };

            return BufferList;
        }();

        if (util && util.inspect && util.inspect.custom) {
            module.exports.prototype[util.inspect.custom] = function () {
                var obj = util.inspect({ length: this.length });
                return this.constructor.name + ' ' + obj;
            };
        }
    },{"safe-buffer":116,"util":76}],110:[function(require,module,exports){
        'use strict';

        /*<replacement>*/

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

// undocumented cb() API, needed for core, not for public API
        function destroy(err, cb) {
            var _this = this;

            var readableDestroyed = this._readableState && this._readableState.destroyed;
            var writableDestroyed = this._writableState && this._writableState.destroyed;

            if (readableDestroyed || writableDestroyed) {
                if (cb) {
                    cb(err);
                } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
                    pna.nextTick(emitErrorNT, this, err);
                }
                return this;
            }

            // we set destroyed to true before firing error callbacks in order
            // to make it re-entrance safe in case destroy() is called within callbacks

            if (this._readableState) {
                this._readableState.destroyed = true;
            }

            // if this is a duplex stream mark the writable part as destroyed as well
            if (this._writableState) {
                this._writableState.destroyed = true;
            }

            this._destroy(err || null, function (err) {
                if (!cb && err) {
                    pna.nextTick(emitErrorNT, _this, err);
                    if (_this._writableState) {
                        _this._writableState.errorEmitted = true;
                    }
                } else if (cb) {
                    cb(err);
                }
            });

            return this;
        }

        function undestroy() {
            if (this._readableState) {
                this._readableState.destroyed = false;
                this._readableState.reading = false;
                this._readableState.ended = false;
                this._readableState.endEmitted = false;
            }

            if (this._writableState) {
                this._writableState.destroyed = false;
                this._writableState.ended = false;
                this._writableState.ending = false;
                this._writableState.finished = false;
                this._writableState.errorEmitted = false;
            }
        }

        function emitErrorNT(self, err) {
            self.emit('error', err);
        }

        module.exports = {
            destroy: destroy,
            undestroy: undestroy
        };
    },{"process-nextick-args":101}],111:[function(require,module,exports){
        module.exports = require('events').EventEmitter;

    },{"events":81}],112:[function(require,module,exports){
        module.exports = require('./readable').PassThrough

    },{"./readable":113}],113:[function(require,module,exports){
        exports = module.exports = require('./lib/_stream_readable.js');
        exports.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":104,"./lib/_stream_passthrough.js":105,"./lib/_stream_readable.js":106,"./lib/_stream_transform.js":107,"./lib/_stream_writable.js":108}],114:[function(require,module,exports){
        module.exports = require('./readable').Transform

    },{"./readable":113}],115:[function(require,module,exports){
        module.exports = require('./lib/_stream_writable.js');

    },{"./lib/_stream_writable.js":108}],116:[function(require,module,exports){
        /* eslint-disable node/no-deprecated-api */
        var buffer = require('buffer')
        var Buffer = buffer.Buffer

// alternative to using Object.keys for old browsers
        function copyProps (src, dst) {
            for (var key in src) {
                dst[key] = src[key]
            }
        }
        if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
            module.exports = buffer
        } else {
            // Copy properties from require('buffer')
            copyProps(buffer, exports)
            exports.Buffer = SafeBuffer
        }

        function SafeBuffer (arg, encodingOrOffset, length) {
            return Buffer(arg, encodingOrOffset, length)
        }

// Copy static methods from Buffer
        copyProps(Buffer, SafeBuffer)

        SafeBuffer.from = function (arg, encodingOrOffset, length) {
            if (typeof arg === 'number') {
                throw new TypeError('Argument must not be a number')
            }
            return Buffer(arg, encodingOrOffset, length)
        }

        SafeBuffer.alloc = function (size, fill, encoding) {
            if (typeof size !== 'number') {
                throw new TypeError('Argument must be a number')
            }
            var buf = Buffer(size)
            if (fill !== undefined) {
                if (typeof encoding === 'string') {
                    buf.fill(fill, encoding)
                } else {
                    buf.fill(fill)
                }
            } else {
                buf.fill(0)
            }
            return buf
        }

        SafeBuffer.allocUnsafe = function (size) {
            if (typeof size !== 'number') {
                throw new TypeError('Argument must be a number')
            }
            return Buffer(size)
        }

        SafeBuffer.allocUnsafeSlow = function (size) {
            if (typeof size !== 'number') {
                throw new TypeError('Argument must be a number')
            }
            return buffer.SlowBuffer(size)
        }

    },{"buffer":77}],117:[function(require,module,exports){
        (function (Buffer){(function (){
            ;(function (sax) { // wrapper for non-node envs
                sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
                sax.SAXParser = SAXParser
                sax.SAXStream = SAXStream
                sax.createStream = createStream

                // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
                // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
                // since that's the earliest that a buffer overrun could occur.  This way, checks are
                // as rare as required, but as often as necessary to ensure never crossing this bound.
                // Furthermore, buffers are only tested at most once per write(), so passing a very
                // large string into write() might have undesirable effects, but this is manageable by
                // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
                // edge case, result in creating at most one complete copy of the string passed in.
                // Set to Infinity to have unlimited buffers.
                sax.MAX_BUFFER_LENGTH = 64 * 1024

                var buffers = [
                    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
                    'procInstName', 'procInstBody', 'entity', 'attribName',
                    'attribValue', 'cdata', 'script'
                ]

                sax.EVENTS = [
                    'text',
                    'processinginstruction',
                    'sgmldeclaration',
                    'doctype',
                    'comment',
                    'attribute',
                    'opentag',
                    'closetag',
                    'opencdata',
                    'cdata',
                    'closecdata',
                    'error',
                    'end',
                    'ready',
                    'script',
                    'opennamespace',
                    'closenamespace'
                ]

                function SAXParser (strict, opt) {
                    if (!(this instanceof SAXParser)) {
                        return new SAXParser(strict, opt)
                    }

                    var parser = this
                    clearBuffers(parser)
                    parser.q = parser.c = ''
                    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
                    parser.opt = opt || {}
                    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags
                    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'
                    parser.tags = []
                    parser.closed = parser.closedRoot = parser.sawRoot = false
                    parser.tag = parser.error = null
                    parser.strict = !!strict
                    parser.noscript = !!(strict || parser.opt.noscript)
                    parser.state = S.BEGIN
                    parser.strictEntities = parser.opt.strictEntities
                    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)
                    parser.attribList = []

                    // namespaces form a prototype chain.
                    // it always points at the current tag,
                    // which protos to its parent tag.
                    if (parser.opt.xmlns) {
                        parser.ns = Object.create(rootNS)
                    }

                    // mostly just for error reporting
                    parser.trackPosition = parser.opt.position !== false
                    if (parser.trackPosition) {
                        parser.position = parser.line = parser.column = 0
                    }
                    emit(parser, 'onready')
                }

                if (!Object.create) {
                    Object.create = function (o) {
                        function F () {}
                        F.prototype = o
                        var newf = new F()
                        return newf
                    }
                }

                if (!Object.keys) {
                    Object.keys = function (o) {
                        var a = []
                        for (var i in o) if (o.hasOwnProperty(i)) a.push(i)
                        return a
                    }
                }

                function checkBufferLength (parser) {
                    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)
                    var maxActual = 0
                    for (var i = 0, l = buffers.length; i < l; i++) {
                        var len = parser[buffers[i]].length
                        if (len > maxAllowed) {
                            // Text/cdata nodes can get big, and since they're buffered,
                            // we can get here under normal conditions.
                            // Avoid issues by emitting the text node now,
                            // so at least it won't get any bigger.
                            switch (buffers[i]) {
                                case 'textNode':
                                    closeText(parser)
                                    break

                                case 'cdata':
                                    emitNode(parser, 'oncdata', parser.cdata)
                                    parser.cdata = ''
                                    break

                                case 'script':
                                    emitNode(parser, 'onscript', parser.script)
                                    parser.script = ''
                                    break

                                default:
                                    error(parser, 'Max buffer length exceeded: ' + buffers[i])
                            }
                        }
                        maxActual = Math.max(maxActual, len)
                    }
                    // schedule the next check for the earliest possible buffer overrun.
                    var m = sax.MAX_BUFFER_LENGTH - maxActual
                    parser.bufferCheckPosition = m + parser.position
                }

                function clearBuffers (parser) {
                    for (var i = 0, l = buffers.length; i < l; i++) {
                        parser[buffers[i]] = ''
                    }
                }

                function flushBuffers (parser) {
                    closeText(parser)
                    if (parser.cdata !== '') {
                        emitNode(parser, 'oncdata', parser.cdata)
                        parser.cdata = ''
                    }
                    if (parser.script !== '') {
                        emitNode(parser, 'onscript', parser.script)
                        parser.script = ''
                    }
                }

                SAXParser.prototype = {
                    end: function () { end(this) },
                    write: write,
                    resume: function () { this.error = null; return this },
                    close: function () { return this.write(null) },
                    flush: function () { flushBuffers(this) }
                }

                var Stream
                try {
                    Stream = require('stream').Stream
                } catch (ex) {
                    Stream = function () {}
                }

                var streamWraps = sax.EVENTS.filter(function (ev) {
                    return ev !== 'error' && ev !== 'end'
                })

                function createStream (strict, opt) {
                    return new SAXStream(strict, opt)
                }

                function SAXStream (strict, opt) {
                    if (!(this instanceof SAXStream)) {
                        return new SAXStream(strict, opt)
                    }

                    Stream.apply(this)

                    this._parser = new SAXParser(strict, opt)
                    this.writable = true
                    this.readable = true

                    var me = this

                    this._parser.onend = function () {
                        me.emit('end')
                    }

                    this._parser.onerror = function (er) {
                        me.emit('error', er)

                        // if didn't throw, then means error was handled.
                        // go ahead and clear error, so we can write again.
                        me._parser.error = null
                    }

                    this._decoder = null

                    streamWraps.forEach(function (ev) {
                        Object.defineProperty(me, 'on' + ev, {
                            get: function () {
                                return me._parser['on' + ev]
                            },
                            set: function (h) {
                                if (!h) {
                                    me.removeAllListeners(ev)
                                    me._parser['on' + ev] = h
                                    return h
                                }
                                me.on(ev, h)
                            },
                            enumerable: true,
                            configurable: false
                        })
                    })
                }

                SAXStream.prototype = Object.create(Stream.prototype, {
                    constructor: {
                        value: SAXStream
                    }
                })

                SAXStream.prototype.write = function (data) {
                    if (typeof Buffer === 'function' &&
                        typeof Buffer.isBuffer === 'function' &&
                        Buffer.isBuffer(data)) {
                        if (!this._decoder) {
                            var SD = require('string_decoder').StringDecoder
                            this._decoder = new SD('utf8')
                        }
                        data = this._decoder.write(data)
                    }

                    this._parser.write(data.toString())
                    this.emit('data', data)
                    return true
                }

                SAXStream.prototype.end = function (chunk) {
                    if (chunk && chunk.length) {
                        this.write(chunk)
                    }
                    this._parser.end()
                    return true
                }

                SAXStream.prototype.on = function (ev, handler) {
                    var me = this
                    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
                        me._parser['on' + ev] = function () {
                            var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)
                            args.splice(0, 0, ev)
                            me.emit.apply(me, args)
                        }
                    }

                    return Stream.prototype.on.call(me, ev, handler)
                }

                // character classes and tokens
                var whitespace = '\r\n\t '

                // this really needs to be replaced with character classes.
                // XML allows all manner of ridiculous numbers and digits.
                var number = '0124356789'
                var letter = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

                // (Letter | "_" | ":")
                var quote = '\'"'
                var attribEnd = whitespace + '>'
                var CDATA = '[CDATA['
                var DOCTYPE = 'DOCTYPE'
                var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'
                var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'
                var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }

                // turn all the string character sets into character class objects.
                whitespace = charClass(whitespace)
                number = charClass(number)
                letter = charClass(letter)

                // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
                // This implementation works on strings, a single character at a time
                // as such, it cannot ever support astral-plane characters (10000-EFFFF)
                // without a significant breaking change to either this  parser, or the
                // JavaScript language.  Implementation of an emoji-capable xml parser
                // is left as an exercise for the reader.
                var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/

                var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/

                var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
                var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/

                quote = charClass(quote)
                attribEnd = charClass(attribEnd)

                function charClass (str) {
                    return str.split('').reduce(function (s, c) {
                        s[c] = true
                        return s
                    }, {})
                }

                function isRegExp (c) {
                    return Object.prototype.toString.call(c) === '[object RegExp]'
                }

                function is (charclass, c) {
                    return isRegExp(charclass) ? !!c.match(charclass) : charclass[c]
                }

                function not (charclass, c) {
                    return !is(charclass, c)
                }

                var S = 0
                sax.STATE = {
                    BEGIN: S++, // leading byte order mark or whitespace
                    BEGIN_WHITESPACE: S++, // leading whitespace
                    TEXT: S++, // general stuff
                    TEXT_ENTITY: S++, // &amp and such.
                    OPEN_WAKA: S++, // <
                    SGML_DECL: S++, // <!BLARG
                    SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
                    DOCTYPE: S++, // <!DOCTYPE
                    DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
                    DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
                    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
                    COMMENT_STARTING: S++, // <!-
                    COMMENT: S++, // <!--
                    COMMENT_ENDING: S++, // <!-- blah -
                    COMMENT_ENDED: S++, // <!-- blah --
                    CDATA: S++, // <![CDATA[ something
                    CDATA_ENDING: S++, // ]
                    CDATA_ENDING_2: S++, // ]]
                    PROC_INST: S++, // <?hi
                    PROC_INST_BODY: S++, // <?hi there
                    PROC_INST_ENDING: S++, // <?hi "there" ?
                    OPEN_TAG: S++, // <strong
                    OPEN_TAG_SLASH: S++, // <strong /
                    ATTRIB: S++, // <a
                    ATTRIB_NAME: S++, // <a foo
                    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
                    ATTRIB_VALUE: S++, // <a foo=
                    ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
                    ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
                    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
                    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
                    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
                    CLOSE_TAG: S++, // </a
                    CLOSE_TAG_SAW_WHITE: S++, // </a   >
                    SCRIPT: S++, // <script> ...
                    SCRIPT_ENDING: S++ // <script> ... <
                }

                sax.XML_ENTITIES = {
                    'amp': '&',
                    'gt': '>',
                    'lt': '<',
                    'quot': '"',
                    'apos': "'"
                }

                sax.ENTITIES = {
                    'amp': '&',
                    'gt': '>',
                    'lt': '<',
                    'quot': '"',
                    'apos': "'",
                    'AElig': 198,
                    'Aacute': 193,
                    'Acirc': 194,
                    'Agrave': 192,
                    'Aring': 197,
                    'Atilde': 195,
                    'Auml': 196,
                    'Ccedil': 199,
                    'ETH': 208,
                    'Eacute': 201,
                    'Ecirc': 202,
                    'Egrave': 200,
                    'Euml': 203,
                    'Iacute': 205,
                    'Icirc': 206,
                    'Igrave': 204,
                    'Iuml': 207,
                    'Ntilde': 209,
                    'Oacute': 211,
                    'Ocirc': 212,
                    'Ograve': 210,
                    'Oslash': 216,
                    'Otilde': 213,
                    'Ouml': 214,
                    'THORN': 222,
                    'Uacute': 218,
                    'Ucirc': 219,
                    'Ugrave': 217,
                    'Uuml': 220,
                    'Yacute': 221,
                    'aacute': 225,
                    'acirc': 226,
                    'aelig': 230,
                    'agrave': 224,
                    'aring': 229,
                    'atilde': 227,
                    'auml': 228,
                    'ccedil': 231,
                    'eacute': 233,
                    'ecirc': 234,
                    'egrave': 232,
                    'eth': 240,
                    'euml': 235,
                    'iacute': 237,
                    'icirc': 238,
                    'igrave': 236,
                    'iuml': 239,
                    'ntilde': 241,
                    'oacute': 243,
                    'ocirc': 244,
                    'ograve': 242,
                    'oslash': 248,
                    'otilde': 245,
                    'ouml': 246,
                    'szlig': 223,
                    'thorn': 254,
                    'uacute': 250,
                    'ucirc': 251,
                    'ugrave': 249,
                    'uuml': 252,
                    'yacute': 253,
                    'yuml': 255,
                    'copy': 169,
                    'reg': 174,
                    'nbsp': 160,
                    'iexcl': 161,
                    'cent': 162,
                    'pound': 163,
                    'curren': 164,
                    'yen': 165,
                    'brvbar': 166,
                    'sect': 167,
                    'uml': 168,
                    'ordf': 170,
                    'laquo': 171,
                    'not': 172,
                    'shy': 173,
                    'macr': 175,
                    'deg': 176,
                    'plusmn': 177,
                    'sup1': 185,
                    'sup2': 178,
                    'sup3': 179,
                    'acute': 180,
                    'micro': 181,
                    'para': 182,
                    'middot': 183,
                    'cedil': 184,
                    'ordm': 186,
                    'raquo': 187,
                    'frac14': 188,
                    'frac12': 189,
                    'frac34': 190,
                    'iquest': 191,
                    'times': 215,
                    'divide': 247,
                    'OElig': 338,
                    'oelig': 339,
                    'Scaron': 352,
                    'scaron': 353,
                    'Yuml': 376,
                    'fnof': 402,
                    'circ': 710,
                    'tilde': 732,
                    'Alpha': 913,
                    'Beta': 914,
                    'Gamma': 915,
                    'Delta': 916,
                    'Epsilon': 917,
                    'Zeta': 918,
                    'Eta': 919,
                    'Theta': 920,
                    'Iota': 921,
                    'Kappa': 922,
                    'Lambda': 923,
                    'Mu': 924,
                    'Nu': 925,
                    'Xi': 926,
                    'Omicron': 927,
                    'Pi': 928,
                    'Rho': 929,
                    'Sigma': 931,
                    'Tau': 932,
                    'Upsilon': 933,
                    'Phi': 934,
                    'Chi': 935,
                    'Psi': 936,
                    'Omega': 937,
                    'alpha': 945,
                    'beta': 946,
                    'gamma': 947,
                    'delta': 948,
                    'epsilon': 949,
                    'zeta': 950,
                    'eta': 951,
                    'theta': 952,
                    'iota': 953,
                    'kappa': 954,
                    'lambda': 955,
                    'mu': 956,
                    'nu': 957,
                    'xi': 958,
                    'omicron': 959,
                    'pi': 960,
                    'rho': 961,
                    'sigmaf': 962,
                    'sigma': 963,
                    'tau': 964,
                    'upsilon': 965,
                    'phi': 966,
                    'chi': 967,
                    'psi': 968,
                    'omega': 969,
                    'thetasym': 977,
                    'upsih': 978,
                    'piv': 982,
                    'ensp': 8194,
                    'emsp': 8195,
                    'thinsp': 8201,
                    'zwnj': 8204,
                    'zwj': 8205,
                    'lrm': 8206,
                    'rlm': 8207,
                    'ndash': 8211,
                    'mdash': 8212,
                    'lsquo': 8216,
                    'rsquo': 8217,
                    'sbquo': 8218,
                    'ldquo': 8220,
                    'rdquo': 8221,
                    'bdquo': 8222,
                    'dagger': 8224,
                    'Dagger': 8225,
                    'bull': 8226,
                    'hellip': 8230,
                    'permil': 8240,
                    'prime': 8242,
                    'Prime': 8243,
                    'lsaquo': 8249,
                    'rsaquo': 8250,
                    'oline': 8254,
                    'frasl': 8260,
                    'euro': 8364,
                    'image': 8465,
                    'weierp': 8472,
                    'real': 8476,
                    'trade': 8482,
                    'alefsym': 8501,
                    'larr': 8592,
                    'uarr': 8593,
                    'rarr': 8594,
                    'darr': 8595,
                    'harr': 8596,
                    'crarr': 8629,
                    'lArr': 8656,
                    'uArr': 8657,
                    'rArr': 8658,
                    'dArr': 8659,
                    'hArr': 8660,
                    'forall': 8704,
                    'part': 8706,
                    'exist': 8707,
                    'empty': 8709,
                    'nabla': 8711,
                    'isin': 8712,
                    'notin': 8713,
                    'ni': 8715,
                    'prod': 8719,
                    'sum': 8721,
                    'minus': 8722,
                    'lowast': 8727,
                    'radic': 8730,
                    'prop': 8733,
                    'infin': 8734,
                    'ang': 8736,
                    'and': 8743,
                    'or': 8744,
                    'cap': 8745,
                    'cup': 8746,
                    'int': 8747,
                    'there4': 8756,
                    'sim': 8764,
                    'cong': 8773,
                    'asymp': 8776,
                    'ne': 8800,
                    'equiv': 8801,
                    'le': 8804,
                    'ge': 8805,
                    'sub': 8834,
                    'sup': 8835,
                    'nsub': 8836,
                    'sube': 8838,
                    'supe': 8839,
                    'oplus': 8853,
                    'otimes': 8855,
                    'perp': 8869,
                    'sdot': 8901,
                    'lceil': 8968,
                    'rceil': 8969,
                    'lfloor': 8970,
                    'rfloor': 8971,
                    'lang': 9001,
                    'rang': 9002,
                    'loz': 9674,
                    'spades': 9824,
                    'clubs': 9827,
                    'hearts': 9829,
                    'diams': 9830
                }

                Object.keys(sax.ENTITIES).forEach(function (key) {
                    var e = sax.ENTITIES[key]
                    var s = typeof e === 'number' ? String.fromCharCode(e) : e
                    sax.ENTITIES[key] = s
                })

                for (var s in sax.STATE) {
                    sax.STATE[sax.STATE[s]] = s
                }

                // shorthand
                S = sax.STATE

                function emit (parser, event, data) {
                    parser[event] && parser[event](data)
                }

                function emitNode (parser, nodeType, data) {
                    if (parser.textNode) closeText(parser)
                    emit(parser, nodeType, data)
                }

                function closeText (parser) {
                    parser.textNode = textopts(parser.opt, parser.textNode)
                    if (parser.textNode) emit(parser, 'ontext', parser.textNode)
                    parser.textNode = ''
                }

                function textopts (opt, text) {
                    if (opt.trim) text = text.trim()
                    if (opt.normalize) text = text.replace(/\s+/g, ' ')
                    return text
                }

                function error (parser, er) {
                    closeText(parser)
                    if (parser.trackPosition) {
                        er += '\nLine: ' + parser.line +
                            '\nColumn: ' + parser.column +
                            '\nChar: ' + parser.c
                    }
                    er = new Error(er)
                    parser.error = er
                    emit(parser, 'onerror', er)
                    return parser
                }

                function end (parser) {
                    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')
                    if ((parser.state !== S.BEGIN) &&
                        (parser.state !== S.BEGIN_WHITESPACE) &&
                        (parser.state !== S.TEXT)) {
                        error(parser, 'Unexpected end')
                    }
                    closeText(parser)
                    parser.c = ''
                    parser.closed = true
                    emit(parser, 'onend')
                    SAXParser.call(parser, parser.strict, parser.opt)
                    return parser
                }

                function strictFail (parser, message) {
                    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
                        throw new Error('bad call to strictFail')
                    }
                    if (parser.strict) {
                        error(parser, message)
                    }
                }

                function newTag (parser) {
                    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
                    var parent = parser.tags[parser.tags.length - 1] || parser
                    var tag = parser.tag = { name: parser.tagName, attributes: {} }

                    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
                    if (parser.opt.xmlns) {
                        tag.ns = parent.ns
                    }
                    parser.attribList.length = 0
                }

                function qname (name, attribute) {
                    var i = name.indexOf(':')
                    var qualName = i < 0 ? [ '', name ] : name.split(':')
                    var prefix = qualName[0]
                    var local = qualName[1]

                    // <x "xmlns"="http://foo">
                    if (attribute && name === 'xmlns') {
                        prefix = 'xmlns'
                        local = ''
                    }

                    return { prefix: prefix, local: local }
                }

                function attrib (parser) {
                    if (!parser.strict) {
                        parser.attribName = parser.attribName[parser.looseCase]()
                    }

                    if (parser.attribList.indexOf(parser.attribName) !== -1 ||
                        parser.tag.attributes.hasOwnProperty(parser.attribName)) {
                        parser.attribName = parser.attribValue = ''
                        return
                    }

                    if (parser.opt.xmlns) {
                        var qn = qname(parser.attribName, true)
                        var prefix = qn.prefix
                        var local = qn.local

                        if (prefix === 'xmlns') {
                            // namespace binding attribute. push the binding into scope
                            if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
                                strictFail(parser,
                                    'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
                                    'Actual: ' + parser.attribValue)
                            } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
                                strictFail(parser,
                                    'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
                                    'Actual: ' + parser.attribValue)
                            } else {
                                var tag = parser.tag
                                var parent = parser.tags[parser.tags.length - 1] || parser
                                if (tag.ns === parent.ns) {
                                    tag.ns = Object.create(parent.ns)
                                }
                                tag.ns[local] = parser.attribValue
                            }
                        }

                        // defer onattribute events until all attributes have been seen
                        // so any new bindings can take effect. preserve attribute order
                        // so deferred events can be emitted in document order
                        parser.attribList.push([parser.attribName, parser.attribValue])
                    } else {
                        // in non-xmlns mode, we can emit the event right away
                        parser.tag.attributes[parser.attribName] = parser.attribValue
                        emitNode(parser, 'onattribute', {
                            name: parser.attribName,
                            value: parser.attribValue
                        })
                    }

                    parser.attribName = parser.attribValue = ''
                }

                function openTag (parser, selfClosing) {
                    if (parser.opt.xmlns) {
                        // emit namespace binding events
                        var tag = parser.tag

                        // add namespace info to tag
                        var qn = qname(parser.tagName)
                        tag.prefix = qn.prefix
                        tag.local = qn.local
                        tag.uri = tag.ns[qn.prefix] || ''

                        if (tag.prefix && !tag.uri) {
                            strictFail(parser, 'Unbound namespace prefix: ' +
                                JSON.stringify(parser.tagName))
                            tag.uri = qn.prefix
                        }

                        var parent = parser.tags[parser.tags.length - 1] || parser
                        if (tag.ns && parent.ns !== tag.ns) {
                            Object.keys(tag.ns).forEach(function (p) {
                                emitNode(parser, 'onopennamespace', {
                                    prefix: p,
                                    uri: tag.ns[p]
                                })
                            })
                        }

                        // handle deferred onattribute events
                        // Note: do not apply default ns to attributes:
                        //   http://www.w3.org/TR/REC-xml-names/#defaulting
                        for (var i = 0, l = parser.attribList.length; i < l; i++) {
                            var nv = parser.attribList[i]
                            var name = nv[0]
                            var value = nv[1]
                            var qualName = qname(name, true)
                            var prefix = qualName.prefix
                            var local = qualName.local
                            var uri = prefix === '' ? '' : (tag.ns[prefix] || '')
                            var a = {
                                name: name,
                                value: value,
                                prefix: prefix,
                                local: local,
                                uri: uri
                            }

                            // if there's any attributes with an undefined namespace,
                            // then fail on them now.
                            if (prefix && prefix !== 'xmlns' && !uri) {
                                strictFail(parser, 'Unbound namespace prefix: ' +
                                    JSON.stringify(prefix))
                                a.uri = prefix
                            }
                            parser.tag.attributes[name] = a
                            emitNode(parser, 'onattribute', a)
                        }
                        parser.attribList.length = 0
                    }

                    parser.tag.isSelfClosing = !!selfClosing

                    // process the tag
                    parser.sawRoot = true
                    parser.tags.push(parser.tag)
                    emitNode(parser, 'onopentag', parser.tag)
                    if (!selfClosing) {
                        // special case for <script> in non-strict mode.
                        if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
                            parser.state = S.SCRIPT
                        } else {
                            parser.state = S.TEXT
                        }
                        parser.tag = null
                        parser.tagName = ''
                    }
                    parser.attribName = parser.attribValue = ''
                    parser.attribList.length = 0
                }

                function closeTag (parser) {
                    if (!parser.tagName) {
                        strictFail(parser, 'Weird empty close tag.')
                        parser.textNode += '</>'
                        parser.state = S.TEXT
                        return
                    }

                    if (parser.script) {
                        if (parser.tagName !== 'script') {
                            parser.script += '</' + parser.tagName + '>'
                            parser.tagName = ''
                            parser.state = S.SCRIPT
                            return
                        }
                        emitNode(parser, 'onscript', parser.script)
                        parser.script = ''
                    }

                    // first make sure that the closing tag actually exists.
                    // <a><b></c></b></a> will close everything, otherwise.
                    var t = parser.tags.length
                    var tagName = parser.tagName
                    if (!parser.strict) {
                        tagName = tagName[parser.looseCase]()
                    }
                    var closeTo = tagName
                    while (t--) {
                        var close = parser.tags[t]
                        if (close.name !== closeTo) {
                            // fail the first time in strict mode
                            strictFail(parser, 'Unexpected close tag')
                        } else {
                            break
                        }
                    }

                    // didn't find it.  we already failed for strict, so just abort.
                    if (t < 0) {
                        strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)
                        parser.textNode += '</' + parser.tagName + '>'
                        parser.state = S.TEXT
                        return
                    }
                    parser.tagName = tagName
                    var s = parser.tags.length
                    while (s-- > t) {
                        var tag = parser.tag = parser.tags.pop()
                        parser.tagName = parser.tag.name
                        emitNode(parser, 'onclosetag', parser.tagName)

                        var x = {}
                        for (var i in tag.ns) {
                            x[i] = tag.ns[i]
                        }

                        var parent = parser.tags[parser.tags.length - 1] || parser
                        if (parser.opt.xmlns && tag.ns !== parent.ns) {
                            // remove namespace bindings introduced by tag
                            Object.keys(tag.ns).forEach(function (p) {
                                var n = tag.ns[p]
                                emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })
                            })
                        }
                    }
                    if (t === 0) parser.closedRoot = true
                    parser.tagName = parser.attribValue = parser.attribName = ''
                    parser.attribList.length = 0
                    parser.state = S.TEXT
                }

                function parseEntity (parser) {
                    var entity = parser.entity
                    var entityLC = entity.toLowerCase()
                    var num
                    var numStr = ''

                    if (parser.ENTITIES[entity]) {
                        return parser.ENTITIES[entity]
                    }
                    if (parser.ENTITIES[entityLC]) {
                        return parser.ENTITIES[entityLC]
                    }
                    entity = entityLC
                    if (entity.charAt(0) === '#') {
                        if (entity.charAt(1) === 'x') {
                            entity = entity.slice(2)
                            num = parseInt(entity, 16)
                            numStr = num.toString(16)
                        } else {
                            entity = entity.slice(1)
                            num = parseInt(entity, 10)
                            numStr = num.toString(10)
                        }
                    }
                    entity = entity.replace(/^0+/, '')
                    if (numStr.toLowerCase() !== entity) {
                        strictFail(parser, 'Invalid character entity')
                        return '&' + parser.entity + ';'
                    }

                    return String.fromCodePoint(num)
                }

                function beginWhiteSpace (parser, c) {
                    if (c === '<') {
                        parser.state = S.OPEN_WAKA
                        parser.startTagPosition = parser.position
                    } else if (not(whitespace, c)) {
                        // have to process this as a text node.
                        // weird, but happens.
                        strictFail(parser, 'Non-whitespace before first tag.')
                        parser.textNode = c
                        parser.state = S.TEXT
                    }
                }

                function charAt (chunk, i) {
                    var result = ''
                    if (i < chunk.length) {
                        result = chunk.charAt(i)
                    }
                    return result
                }

                function write (chunk) {
                    var parser = this
                    if (this.error) {
                        throw this.error
                    }
                    if (parser.closed) {
                        return error(parser,
                            'Cannot write after close. Assign an onready handler.')
                    }
                    if (chunk === null) {
                        return end(parser)
                    }
                    if (typeof chunk === 'object') {
                        chunk = chunk.toString()
                    }
                    var i = 0
                    var c = ''
                    while (true) {
                        c = charAt(chunk, i++)
                        parser.c = c
                        if (!c) {
                            break
                        }
                        if (parser.trackPosition) {
                            parser.position++
                            if (c === '\n') {
                                parser.line++
                                parser.column = 0
                            } else {
                                parser.column++
                            }
                        }
                        switch (parser.state) {
                            case S.BEGIN:
                                parser.state = S.BEGIN_WHITESPACE
                                if (c === '\uFEFF') {
                                    continue
                                }
                                beginWhiteSpace(parser, c)
                                continue

                            case S.BEGIN_WHITESPACE:
                                beginWhiteSpace(parser, c)
                                continue

                            case S.TEXT:
                                if (parser.sawRoot && !parser.closedRoot) {
                                    var starti = i - 1
                                    while (c && c !== '<' && c !== '&') {
                                        c = charAt(chunk, i++)
                                        if (c && parser.trackPosition) {
                                            parser.position++
                                            if (c === '\n') {
                                                parser.line++
                                                parser.column = 0
                                            } else {
                                                parser.column++
                                            }
                                        }
                                    }
                                    parser.textNode += chunk.substring(starti, i - 1)
                                }
                                if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
                                    parser.state = S.OPEN_WAKA
                                    parser.startTagPosition = parser.position
                                } else {
                                    if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot)) {
                                        strictFail(parser, 'Text data outside of root node.')
                                    }
                                    if (c === '&') {
                                        parser.state = S.TEXT_ENTITY
                                    } else {
                                        parser.textNode += c
                                    }
                                }
                                continue

                            case S.SCRIPT:
                                // only non-strict
                                if (c === '<') {
                                    parser.state = S.SCRIPT_ENDING
                                } else {
                                    parser.script += c
                                }
                                continue

                            case S.SCRIPT_ENDING:
                                if (c === '/') {
                                    parser.state = S.CLOSE_TAG
                                } else {
                                    parser.script += '<' + c
                                    parser.state = S.SCRIPT
                                }
                                continue

                            case S.OPEN_WAKA:
                                // either a /, ?, !, or text is coming next.
                                if (c === '!') {
                                    parser.state = S.SGML_DECL
                                    parser.sgmlDecl = ''
                                } else if (is(whitespace, c)) {
                                    // wait for it...
                                } else if (is(nameStart, c)) {
                                    parser.state = S.OPEN_TAG
                                    parser.tagName = c
                                } else if (c === '/') {
                                    parser.state = S.CLOSE_TAG
                                    parser.tagName = ''
                                } else if (c === '?') {
                                    parser.state = S.PROC_INST
                                    parser.procInstName = parser.procInstBody = ''
                                } else {
                                    strictFail(parser, 'Unencoded <')
                                    // if there was some whitespace, then add that in.
                                    if (parser.startTagPosition + 1 < parser.position) {
                                        var pad = parser.position - parser.startTagPosition
                                        c = new Array(pad).join(' ') + c
                                    }
                                    parser.textNode += '<' + c
                                    parser.state = S.TEXT
                                }
                                continue

                            case S.SGML_DECL:
                                if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
                                    emitNode(parser, 'onopencdata')
                                    parser.state = S.CDATA
                                    parser.sgmlDecl = ''
                                    parser.cdata = ''
                                } else if (parser.sgmlDecl + c === '--') {
                                    parser.state = S.COMMENT
                                    parser.comment = ''
                                    parser.sgmlDecl = ''
                                } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
                                    parser.state = S.DOCTYPE
                                    if (parser.doctype || parser.sawRoot) {
                                        strictFail(parser,
                                            'Inappropriately located doctype declaration')
                                    }
                                    parser.doctype = ''
                                    parser.sgmlDecl = ''
                                } else if (c === '>') {
                                    emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)
                                    parser.sgmlDecl = ''
                                    parser.state = S.TEXT
                                } else if (is(quote, c)) {
                                    parser.state = S.SGML_DECL_QUOTED
                                    parser.sgmlDecl += c
                                } else {
                                    parser.sgmlDecl += c
                                }
                                continue

                            case S.SGML_DECL_QUOTED:
                                if (c === parser.q) {
                                    parser.state = S.SGML_DECL
                                    parser.q = ''
                                }
                                parser.sgmlDecl += c
                                continue

                            case S.DOCTYPE:
                                if (c === '>') {
                                    parser.state = S.TEXT
                                    emitNode(parser, 'ondoctype', parser.doctype)
                                    parser.doctype = true // just remember that we saw it.
                                } else {
                                    parser.doctype += c
                                    if (c === '[') {
                                        parser.state = S.DOCTYPE_DTD
                                    } else if (is(quote, c)) {
                                        parser.state = S.DOCTYPE_QUOTED
                                        parser.q = c
                                    }
                                }
                                continue

                            case S.DOCTYPE_QUOTED:
                                parser.doctype += c
                                if (c === parser.q) {
                                    parser.q = ''
                                    parser.state = S.DOCTYPE
                                }
                                continue

                            case S.DOCTYPE_DTD:
                                parser.doctype += c
                                if (c === ']') {
                                    parser.state = S.DOCTYPE
                                } else if (is(quote, c)) {
                                    parser.state = S.DOCTYPE_DTD_QUOTED
                                    parser.q = c
                                }
                                continue

                            case S.DOCTYPE_DTD_QUOTED:
                                parser.doctype += c
                                if (c === parser.q) {
                                    parser.state = S.DOCTYPE_DTD
                                    parser.q = ''
                                }
                                continue

                            case S.COMMENT:
                                if (c === '-') {
                                    parser.state = S.COMMENT_ENDING
                                } else {
                                    parser.comment += c
                                }
                                continue

                            case S.COMMENT_ENDING:
                                if (c === '-') {
                                    parser.state = S.COMMENT_ENDED
                                    parser.comment = textopts(parser.opt, parser.comment)
                                    if (parser.comment) {
                                        emitNode(parser, 'oncomment', parser.comment)
                                    }
                                    parser.comment = ''
                                } else {
                                    parser.comment += '-' + c
                                    parser.state = S.COMMENT
                                }
                                continue

                            case S.COMMENT_ENDED:
                                if (c !== '>') {
                                    strictFail(parser, 'Malformed comment')
                                    // allow <!-- blah -- bloo --> in non-strict mode,
                                    // which is a comment of " blah -- bloo "
                                    parser.comment += '--' + c
                                    parser.state = S.COMMENT
                                } else {
                                    parser.state = S.TEXT
                                }
                                continue

                            case S.CDATA:
                                if (c === ']') {
                                    parser.state = S.CDATA_ENDING
                                } else {
                                    parser.cdata += c
                                }
                                continue

                            case S.CDATA_ENDING:
                                if (c === ']') {
                                    parser.state = S.CDATA_ENDING_2
                                } else {
                                    parser.cdata += ']' + c
                                    parser.state = S.CDATA
                                }
                                continue

                            case S.CDATA_ENDING_2:
                                if (c === '>') {
                                    if (parser.cdata) {
                                        emitNode(parser, 'oncdata', parser.cdata)
                                    }
                                    emitNode(parser, 'onclosecdata')
                                    parser.cdata = ''
                                    parser.state = S.TEXT
                                } else if (c === ']') {
                                    parser.cdata += ']'
                                } else {
                                    parser.cdata += ']]' + c
                                    parser.state = S.CDATA
                                }
                                continue

                            case S.PROC_INST:
                                if (c === '?') {
                                    parser.state = S.PROC_INST_ENDING
                                } else if (is(whitespace, c)) {
                                    parser.state = S.PROC_INST_BODY
                                } else {
                                    parser.procInstName += c
                                }
                                continue

                            case S.PROC_INST_BODY:
                                if (!parser.procInstBody && is(whitespace, c)) {
                                    continue
                                } else if (c === '?') {
                                    parser.state = S.PROC_INST_ENDING
                                } else {
                                    parser.procInstBody += c
                                }
                                continue

                            case S.PROC_INST_ENDING:
                                if (c === '>') {
                                    emitNode(parser, 'onprocessinginstruction', {
                                        name: parser.procInstName,
                                        body: parser.procInstBody
                                    })
                                    parser.procInstName = parser.procInstBody = ''
                                    parser.state = S.TEXT
                                } else {
                                    parser.procInstBody += '?' + c
                                    parser.state = S.PROC_INST_BODY
                                }
                                continue

                            case S.OPEN_TAG:
                                if (is(nameBody, c)) {
                                    parser.tagName += c
                                } else {
                                    newTag(parser)
                                    if (c === '>') {
                                        openTag(parser)
                                    } else if (c === '/') {
                                        parser.state = S.OPEN_TAG_SLASH
                                    } else {
                                        if (not(whitespace, c)) {
                                            strictFail(parser, 'Invalid character in tag name')
                                        }
                                        parser.state = S.ATTRIB
                                    }
                                }
                                continue

                            case S.OPEN_TAG_SLASH:
                                if (c === '>') {
                                    openTag(parser, true)
                                    closeTag(parser)
                                } else {
                                    strictFail(parser, 'Forward-slash in opening tag not followed by >')
                                    parser.state = S.ATTRIB
                                }
                                continue

                            case S.ATTRIB:
                                // haven't read the attribute name yet.
                                if (is(whitespace, c)) {
                                    continue
                                } else if (c === '>') {
                                    openTag(parser)
                                } else if (c === '/') {
                                    parser.state = S.OPEN_TAG_SLASH
                                } else if (is(nameStart, c)) {
                                    parser.attribName = c
                                    parser.attribValue = ''
                                    parser.state = S.ATTRIB_NAME
                                } else {
                                    strictFail(parser, 'Invalid attribute name')
                                }
                                continue

                            case S.ATTRIB_NAME:
                                if (c === '=') {
                                    parser.state = S.ATTRIB_VALUE
                                } else if (c === '>') {
                                    strictFail(parser, 'Attribute without value')
                                    parser.attribValue = parser.attribName
                                    attrib(parser)
                                    openTag(parser)
                                } else if (is(whitespace, c)) {
                                    parser.state = S.ATTRIB_NAME_SAW_WHITE
                                } else if (is(nameBody, c)) {
                                    parser.attribName += c
                                } else {
                                    strictFail(parser, 'Invalid attribute name')
                                }
                                continue

                            case S.ATTRIB_NAME_SAW_WHITE:
                                if (c === '=') {
                                    parser.state = S.ATTRIB_VALUE
                                } else if (is(whitespace, c)) {
                                    continue
                                } else {
                                    strictFail(parser, 'Attribute without value')
                                    parser.tag.attributes[parser.attribName] = ''
                                    parser.attribValue = ''
                                    emitNode(parser, 'onattribute', {
                                        name: parser.attribName,
                                        value: ''
                                    })
                                    parser.attribName = ''
                                    if (c === '>') {
                                        openTag(parser)
                                    } else if (is(nameStart, c)) {
                                        parser.attribName = c
                                        parser.state = S.ATTRIB_NAME
                                    } else {
                                        strictFail(parser, 'Invalid attribute name')
                                        parser.state = S.ATTRIB
                                    }
                                }
                                continue

                            case S.ATTRIB_VALUE:
                                if (is(whitespace, c)) {
                                    continue
                                } else if (is(quote, c)) {
                                    parser.q = c
                                    parser.state = S.ATTRIB_VALUE_QUOTED
                                } else {
                                    strictFail(parser, 'Unquoted attribute value')
                                    parser.state = S.ATTRIB_VALUE_UNQUOTED
                                    parser.attribValue = c
                                }
                                continue

                            case S.ATTRIB_VALUE_QUOTED:
                                if (c !== parser.q) {
                                    if (c === '&') {
                                        parser.state = S.ATTRIB_VALUE_ENTITY_Q
                                    } else {
                                        parser.attribValue += c
                                    }
                                    continue
                                }
                                attrib(parser)
                                parser.q = ''
                                parser.state = S.ATTRIB_VALUE_CLOSED
                                continue

                            case S.ATTRIB_VALUE_CLOSED:
                                if (is(whitespace, c)) {
                                    parser.state = S.ATTRIB
                                } else if (c === '>') {
                                    openTag(parser)
                                } else if (c === '/') {
                                    parser.state = S.OPEN_TAG_SLASH
                                } else if (is(nameStart, c)) {
                                    strictFail(parser, 'No whitespace between attributes')
                                    parser.attribName = c
                                    parser.attribValue = ''
                                    parser.state = S.ATTRIB_NAME
                                } else {
                                    strictFail(parser, 'Invalid attribute name')
                                }
                                continue

                            case S.ATTRIB_VALUE_UNQUOTED:
                                if (not(attribEnd, c)) {
                                    if (c === '&') {
                                        parser.state = S.ATTRIB_VALUE_ENTITY_U
                                    } else {
                                        parser.attribValue += c
                                    }
                                    continue
                                }
                                attrib(parser)
                                if (c === '>') {
                                    openTag(parser)
                                } else {
                                    parser.state = S.ATTRIB
                                }
                                continue

                            case S.CLOSE_TAG:
                                if (!parser.tagName) {
                                    if (is(whitespace, c)) {
                                        continue
                                    } else if (not(nameStart, c)) {
                                        if (parser.script) {
                                            parser.script += '</' + c
                                            parser.state = S.SCRIPT
                                        } else {
                                            strictFail(parser, 'Invalid tagname in closing tag.')
                                        }
                                    } else {
                                        parser.tagName = c
                                    }
                                } else if (c === '>') {
                                    closeTag(parser)
                                } else if (is(nameBody, c)) {
                                    parser.tagName += c
                                } else if (parser.script) {
                                    parser.script += '</' + parser.tagName
                                    parser.tagName = ''
                                    parser.state = S.SCRIPT
                                } else {
                                    if (not(whitespace, c)) {
                                        strictFail(parser, 'Invalid tagname in closing tag')
                                    }
                                    parser.state = S.CLOSE_TAG_SAW_WHITE
                                }
                                continue

                            case S.CLOSE_TAG_SAW_WHITE:
                                if (is(whitespace, c)) {
                                    continue
                                }
                                if (c === '>') {
                                    closeTag(parser)
                                } else {
                                    strictFail(parser, 'Invalid characters in closing tag')
                                }
                                continue

                            case S.TEXT_ENTITY:
                            case S.ATTRIB_VALUE_ENTITY_Q:
                            case S.ATTRIB_VALUE_ENTITY_U:
                                var returnState
                                var buffer
                                switch (parser.state) {
                                    case S.TEXT_ENTITY:
                                        returnState = S.TEXT
                                        buffer = 'textNode'
                                        break

                                    case S.ATTRIB_VALUE_ENTITY_Q:
                                        returnState = S.ATTRIB_VALUE_QUOTED
                                        buffer = 'attribValue'
                                        break

                                    case S.ATTRIB_VALUE_ENTITY_U:
                                        returnState = S.ATTRIB_VALUE_UNQUOTED
                                        buffer = 'attribValue'
                                        break
                                }

                                if (c === ';') {
                                    parser[buffer] += parseEntity(parser)
                                    parser.entity = ''
                                    parser.state = returnState
                                } else if (is(parser.entity.length ? entityBody : entityStart, c)) {
                                    parser.entity += c
                                } else {
                                    strictFail(parser, 'Invalid character in entity name')
                                    parser[buffer] += '&' + parser.entity + c
                                    parser.entity = ''
                                    parser.state = returnState
                                }

                                continue

                            default:
                                throw new Error(parser, 'Unknown state: ' + parser.state)
                        }
                    } // while

                    if (parser.position >= parser.bufferCheckPosition) {
                        checkBufferLength(parser)
                    }
                    return parser
                }

                /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
                if (!String.fromCodePoint) {
                    (function () {
                        var stringFromCharCode = String.fromCharCode
                        var floor = Math.floor
                        var fromCodePoint = function () {
                            var MAX_SIZE = 0x4000
                            var codeUnits = []
                            var highSurrogate
                            var lowSurrogate
                            var index = -1
                            var length = arguments.length
                            if (!length) {
                                return ''
                            }
                            var result = ''
                            while (++index < length) {
                                var codePoint = Number(arguments[index])
                                if (
                                    !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
                                    codePoint < 0 || // not a valid Unicode code point
                                    codePoint > 0x10FFFF || // not a valid Unicode code point
                                    floor(codePoint) !== codePoint // not an integer
                                ) {
                                    throw RangeError('Invalid code point: ' + codePoint)
                                }
                                if (codePoint <= 0xFFFF) { // BMP code point
                                    codeUnits.push(codePoint)
                                } else { // Astral code point; split in surrogate halves
                                    // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
                                    codePoint -= 0x10000
                                    highSurrogate = (codePoint >> 10) + 0xD800
                                    lowSurrogate = (codePoint % 0x400) + 0xDC00
                                    codeUnits.push(highSurrogate, lowSurrogate)
                                }
                                if (index + 1 === length || codeUnits.length > MAX_SIZE) {
                                    result += stringFromCharCode.apply(null, codeUnits)
                                    codeUnits.length = 0
                                }
                            }
                            return result
                        }
                        if (Object.defineProperty) {
                            Object.defineProperty(String, 'fromCodePoint', {
                                value: fromCodePoint,
                                configurable: true,
                                writable: true
                            })
                        } else {
                            String.fromCodePoint = fromCodePoint
                        }
                    }())
                }
            })(typeof exports === 'undefined' ? this.sax = {} : exports)

        }).call(this)}).call(this,require("buffer").Buffer)
    },{"buffer":77,"stream":118,"string_decoder":119}],118:[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":81,"inherits":84,"readable-stream/duplex.js":103,"readable-stream/passthrough.js":112,"readable-stream/readable.js":113,"readable-stream/transform.js":114,"readable-stream/writable.js":115}],119:[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":77}],120:[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.

        'use strict';

        /*<replacement>*/

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

        var isEncoding = Buffer.isEncoding || function (encoding) {
            encoding = '' + 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 _normalizeEncoding(enc) {
            if (!enc) return 'utf8';
            var retried;
            while (true) {
                switch (enc) {
                    case 'utf8':
                    case 'utf-8':
                        return 'utf8';
                    case 'ucs2':
                    case 'ucs-2':
                    case 'utf16le':
                    case 'utf-16le':
                        return 'utf16le';
                    case 'latin1':
                    case 'binary':
                        return 'latin1';
                    case 'base64':
                    case 'ascii':
                    case 'hex':
                        return enc;
                    default:
                        if (retried) return; // undefined
                        enc = ('' + enc).toLowerCase();
                        retried = true;
                }
            }
        };

// Do not cache `Buffer.isEncoding` when checking encoding names as some
// modules monkey-patch it to support additional encodings
        function normalizeEncoding(enc) {
            var nenc = _normalizeEncoding(enc);
            if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
            return nenc || enc;
        }

// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters.
        exports.StringDecoder = StringDecoder;
        function StringDecoder(encoding) {
            this.encoding = normalizeEncoding(encoding);
            var nb;
            switch (this.encoding) {
                case 'utf16le':
                    this.text = utf16Text;
                    this.end = utf16End;
                    nb = 4;
                    break;
                case 'utf8':
                    this.fillLast = utf8FillLast;
                    nb = 4;
                    break;
                case 'base64':
                    this.text = base64Text;
                    this.end = base64End;
                    nb = 3;
                    break;
                default:
                    this.write = simpleWrite;
                    this.end = simpleEnd;
                    return;
            }
            this.lastNeed = 0;
            this.lastTotal = 0;
            this.lastChar = Buffer.allocUnsafe(nb);
        }

        StringDecoder.prototype.write = function (buf) {
            if (buf.length === 0) return '';
            var r;
            var i;
            if (this.lastNeed) {
                r = this.fillLast(buf);
                if (r === undefined) return '';
                i = this.lastNeed;
                this.lastNeed = 0;
            } else {
                i = 0;
            }
            if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
            return r || '';
        };

        StringDecoder.prototype.end = utf8End;

// Returns only complete characters in a Buffer
        StringDecoder.prototype.text = utf8Text;

// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
        StringDecoder.prototype.fillLast = function (buf) {
            if (this.lastNeed <= buf.length) {
                buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
                return this.lastChar.toString(this.encoding, 0, this.lastTotal);
            }
            buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
            this.lastNeed -= buf.length;
        };

// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
// continuation byte. If an invalid byte is detected, -2 is returned.
        function utf8CheckByte(byte) {
            if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
            return byte >> 6 === 0x02 ? -1 : -2;
        }

// Checks at most 3 bytes at the end of a Buffer in order to detect an
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
// needed to complete the UTF-8 character (if applicable) are returned.
        function utf8CheckIncomplete(self, buf, i) {
            var j = buf.length - 1;
            if (j < i) return 0;
            var nb = utf8CheckByte(buf[j]);
            if (nb >= 0) {
                if (nb > 0) self.lastNeed = nb - 1;
                return nb;
            }
            if (--j < i || nb === -2) return 0;
            nb = utf8CheckByte(buf[j]);
            if (nb >= 0) {
                if (nb > 0) self.lastNeed = nb - 2;
                return nb;
            }
            if (--j < i || nb === -2) return 0;
            nb = utf8CheckByte(buf[j]);
            if (nb >= 0) {
                if (nb > 0) {
                    if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
                }
                return nb;
            }
            return 0;
        }

// Validates as many continuation bytes for a multi-byte UTF-8 character as
// needed or are available. If we see a non-continuation byte where we expect
// one, we "replace" the validated continuation bytes we've seen so far with
// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
// behavior. The continuation byte check is included three times in the case
// where all of the continuation bytes for a character exist in the same buffer.
// It is also done this way as a slight performance increase instead of using a
// loop.
        function utf8CheckExtraBytes(self, buf, p) {
            if ((buf[0] & 0xC0) !== 0x80) {
                self.lastNeed = 0;
                return '\ufffd';
            }
            if (self.lastNeed > 1 && buf.length > 1) {
                if ((buf[1] & 0xC0) !== 0x80) {
                    self.lastNeed = 1;
                    return '\ufffd';
                }
                if (self.lastNeed > 2 && buf.length > 2) {
                    if ((buf[2] & 0xC0) !== 0x80) {
                        self.lastNeed = 2;
                        return '\ufffd';
                    }
                }
            }
        }

// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
        function utf8FillLast(buf) {
            var p = this.lastTotal - this.lastNeed;
            var r = utf8CheckExtraBytes(this, buf, p);
            if (r !== undefined) return r;
            if (this.lastNeed <= buf.length) {
                buf.copy(this.lastChar, p, 0, this.lastNeed);
                return this.lastChar.toString(this.encoding, 0, this.lastTotal);
            }
            buf.copy(this.lastChar, p, 0, buf.length);
            this.lastNeed -= buf.length;
        }

// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
// partial character, the character's bytes are buffered until the required
// number of bytes are available.
        function utf8Text(buf, i) {
            var total = utf8CheckIncomplete(this, buf, i);
            if (!this.lastNeed) return buf.toString('utf8', i);
            this.lastTotal = total;
            var end = buf.length - (total - this.lastNeed);
            buf.copy(this.lastChar, 0, end);
            return buf.toString('utf8', i, end);
        }

// For UTF-8, a replacement character is added when ending on a partial
// character.
        function utf8End(buf) {
            var r = buf && buf.length ? this.write(buf) : '';
            if (this.lastNeed) return r + '\ufffd';
            return r;
        }

// UTF-16LE typically needs two bytes per character, but even if we have an even
// number of bytes available, we need to check if we end on a leading/high
// surrogate. In that case, we need to wait for the next two bytes in order to
// decode the last character properly.
        function utf16Text(buf, i) {
            if ((buf.length - i) % 2 === 0) {
                var r = buf.toString('utf16le', i);
                if (r) {
                    var c = r.charCodeAt(r.length - 1);
                    if (c >= 0xD800 && c <= 0xDBFF) {
                        this.lastNeed = 2;
                        this.lastTotal = 4;
                        this.lastChar[0] = buf[buf.length - 2];
                        this.lastChar[1] = buf[buf.length - 1];
                        return r.slice(0, -1);
                    }
                }
                return r;
            }
            this.lastNeed = 1;
            this.lastTotal = 2;
            this.lastChar[0] = buf[buf.length - 1];
            return buf.toString('utf16le', i, buf.length - 1);
        }

// For UTF-16LE we do not explicitly append special replacement characters if we
// end on a partial character, we simply let v8 handle that.
        function utf16End(buf) {
            var r = buf && buf.length ? this.write(buf) : '';
            if (this.lastNeed) {
                var end = this.lastTotal - this.lastNeed;
                return r + this.lastChar.toString('utf16le', 0, end);
            }
            return r;
        }

        function base64Text(buf, i) {
            var n = (buf.length - i) % 3;
            if (n === 0) return buf.toString('base64', i);
            this.lastNeed = 3 - n;
            this.lastTotal = 3;
            if (n === 1) {
                this.lastChar[0] = buf[buf.length - 1];
            } else {
                this.lastChar[0] = buf[buf.length - 2];
                this.lastChar[1] = buf[buf.length - 1];
            }
            return buf.toString('base64', i, buf.length - n);
        }

        function base64End(buf) {
            var r = buf && buf.length ? this.write(buf) : '';
            if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
            return r;
        }

// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
        function simpleWrite(buf) {
            return buf.toString(this.encoding);
        }

        function simpleEnd(buf) {
            return buf && buf.length ? this.write(buf) : '';
        }
    },{"safe-buffer":116}],121:[function(require,module,exports){
        (function (setImmediate,clearImmediate){(function (){
            var nextTick = require('process/browser.js').nextTick;
            var apply = Function.prototype.apply;
            var slice = Array.prototype.slice;
            var immediateIds = {};
            var nextImmediateId = 0;

// DOM APIs, for completeness

            exports.setTimeout = function() {
                return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
            };
            exports.setInterval = function() {
                return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
            };
            exports.clearTimeout =
                exports.clearInterval = function(timeout) { timeout.close(); };

            function Timeout(id, clearFn) {
                this._id = id;
                this._clearFn = clearFn;
            }
            Timeout.prototype.unref = Timeout.prototype.ref = function() {};
            Timeout.prototype.close = function() {
                this._clearFn.call(window, this._id);
            };

// Does not start the time, just sets up the members needed.
            exports.enroll = function(item, msecs) {
                clearTimeout(item._idleTimeoutId);
                item._idleTimeout = msecs;
            };

            exports.unenroll = function(item) {
                clearTimeout(item._idleTimeoutId);
                item._idleTimeout = -1;
            };

            exports._unrefActive = exports.active = function(item) {
                clearTimeout(item._idleTimeoutId);

                var msecs = item._idleTimeout;
                if (msecs >= 0) {
                    item._idleTimeoutId = setTimeout(function onTimeout() {
                        if (item._onTimeout)
                            item._onTimeout();
                    }, msecs);
                }
            };

// That's not how node.js implements it but the exposed api is the same.
            exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
                var id = nextImmediateId++;
                var args = arguments.length < 2 ? false : slice.call(arguments, 1);

                immediateIds[id] = true;

                nextTick(function onNextTick() {
                    if (immediateIds[id]) {
                        // fn.call() is faster so we optimize for the common use-case
                        // @see http://jsperf.com/call-apply-segu
                        if (args) {
                            fn.apply(null, args);
                        } else {
                            fn.call(null);
                        }
                        // Prevent ids from leaking
                        exports.clearImmediate(id);
                    }
                });

                return id;
            };

            exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
                delete immediateIds[id];
            };
        }).call(this)}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
    },{"process/browser.js":102,"timers":121}],122:[function(require,module,exports){
        (function (global){(function (){
            (function (global, factory) {
                typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
                    typeof define === 'function' && define.amd ? define('underscore', factory) :
                        (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {
                            var current = global._;
                            var exports = global._ = factory();
                            exports.noConflict = function () { global._ = current; return exports; };
                        }()));
            }(this, (function () {
                //     Underscore.js 1.13.6
                //     https://underscorejs.org
                //     (c) 2009-2022 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors
                //     Underscore may be freely distributed under the MIT license.

                // Current version.
                var VERSION = '1.13.6';

                // Establish the root object, `window` (`self`) in the browser, `global`
                // on the server, or `this` in some virtual machines. We use `self`
                // instead of `window` for `WebWorker` support.
                var root = (typeof self == 'object' && self.self === self && self) ||
                    (typeof global == 'object' && global.global === global && global) ||
                    Function('return this')() ||
                    {};

                // Save bytes in the minified (but not gzipped) version:
                var ArrayProto = Array.prototype, ObjProto = Object.prototype;
                var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;

                // Create quick reference variables for speed access to core prototypes.
                var push = ArrayProto.push,
                    slice = ArrayProto.slice,
                    toString = ObjProto.toString,
                    hasOwnProperty = ObjProto.hasOwnProperty;

                // Modern feature detection.
                var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',
                    supportsDataView = typeof DataView !== 'undefined';

                // All **ECMAScript 5+** native function implementations that we hope to use
                // are declared here.
                var nativeIsArray = Array.isArray,
                    nativeKeys = Object.keys,
                    nativeCreate = Object.create,
                    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;

                // Create references to these builtin functions because we override them.
                var _isNaN = isNaN,
                    _isFinite = isFinite;

                // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
                var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
                var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
                    'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

                // The largest integer that can be represented exactly.
                var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

                // Some functions take a variable number of arguments, or a few expected
                // arguments at the beginning and then a variable number of values to operate
                // on. This helper accumulates all remaining arguments past the function’s
                // argument length (or an explicit `startIndex`), into an array that becomes
                // the last argument. Similar to ES6’s "rest parameter".
                function restArguments(func, startIndex) {
                    startIndex = startIndex == null ? func.length - 1 : +startIndex;
                    return function() {
                        var length = Math.max(arguments.length - startIndex, 0),
                            rest = Array(length),
                            index = 0;
                        for (; index < length; index++) {
                            rest[index] = arguments[index + startIndex];
                        }
                        switch (startIndex) {
                            case 0: return func.call(this, rest);
                            case 1: return func.call(this, arguments[0], rest);
                            case 2: return func.call(this, arguments[0], arguments[1], rest);
                        }
                        var args = Array(startIndex + 1);
                        for (index = 0; index < startIndex; index++) {
                            args[index] = arguments[index];
                        }
                        args[startIndex] = rest;
                        return func.apply(this, args);
                    };
                }

                // Is a given variable an object?
                function isObject(obj) {
                    var type = typeof obj;
                    return type === 'function' || (type === 'object' && !!obj);
                }

                // Is a given value equal to null?
                function isNull(obj) {
                    return obj === null;
                }

                // Is a given variable undefined?
                function isUndefined(obj) {
                    return obj === void 0;
                }

                // Is a given value a boolean?
                function isBoolean(obj) {
                    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
                }

                // Is a given value a DOM element?
                function isElement(obj) {
                    return !!(obj && obj.nodeType === 1);
                }

                // Internal function for creating a `toString`-based type tester.
                function tagTester(name) {
                    var tag = '[object ' + name + ']';
                    return function(obj) {
                        return toString.call(obj) === tag;
                    };
                }

                var isString = tagTester('String');

                var isNumber = tagTester('Number');

                var isDate = tagTester('Date');

                var isRegExp = tagTester('RegExp');

                var isError = tagTester('Error');

                var isSymbol = tagTester('Symbol');

                var isArrayBuffer = tagTester('ArrayBuffer');

                var isFunction = tagTester('Function');

                // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old
                // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).
                var nodelist = root.document && root.document.childNodes;
                if ( true && typeof Int8Array != 'object' && typeof nodelist != 'function') {
                    isFunction = function(obj) {
                        return typeof obj == 'function' || false;
                    };
                }

                var isFunction$1 = isFunction;

                var hasObjectTag = tagTester('Object');

                // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.
                // In IE 11, the most common among them, this problem also applies to
                // `Map`, `WeakMap` and `Set`.
                var hasStringTagBug = (
                        supportsDataView && hasObjectTag(new DataView(new ArrayBuffer(8)))
                    ),
                    isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));

                var isDataView = tagTester('DataView');

                // In IE 10 - Edge 13, we need a different heuristic
                // to determine whether an object is a `DataView`.
                function ie10IsDataView(obj) {
                    return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer);
                }

                var isDataView$1 = (hasStringTagBug ? ie10IsDataView : isDataView);

                // Is a given value an array?
                // Delegates to ECMA5's native `Array.isArray`.
                var isArray = nativeIsArray || tagTester('Array');

                // Internal function to check whether `key` is an own property name of `obj`.
                function has$1(obj, key) {
                    return obj != null && hasOwnProperty.call(obj, key);
                }

                var isArguments = tagTester('Arguments');

                // Define a fallback version of the method in browsers (ahem, IE < 9), where
                // there isn't any inspectable "Arguments" type.
                (function() {
                    if (!isArguments(arguments)) {
                        isArguments = function(obj) {
                            return has$1(obj, 'callee');
                        };
                    }
                }());

                var isArguments$1 = isArguments;

                // Is a given object a finite number?
                function isFinite$1(obj) {
                    return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));
                }

                // Is the given value `NaN`?
                function isNaN$1(obj) {
                    return isNumber(obj) && _isNaN(obj);
                }

                // Predicate-generating function. Often useful outside of Underscore.
                function constant(value) {
                    return function() {
                        return value;
                    };
                }

                // Common internal logic for `isArrayLike` and `isBufferLike`.
                function createSizePropertyCheck(getSizeProperty) {
                    return function(collection) {
                        var sizeProperty = getSizeProperty(collection);
                        return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;
                    }
                }

                // Internal helper to generate a function to obtain property `key` from `obj`.
                function shallowProperty(key) {
                    return function(obj) {
                        return obj == null ? void 0 : obj[key];
                    };
                }

                // Internal helper to obtain the `byteLength` property of an object.
                var getByteLength = shallowProperty('byteLength');

                // Internal helper to determine whether we should spend extensive checks against
                // `ArrayBuffer` et al.
                var isBufferLike = createSizePropertyCheck(getByteLength);

                // Is a given value a typed array?
                var typedArrayPattern = /\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;
                function isTypedArray(obj) {
                    // `ArrayBuffer.isView` is the most future-proof, so use it when available.
                    // Otherwise, fall back on the above regular expression.
                    return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :
                        isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));
                }

                var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);

                // Internal helper to obtain the `length` property of an object.
                var getLength = shallowProperty('length');

                // Internal helper to create a simple lookup structure.
                // `collectNonEnumProps` used to depend on `_.contains`, but this led to
                // circular imports. `emulatedSet` is a one-off solution that only works for
                // arrays of strings.
                function emulatedSet(keys) {
                    var hash = {};
                    for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;
                    return {
                        contains: function(key) { return hash[key] === true; },
                        push: function(key) {
                            hash[key] = true;
                            return keys.push(key);
                        }
                    };
                }

                // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't
                // be iterated by `for key in ...` and thus missed. Extends `keys` in place if
                // needed.
                function collectNonEnumProps(obj, keys) {
                    keys = emulatedSet(keys);
                    var nonEnumIdx = nonEnumerableProps.length;
                    var constructor = obj.constructor;
                    var proto = (isFunction$1(constructor) && constructor.prototype) || ObjProto;

                    // Constructor is a special case.
                    var prop = 'constructor';
                    if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);

                    while (nonEnumIdx--) {
                        prop = nonEnumerableProps[nonEnumIdx];
                        if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {
                            keys.push(prop);
                        }
                    }
                }

                // Retrieve the names of an object's own properties.
                // Delegates to **ECMAScript 5**'s native `Object.keys`.
                function keys(obj) {
                    if (!isObject(obj)) return [];
                    if (nativeKeys) return nativeKeys(obj);
                    var keys = [];
                    for (var key in obj) if (has$1(obj, key)) keys.push(key);
                    // Ahem, IE < 9.
                    if (hasEnumBug) collectNonEnumProps(obj, keys);
                    return keys;
                }

                // Is a given array, string, or object empty?
                // An "empty" object has no enumerable own-properties.
                function isEmpty(obj) {
                    if (obj == null) return true;
                    // Skip the more expensive `toString`-based type checks if `obj` has no
                    // `.length`.
                    var length = getLength(obj);
                    if (typeof length == 'number' && (
                        isArray(obj) || isString(obj) || isArguments$1(obj)
                    )) return length === 0;
                    return getLength(keys(obj)) === 0;
                }

                // Returns whether an object has a given set of `key:value` pairs.
                function isMatch(object, attrs) {
                    var _keys = keys(attrs), length = _keys.length;
                    if (object == null) return !length;
                    var obj = Object(object);
                    for (var i = 0; i < length; i++) {
                        var key = _keys[i];
                        if (attrs[key] !== obj[key] || !(key in obj)) return false;
                    }
                    return true;
                }

                // If Underscore is called as a function, it returns a wrapped object that can
                // be used OO-style. This wrapper holds altered versions of all functions added
                // through `_.mixin`. Wrapped objects may be chained.
                function _$1(obj) {
                    if (obj instanceof _$1) return obj;
                    if (!(this instanceof _$1)) return new _$1(obj);
                    this._wrapped = obj;
                }

                _$1.VERSION = VERSION;

                // Extracts the result from a wrapped and chained object.
                _$1.prototype.value = function() {
                    return this._wrapped;
                };

                // Provide unwrapping proxies for some methods used in engine operations
                // such as arithmetic and JSON stringification.
                _$1.prototype.valueOf = _$1.prototype.toJSON = _$1.prototype.value;

                _$1.prototype.toString = function() {
                    return String(this._wrapped);
                };

                // Internal function to wrap or shallow-copy an ArrayBuffer,
                // typed array or DataView to a new view, reusing the buffer.
                function toBufferView(bufferSource) {
                    return new Uint8Array(
                        bufferSource.buffer || bufferSource,
                        bufferSource.byteOffset || 0,
                        getByteLength(bufferSource)
                    );
                }

                // We use this string twice, so give it a name for minification.
                var tagDataView = '[object DataView]';

                // Internal recursive comparison function for `_.isEqual`.
                function eq(a, b, aStack, bStack) {
                    // Identical objects are equal. `0 === -0`, but they aren't identical.
                    // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).
                    if (a === b) return a !== 0 || 1 / a === 1 / b;
                    // `null` or `undefined` only equal to itself (strict comparison).
                    if (a == null || b == null) return false;
                    // `NaN`s are equivalent, but non-reflexive.
                    if (a !== a) return b !== b;
                    // Exhaust primitive checks
                    var type = typeof a;
                    if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
                    return deepEq(a, b, aStack, bStack);
                }

                // Internal recursive comparison function for `_.isEqual`.
                function deepEq(a, b, aStack, bStack) {
                    // Unwrap any wrapped objects.
                    if (a instanceof _$1) a = a._wrapped;
                    if (b instanceof _$1) b = b._wrapped;
                    // Compare `[[Class]]` names.
                    var className = toString.call(a);
                    if (className !== toString.call(b)) return false;
                    // Work around a bug in IE 10 - Edge 13.
                    if (hasStringTagBug && className == '[object Object]' && isDataView$1(a)) {
                        if (!isDataView$1(b)) return false;
                        className = tagDataView;
                    }
                    switch (className) {
                        // These types are compared by value.
                        case '[object RegExp]':
                        // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
                        case '[object String]':
                            // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
                            // equivalent to `new String("5")`.
                            return '' + a === '' + b;
                        case '[object Number]':
                            // `NaN`s are equivalent, but non-reflexive.
                            // Object(NaN) is equivalent to NaN.
                            if (+a !== +a) return +b !== +b;
                            // An `egal` comparison is performed for other numeric values.
                            return +a === 0 ? 1 / +a === 1 / b : +a === +b;
                        case '[object Date]':
                        case '[object Boolean]':
                            // Coerce dates and booleans to numeric primitive values. Dates are compared by their
                            // millisecond representations. Note that invalid dates with millisecond representations
                            // of `NaN` are not equivalent.
                            return +a === +b;
                        case '[object Symbol]':
                            return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
                        case '[object ArrayBuffer]':
                        case tagDataView:
                            // Coerce to typed array so we can fall through.
                            return deepEq(toBufferView(a), toBufferView(b), aStack, bStack);
                    }

                    var areArrays = className === '[object Array]';
                    if (!areArrays && isTypedArray$1(a)) {
                        var byteLength = getByteLength(a);
                        if (byteLength !== getByteLength(b)) return false;
                        if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;
                        areArrays = true;
                    }
                    if (!areArrays) {
                        if (typeof a != 'object' || typeof b != 'object') return false;

                        // Objects with different constructors are not equivalent, but `Object`s or `Array`s
                        // from different frames are.
                        var aCtor = a.constructor, bCtor = b.constructor;
                        if (aCtor !== bCtor && !(isFunction$1(aCtor) && aCtor instanceof aCtor &&
                                isFunction$1(bCtor) && bCtor instanceof bCtor)
                            && ('constructor' in a && 'constructor' in b)) {
                            return false;
                        }
                    }
                    // Assume equality for cyclic structures. The algorithm for detecting cyclic
                    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.

                    // Initializing stack of traversed objects.
                    // It's done here since we only need them for objects and arrays comparison.
                    aStack = aStack || [];
                    bStack = bStack || [];
                    var length = aStack.length;
                    while (length--) {
                        // Linear search. Performance is inversely proportional to the number of
                        // unique nested structures.
                        if (aStack[length] === a) return bStack[length] === b;
                    }

                    // Add the first object to the stack of traversed objects.
                    aStack.push(a);
                    bStack.push(b);

                    // Recursively compare objects and arrays.
                    if (areArrays) {
                        // Compare array lengths to determine if a deep comparison is necessary.
                        length = a.length;
                        if (length !== b.length) return false;
                        // Deep compare the contents, ignoring non-numeric properties.
                        while (length--) {
                            if (!eq(a[length], b[length], aStack, bStack)) return false;
                        }
                    } else {
                        // Deep compare objects.
                        var _keys = keys(a), key;
                        length = _keys.length;
                        // Ensure that both objects contain the same number of properties before comparing deep equality.
                        if (keys(b).length !== length) return false;
                        while (length--) {
                            // Deep compare each member
                            key = _keys[length];
                            if (!(has$1(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
                        }
                    }
                    // Remove the first object from the stack of traversed objects.
                    aStack.pop();
                    bStack.pop();
                    return true;
                }

                // Perform a deep comparison to check if two objects are equal.
                function isEqual(a, b) {
                    return eq(a, b);
                }

                // Retrieve all the enumerable property names of an object.
                function allKeys(obj) {
                    if (!isObject(obj)) return [];
                    var keys = [];
                    for (var key in obj) keys.push(key);
                    // Ahem, IE < 9.
                    if (hasEnumBug) collectNonEnumProps(obj, keys);
                    return keys;
                }

                // Since the regular `Object.prototype.toString` type tests don't work for
                // some types in IE 11, we use a fingerprinting heuristic instead, based
                // on the methods. It's not great, but it's the best we got.
                // The fingerprint method lists are defined below.
                function ie11fingerprint(methods) {
                    var length = getLength(methods);
                    return function(obj) {
                        if (obj == null) return false;
                        // `Map`, `WeakMap` and `Set` have no enumerable keys.
                        var keys = allKeys(obj);
                        if (getLength(keys)) return false;
                        for (var i = 0; i < length; i++) {
                            if (!isFunction$1(obj[methods[i]])) return false;
                        }
                        // If we are testing against `WeakMap`, we need to ensure that
                        // `obj` doesn't have a `forEach` method in order to distinguish
                        // it from a regular `Map`.
                        return methods !== weakMapMethods || !isFunction$1(obj[forEachName]);
                    };
                }

                // In the interest of compact minification, we write
                // each string in the fingerprints only once.
                var forEachName = 'forEach',
                    hasName = 'has',
                    commonInit = ['clear', 'delete'],
                    mapTail = ['get', hasName, 'set'];

                // `Map`, `WeakMap` and `Set` each have slightly different
                // combinations of the above sublists.
                var mapMethods = commonInit.concat(forEachName, mapTail),
                    weakMapMethods = commonInit.concat(mapTail),
                    setMethods = ['add'].concat(commonInit, forEachName, hasName);

                var isMap = isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');

                var isWeakMap = isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');

                var isSet = isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');

                var isWeakSet = tagTester('WeakSet');

                // Retrieve the values of an object's properties.
                function values(obj) {
                    var _keys = keys(obj);
                    var length = _keys.length;
                    var values = Array(length);
                    for (var i = 0; i < length; i++) {
                        values[i] = obj[_keys[i]];
                    }
                    return values;
                }

                // Convert an object into a list of `[key, value]` pairs.
                // The opposite of `_.object` with one argument.
                function pairs(obj) {
                    var _keys = keys(obj);
                    var length = _keys.length;
                    var pairs = Array(length);
                    for (var i = 0; i < length; i++) {
                        pairs[i] = [_keys[i], obj[_keys[i]]];
                    }
                    return pairs;
                }

                // Invert the keys and values of an object. The values must be serializable.
                function invert(obj) {
                    var result = {};
                    var _keys = keys(obj);
                    for (var i = 0, length = _keys.length; i < length; i++) {
                        result[obj[_keys[i]]] = _keys[i];
                    }
                    return result;
                }

                // Return a sorted list of the function names available on the object.
                function functions(obj) {
                    var names = [];
                    for (var key in obj) {
                        if (isFunction$1(obj[key])) names.push(key);
                    }
                    return names.sort();
                }

                // An internal function for creating assigner functions.
                function createAssigner(keysFunc, defaults) {
                    return function(obj) {
                        var length = arguments.length;
                        if (defaults) obj = Object(obj);
                        if (length < 2 || obj == null) return obj;
                        for (var index = 1; index < length; index++) {
                            var source = arguments[index],
                                keys = keysFunc(source),
                                l = keys.length;
                            for (var i = 0; i < l; i++) {
                                var key = keys[i];
                                if (!defaults || obj[key] === void 0) obj[key] = source[key];
                            }
                        }
                        return obj;
                    };
                }

                // Extend a given object with all the properties in passed-in object(s).
                var extend = createAssigner(allKeys);

                // Assigns a given object with all the own properties in the passed-in
                // object(s).
                // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
                var extendOwn = createAssigner(keys);

                // Fill in a given object with default properties.
                var defaults = createAssigner(allKeys, true);

                // Create a naked function reference for surrogate-prototype-swapping.
                function ctor() {
                    return function(){};
                }

                // An internal function for creating a new object that inherits from another.
                function baseCreate(prototype) {
                    if (!isObject(prototype)) return {};
                    if (nativeCreate) return nativeCreate(prototype);
                    var Ctor = ctor();
                    Ctor.prototype = prototype;
                    var result = new Ctor;
                    Ctor.prototype = null;
                    return result;
                }

                // Creates an object that inherits from the given prototype object.
                // If additional properties are provided then they will be added to the
                // created object.
                function create(prototype, props) {
                    var result = baseCreate(prototype);
                    if (props) extendOwn(result, props);
                    return result;
                }

                // Create a (shallow-cloned) duplicate of an object.
                function clone(obj) {
                    if (!isObject(obj)) return obj;
                    return isArray(obj) ? obj.slice() : extend({}, obj);
                }

                // Invokes `interceptor` with the `obj` and then returns `obj`.
                // The primary purpose of this method is to "tap into" a method chain, in
                // order to perform operations on intermediate results within the chain.
                function tap(obj, interceptor) {
                    interceptor(obj);
                    return obj;
                }

                // Normalize a (deep) property `path` to array.
                // Like `_.iteratee`, this function can be customized.
                function toPath$1(path) {
                    return isArray(path) ? path : [path];
                }
                _$1.toPath = toPath$1;

                // Internal wrapper for `_.toPath` to enable minification.
                // Similar to `cb` for `_.iteratee`.
                function toPath(path) {
                    return _$1.toPath(path);
                }

                // Internal function to obtain a nested property in `obj` along `path`.
                function deepGet(obj, path) {
                    var length = path.length;
                    for (var i = 0; i < length; i++) {
                        if (obj == null) return void 0;
                        obj = obj[path[i]];
                    }
                    return length ? obj : void 0;
                }

                // Get the value of the (deep) property on `path` from `object`.
                // If any property in `path` does not exist or if the value is
                // `undefined`, return `defaultValue` instead.
                // The `path` is normalized through `_.toPath`.
                function get(object, path, defaultValue) {
                    var value = deepGet(object, toPath(path));
                    return isUndefined(value) ? defaultValue : value;
                }

                // Shortcut function for checking if an object has a given property directly on
                // itself (in other words, not on a prototype). Unlike the internal `has`
                // function, this public version can also traverse nested properties.
                function has(obj, path) {
                    path = toPath(path);
                    var length = path.length;
                    for (var i = 0; i < length; i++) {
                        var key = path[i];
                        if (!has$1(obj, key)) return false;
                        obj = obj[key];
                    }
                    return !!length;
                }

                // Keep the identity function around for default iteratees.
                function identity(value) {
                    return value;
                }

                // Returns a predicate for checking whether an object has a given set of
                // `key:value` pairs.
                function matcher(attrs) {
                    attrs = extendOwn({}, attrs);
                    return function(obj) {
                        return isMatch(obj, attrs);
                    };
                }

                // Creates a function that, when passed an object, will traverse that object’s
                // properties down the given `path`, specified as an array of keys or indices.
                function property(path) {
                    path = toPath(path);
                    return function(obj) {
                        return deepGet(obj, path);
                    };
                }

                // Internal function that returns an efficient (for current engines) version
                // of the passed-in callback, to be repeatedly applied in other Underscore
                // functions.
                function optimizeCb(func, context, argCount) {
                    if (context === void 0) return func;
                    switch (argCount == null ? 3 : argCount) {
                        case 1: return function(value) {
                            return func.call(context, value);
                        };
                        // The 2-argument case is omitted because we’re not using it.
                        case 3: return function(value, index, collection) {
                            return func.call(context, value, index, collection);
                        };
                        case 4: return function(accumulator, value, index, collection) {
                            return func.call(context, accumulator, value, index, collection);
                        };
                    }
                    return function() {
                        return func.apply(context, arguments);
                    };
                }

                // An internal function to generate callbacks that can be applied to each
                // element in a collection, returning the desired result — either `_.identity`,
                // an arbitrary callback, a property matcher, or a property accessor.
                function baseIteratee(value, context, argCount) {
                    if (value == null) return identity;
                    if (isFunction$1(value)) return optimizeCb(value, context, argCount);
                    if (isObject(value) && !isArray(value)) return matcher(value);
                    return property(value);
                }

                // External wrapper for our callback generator. Users may customize
                // `_.iteratee` if they want additional predicate/iteratee shorthand styles.
                // This abstraction hides the internal-only `argCount` argument.
                function iteratee(value, context) {
                    return baseIteratee(value, context, Infinity);
                }
                _$1.iteratee = iteratee;

                // The function we call internally to generate a callback. It invokes
                // `_.iteratee` if overridden, otherwise `baseIteratee`.
                function cb(value, context, argCount) {
                    if (_$1.iteratee !== iteratee) return _$1.iteratee(value, context);
                    return baseIteratee(value, context, argCount);
                }

                // Returns the results of applying the `iteratee` to each element of `obj`.
                // In contrast to `_.map` it returns an object.
                function mapObject(obj, iteratee, context) {
                    iteratee = cb(iteratee, context);
                    var _keys = keys(obj),
                        length = _keys.length,
                        results = {};
                    for (var index = 0; index < length; index++) {
                        var currentKey = _keys[index];
                        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
                    }
                    return results;
                }

                // Predicate-generating function. Often useful outside of Underscore.
                function noop(){}

                // Generates a function for a given object that returns a given property.
                function propertyOf(obj) {
                    if (obj == null) return noop;
                    return function(path) {
                        return get(obj, path);
                    };
                }

                // Run a function **n** times.
                function times(n, iteratee, context) {
                    var accum = Array(Math.max(0, n));
                    iteratee = optimizeCb(iteratee, context, 1);
                    for (var i = 0; i < n; i++) accum[i] = iteratee(i);
                    return accum;
                }

                // Return a random integer between `min` and `max` (inclusive).
                function random(min, max) {
                    if (max == null) {
                        max = min;
                        min = 0;
                    }
                    return min + Math.floor(Math.random() * (max - min + 1));
                }

                // A (possibly faster) way to get the current timestamp as an integer.
                var now = Date.now || function() {
                    return new Date().getTime();
                };

                // Internal helper to generate functions for escaping and unescaping strings
                // to/from HTML interpolation.
                function createEscaper(map) {
                    var escaper = function(match) {
                        return map[match];
                    };
                    // Regexes for identifying a key that needs to be escaped.
                    var source = '(?:' + keys(map).join('|') + ')';
                    var testRegexp = RegExp(source);
                    var replaceRegexp = RegExp(source, 'g');
                    return function(string) {
                        string = string == null ? '' : '' + string;
                        return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
                    };
                }

                // Internal list of HTML entities for escaping.
                var escapeMap = {
                    '&': '&amp;',
                    '<': '&lt;',
                    '>': '&gt;',
                    '"': '&quot;',
                    "'": '&#x27;',
                    '`': '&#x60;'
                };

                // Function for escaping strings to HTML interpolation.
                var _escape = createEscaper(escapeMap);

                // Internal list of HTML entities for unescaping.
                var unescapeMap = invert(escapeMap);

                // Function for unescaping strings from HTML interpolation.
                var _unescape = createEscaper(unescapeMap);

                // By default, Underscore uses ERB-style template delimiters. Change the
                // following template settings to use alternative delimiters.
                var templateSettings = _$1.templateSettings = {
                    evaluate: /<%([\s\S]+?)%>/g,
                    interpolate: /<%=([\s\S]+?)%>/g,
                    escape: /<%-([\s\S]+?)%>/g
                };

                // When customizing `_.templateSettings`, if you don't want to define an
                // interpolation, evaluation or escaping regex, we need one that is
                // guaranteed not to match.
                var noMatch = /(.)^/;

                // Certain characters need to be escaped so that they can be put into a
                // string literal.
                var escapes = {
                    "'": "'",
                    '\\': '\\',
                    '\r': 'r',
                    '\n': 'n',
                    '\u2028': 'u2028',
                    '\u2029': 'u2029'
                };

                var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;

                function escapeChar(match) {
                    return '\\' + escapes[match];
                }

                // In order to prevent third-party code injection through
                // `_.templateSettings.variable`, we test it against the following regular
                // expression. It is intentionally a bit more liberal than just matching valid
                // identifiers, but still prevents possible loopholes through defaults or
                // destructuring assignment.
                var bareIdentifier = /^\s*(\w|\$)+\s*$/;

                // JavaScript micro-templating, similar to John Resig's implementation.
                // Underscore templating handles arbitrary delimiters, preserves whitespace,
                // and correctly escapes quotes within interpolated code.
                // NB: `oldSettings` only exists for backwards compatibility.
                function template(text, settings, oldSettings) {
                    if (!settings && oldSettings) settings = oldSettings;
                    settings = defaults({}, settings, _$1.templateSettings);

                    // Combine delimiters into one regular expression via alternation.
                    var matcher = RegExp([
                        (settings.escape || noMatch).source,
                        (settings.interpolate || noMatch).source,
                        (settings.evaluate || noMatch).source
                    ].join('|') + '|$', 'g');

                    // Compile the template source, escaping string literals appropriately.
                    var index = 0;
                    var source = "__p+='";
                    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
                        source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
                        index = offset + match.length;

                        if (escape) {
                            source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
                        } else if (interpolate) {
                            source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
                        } else if (evaluate) {
                            source += "';\n" + evaluate + "\n__p+='";
                        }

                        // Adobe VMs need the match returned to produce the correct offset.
                        return match;
                    });
                    source += "';\n";

                    var argument = settings.variable;
                    if (argument) {
                        // Insure against third-party code injection. (CVE-2021-23358)
                        if (!bareIdentifier.test(argument)) throw new Error(
                            'variable is not a bare identifier: ' + argument
                        );
                    } else {
                        // If a variable is not specified, place data values in local scope.
                        source = 'with(obj||{}){\n' + source + '}\n';
                        argument = 'obj';
                    }

                    source = "var __t,__p='',__j=Array.prototype.join," +
                        "print=function(){__p+=__j.call(arguments,'');};\n" +
                        source + 'return __p;\n';

                    var render;
                    try {
                        render = new Function(argument, '_', source);
                    } catch (e) {
                        e.source = source;
                        throw e;
                    }

                    var template = function(data) {
                        return render.call(this, data, _$1);
                    };

                    // Provide the compiled source as a convenience for precompilation.
                    template.source = 'function(' + argument + '){\n' + source + '}';

                    return template;
                }

                // Traverses the children of `obj` along `path`. If a child is a function, it
                // is invoked with its parent as context. Returns the value of the final
                // child, or `fallback` if any child is undefined.
                function result(obj, path, fallback) {
                    path = toPath(path);
                    var length = path.length;
                    if (!length) {
                        return isFunction$1(fallback) ? fallback.call(obj) : fallback;
                    }
                    for (var i = 0; i < length; i++) {
                        var prop = obj == null ? void 0 : obj[path[i]];
                        if (prop === void 0) {
                            prop = fallback;
                            i = length; // Ensure we don't continue iterating.
                        }
                        obj = isFunction$1(prop) ? prop.call(obj) : prop;
                    }
                    return obj;
                }

                // Generate a unique integer id (unique within the entire client session).
                // Useful for temporary DOM ids.
                var idCounter = 0;
                function uniqueId(prefix) {
                    var id = ++idCounter + '';
                    return prefix ? prefix + id : id;
                }

                // Start chaining a wrapped Underscore object.
                function chain(obj) {
                    var instance = _$1(obj);
                    instance._chain = true;
                    return instance;
                }

                // Internal function to execute `sourceFunc` bound to `context` with optional
                // `args`. Determines whether to execute a function as a constructor or as a
                // normal function.
                function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
                    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
                    var self = baseCreate(sourceFunc.prototype);
                    var result = sourceFunc.apply(self, args);
                    if (isObject(result)) return result;
                    return self;
                }

                // Partially apply a function by creating a version that has had some of its
                // arguments pre-filled, without changing its dynamic `this` context. `_` acts
                // as a placeholder by default, allowing any combination of arguments to be
                // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.
                var partial = restArguments(function(func, boundArgs) {
                    var placeholder = partial.placeholder;
                    var bound = function() {
                        var position = 0, length = boundArgs.length;
                        var args = Array(length);
                        for (var i = 0; i < length; i++) {
                            args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
                        }
                        while (position < arguments.length) args.push(arguments[position++]);
                        return executeBound(func, bound, this, this, args);
                    };
                    return bound;
                });

                partial.placeholder = _$1;

                // Create a function bound to a given object (assigning `this`, and arguments,
                // optionally).
                var bind = restArguments(function(func, context, args) {
                    if (!isFunction$1(func)) throw new TypeError('Bind must be called on a function');
                    var bound = restArguments(function(callArgs) {
                        return executeBound(func, bound, context, this, args.concat(callArgs));
                    });
                    return bound;
                });

                // Internal helper for collection methods to determine whether a collection
                // should be iterated as an array or as an object.
                // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
                // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
                var isArrayLike = createSizePropertyCheck(getLength);

                // Internal implementation of a recursive `flatten` function.
                function flatten$1(input, depth, strict, output) {
                    output = output || [];
                    if (!depth && depth !== 0) {
                        depth = Infinity;
                    } else if (depth <= 0) {
                        return output.concat(input);
                    }
                    var idx = output.length;
                    for (var i = 0, length = getLength(input); i < length; i++) {
                        var value = input[i];
                        if (isArrayLike(value) && (isArray(value) || isArguments$1(value))) {
                            // Flatten current level of array or arguments object.
                            if (depth > 1) {
                                flatten$1(value, depth - 1, strict, output);
                                idx = output.length;
                            } else {
                                var j = 0, len = value.length;
                                while (j < len) output[idx++] = value[j++];
                            }
                        } else if (!strict) {
                            output[idx++] = value;
                        }
                    }
                    return output;
                }

                // Bind a number of an object's methods to that object. Remaining arguments
                // are the method names to be bound. Useful for ensuring that all callbacks
                // defined on an object belong to it.
                var bindAll = restArguments(function(obj, keys) {
                    keys = flatten$1(keys, false, false);
                    var index = keys.length;
                    if (index < 1) throw new Error('bindAll must be passed function names');
                    while (index--) {
                        var key = keys[index];
                        obj[key] = bind(obj[key], obj);
                    }
                    return obj;
                });

                // Memoize an expensive function by storing its results.
                function memoize(func, hasher) {
                    var memoize = function(key) {
                        var cache = memoize.cache;
                        var address = '' + (hasher ? hasher.apply(this, arguments) : key);
                        if (!has$1(cache, address)) cache[address] = func.apply(this, arguments);
                        return cache[address];
                    };
                    memoize.cache = {};
                    return memoize;
                }

                // Delays a function for the given number of milliseconds, and then calls
                // it with the arguments supplied.
                var delay = restArguments(function(func, wait, args) {
                    return setTimeout(function() {
                        return func.apply(null, args);
                    }, wait);
                });

                // Defers a function, scheduling it to run after the current call stack has
                // cleared.
                var defer = partial(delay, _$1, 1);

                // Returns a function, that, when invoked, will only be triggered at most once
                // during a given window of time. Normally, the throttled function will run
                // as much as it can, without ever going more than once per `wait` duration;
                // but if you'd like to disable the execution on the leading edge, pass
                // `{leading: false}`. To disable execution on the trailing edge, ditto.
                function throttle(func, wait, options) {
                    var timeout, context, args, result;
                    var previous = 0;
                    if (!options) options = {};

                    var later = function() {
                        previous = options.leading === false ? 0 : now();
                        timeout = null;
                        result = func.apply(context, args);
                        if (!timeout) context = args = null;
                    };

                    var throttled = function() {
                        var _now = now();
                        if (!previous && options.leading === false) previous = _now;
                        var remaining = wait - (_now - previous);
                        context = this;
                        args = arguments;
                        if (remaining <= 0 || remaining > wait) {
                            if (timeout) {
                                clearTimeout(timeout);
                                timeout = null;
                            }
                            previous = _now;
                            result = func.apply(context, args);
                            if (!timeout) context = args = null;
                        } else if (!timeout && options.trailing !== false) {
                            timeout = setTimeout(later, remaining);
                        }
                        return result;
                    };

                    throttled.cancel = function() {
                        clearTimeout(timeout);
                        previous = 0;
                        timeout = context = args = null;
                    };

                    return throttled;
                }

                // When a sequence of calls of the returned function ends, the argument
                // function is triggered. The end of a sequence is defined by the `wait`
                // parameter. If `immediate` is passed, the argument function will be
                // triggered at the beginning of the sequence instead of at the end.
                function debounce(func, wait, immediate) {
                    var timeout, previous, args, result, context;

                    var later = function() {
                        var passed = now() - previous;
                        if (wait > passed) {
                            timeout = setTimeout(later, wait - passed);
                        } else {
                            timeout = null;
                            if (!immediate) result = func.apply(context, args);
                            // This check is needed because `func` can recursively invoke `debounced`.
                            if (!timeout) args = context = null;
                        }
                    };

                    var debounced = restArguments(function(_args) {
                        context = this;
                        args = _args;
                        previous = now();
                        if (!timeout) {
                            timeout = setTimeout(later, wait);
                            if (immediate) result = func.apply(context, args);
                        }
                        return result;
                    });

                    debounced.cancel = function() {
                        clearTimeout(timeout);
                        timeout = args = context = null;
                    };

                    return debounced;
                }

                // Returns the first function passed as an argument to the second,
                // allowing you to adjust arguments, run code before and after, and
                // conditionally execute the original function.
                function wrap(func, wrapper) {
                    return partial(wrapper, func);
                }

                // Returns a negated version of the passed-in predicate.
                function negate(predicate) {
                    return function() {
                        return !predicate.apply(this, arguments);
                    };
                }

                // Returns a function that is the composition of a list of functions, each
                // consuming the return value of the function that follows.
                function compose() {
                    var args = arguments;
                    var start = args.length - 1;
                    return function() {
                        var i = start;
                        var result = args[start].apply(this, arguments);
                        while (i--) result = args[i].call(this, result);
                        return result;
                    };
                }

                // Returns a function that will only be executed on and after the Nth call.
                function after(times, func) {
                    return function() {
                        if (--times < 1) {
                            return func.apply(this, arguments);
                        }
                    };
                }

                // Returns a function that will only be executed up to (but not including) the
                // Nth call.
                function before(times, func) {
                    var memo;
                    return function() {
                        if (--times > 0) {
                            memo = func.apply(this, arguments);
                        }
                        if (times <= 1) func = null;
                        return memo;
                    };
                }

                // Returns a function that will be executed at most one time, no matter how
                // often you call it. Useful for lazy initialization.
                var once = partial(before, 2);

                // Returns the first key on an object that passes a truth test.
                function findKey(obj, predicate, context) {
                    predicate = cb(predicate, context);
                    var _keys = keys(obj), key;
                    for (var i = 0, length = _keys.length; i < length; i++) {
                        key = _keys[i];
                        if (predicate(obj[key], key, obj)) return key;
                    }
                }

                // Internal function to generate `_.findIndex` and `_.findLastIndex`.
                function createPredicateIndexFinder(dir) {
                    return function(array, predicate, context) {
                        predicate = cb(predicate, context);
                        var length = getLength(array);
                        var index = dir > 0 ? 0 : length - 1;
                        for (; index >= 0 && index < length; index += dir) {
                            if (predicate(array[index], index, array)) return index;
                        }
                        return -1;
                    };
                }

                // Returns the first index on an array-like that passes a truth test.
                var findIndex = createPredicateIndexFinder(1);

                // Returns the last index on an array-like that passes a truth test.
                var findLastIndex = createPredicateIndexFinder(-1);

                // Use a comparator function to figure out the smallest index at which
                // an object should be inserted so as to maintain order. Uses binary search.
                function sortedIndex(array, obj, iteratee, context) {
                    iteratee = cb(iteratee, context, 1);
                    var value = iteratee(obj);
                    var low = 0, high = getLength(array);
                    while (low < high) {
                        var mid = Math.floor((low + high) / 2);
                        if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
                    }
                    return low;
                }

                // Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.
                function createIndexFinder(dir, predicateFind, sortedIndex) {
                    return function(array, item, idx) {
                        var i = 0, length = getLength(array);
                        if (typeof idx == 'number') {
                            if (dir > 0) {
                                i = idx >= 0 ? idx : Math.max(idx + length, i);
                            } else {
                                length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
                            }
                        } else if (sortedIndex && idx && length) {
                            idx = sortedIndex(array, item);
                            return array[idx] === item ? idx : -1;
                        }
                        if (item !== item) {
                            idx = predicateFind(slice.call(array, i, length), isNaN$1);
                            return idx >= 0 ? idx + i : -1;
                        }
                        for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
                            if (array[idx] === item) return idx;
                        }
                        return -1;
                    };
                }

                // Return the position of the first occurrence of an item in an array,
                // or -1 if the item is not included in the array.
                // If the array is large and already in sort order, pass `true`
                // for **isSorted** to use binary search.
                var indexOf = createIndexFinder(1, findIndex, sortedIndex);

                // Return the position of the last occurrence of an item in an array,
                // or -1 if the item is not included in the array.
                var lastIndexOf = createIndexFinder(-1, findLastIndex);

                // Return the first value which passes a truth test.
                function find(obj, predicate, context) {
                    var keyFinder = isArrayLike(obj) ? findIndex : findKey;
                    var key = keyFinder(obj, predicate, context);
                    if (key !== void 0 && key !== -1) return obj[key];
                }

                // Convenience version of a common use case of `_.find`: getting the first
                // object containing specific `key:value` pairs.
                function findWhere(obj, attrs) {
                    return find(obj, matcher(attrs));
                }

                // The cornerstone for collection functions, an `each`
                // implementation, aka `forEach`.
                // Handles raw objects in addition to array-likes. Treats all
                // sparse array-likes as if they were dense.
                function each(obj, iteratee, context) {
                    iteratee = optimizeCb(iteratee, context);
                    var i, length;
                    if (isArrayLike(obj)) {
                        for (i = 0, length = obj.length; i < length; i++) {
                            iteratee(obj[i], i, obj);
                        }
                    } else {
                        var _keys = keys(obj);
                        for (i = 0, length = _keys.length; i < length; i++) {
                            iteratee(obj[_keys[i]], _keys[i], obj);
                        }
                    }
                    return obj;
                }

                // Return the results of applying the iteratee to each element.
                function map(obj, iteratee, context) {
                    iteratee = cb(iteratee, context);
                    var _keys = !isArrayLike(obj) && keys(obj),
                        length = (_keys || obj).length,
                        results = Array(length);
                    for (var index = 0; index < length; index++) {
                        var currentKey = _keys ? _keys[index] : index;
                        results[index] = iteratee(obj[currentKey], currentKey, obj);
                    }
                    return results;
                }

                // Internal helper to create a reducing function, iterating left or right.
                function createReduce(dir) {
                    // Wrap code that reassigns argument variables in a separate function than
                    // the one that accesses `arguments.length` to avoid a perf hit. (#1991)
                    var reducer = function(obj, iteratee, memo, initial) {
                        var _keys = !isArrayLike(obj) && keys(obj),
                            length = (_keys || obj).length,
                            index = dir > 0 ? 0 : length - 1;
                        if (!initial) {
                            memo = obj[_keys ? _keys[index] : index];
                            index += dir;
                        }
                        for (; index >= 0 && index < length; index += dir) {
                            var currentKey = _keys ? _keys[index] : index;
                            memo = iteratee(memo, obj[currentKey], currentKey, obj);
                        }
                        return memo;
                    };

                    return function(obj, iteratee, memo, context) {
                        var initial = arguments.length >= 3;
                        return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);
                    };
                }

                // **Reduce** builds up a single result from a list of values, aka `inject`,
                // or `foldl`.
                var reduce = createReduce(1);

                // The right-associative version of reduce, also known as `foldr`.
                var reduceRight = createReduce(-1);

                // Return all the elements that pass a truth test.
                function filter(obj, predicate, context) {
                    var results = [];
                    predicate = cb(predicate, context);
                    each(obj, function(value, index, list) {
                        if (predicate(value, index, list)) results.push(value);
                    });
                    return results;
                }

                // Return all the elements for which a truth test fails.
                function reject(obj, predicate, context) {
                    return filter(obj, negate(cb(predicate)), context);
                }

                // Determine whether all of the elements pass a truth test.
                function every(obj, predicate, context) {
                    predicate = cb(predicate, context);
                    var _keys = !isArrayLike(obj) && keys(obj),
                        length = (_keys || obj).length;
                    for (var index = 0; index < length; index++) {
                        var currentKey = _keys ? _keys[index] : index;
                        if (!predicate(obj[currentKey], currentKey, obj)) return false;
                    }
                    return true;
                }

                // Determine if at least one element in the object passes a truth test.
                function some(obj, predicate, context) {
                    predicate = cb(predicate, context);
                    var _keys = !isArrayLike(obj) && keys(obj),
                        length = (_keys || obj).length;
                    for (var index = 0; index < length; index++) {
                        var currentKey = _keys ? _keys[index] : index;
                        if (predicate(obj[currentKey], currentKey, obj)) return true;
                    }
                    return false;
                }

                // Determine if the array or object contains a given item (using `===`).
                function contains(obj, item, fromIndex, guard) {
                    if (!isArrayLike(obj)) obj = values(obj);
                    if (typeof fromIndex != 'number' || guard) fromIndex = 0;
                    return indexOf(obj, item, fromIndex) >= 0;
                }

                // Invoke a method (with arguments) on every item in a collection.
                var invoke = restArguments(function(obj, path, args) {
                    var contextPath, func;
                    if (isFunction$1(path)) {
                        func = path;
                    } else {
                        path = toPath(path);
                        contextPath = path.slice(0, -1);
                        path = path[path.length - 1];
                    }
                    return map(obj, function(context) {
                        var method = func;
                        if (!method) {
                            if (contextPath && contextPath.length) {
                                context = deepGet(context, contextPath);
                            }
                            if (context == null) return void 0;
                            method = context[path];
                        }
                        return method == null ? method : method.apply(context, args);
                    });
                });

                // Convenience version of a common use case of `_.map`: fetching a property.
                function pluck(obj, key) {
                    return map(obj, property(key));
                }

                // Convenience version of a common use case of `_.filter`: selecting only
                // objects containing specific `key:value` pairs.
                function where(obj, attrs) {
                    return filter(obj, matcher(attrs));
                }

                // Return the maximum element (or element-based computation).
                function max(obj, iteratee, context) {
                    var result = -Infinity, lastComputed = -Infinity,
                        value, computed;
                    if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {
                        obj = isArrayLike(obj) ? obj : values(obj);
                        for (var i = 0, length = obj.length; i < length; i++) {
                            value = obj[i];
                            if (value != null && value > result) {
                                result = value;
                            }
                        }
                    } else {
                        iteratee = cb(iteratee, context);
                        each(obj, function(v, index, list) {
                            computed = iteratee(v, index, list);
                            if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {
                                result = v;
                                lastComputed = computed;
                            }
                        });
                    }
                    return result;
                }

                // Return the minimum element (or element-based computation).
                function min(obj, iteratee, context) {
                    var result = Infinity, lastComputed = Infinity,
                        value, computed;
                    if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {
                        obj = isArrayLike(obj) ? obj : values(obj);
                        for (var i = 0, length = obj.length; i < length; i++) {
                            value = obj[i];
                            if (value != null && value < result) {
                                result = value;
                            }
                        }
                    } else {
                        iteratee = cb(iteratee, context);
                        each(obj, function(v, index, list) {
                            computed = iteratee(v, index, list);
                            if (computed < lastComputed || (computed === Infinity && result === Infinity)) {
                                result = v;
                                lastComputed = computed;
                            }
                        });
                    }
                    return result;
                }

                // Safely create a real, live array from anything iterable.
                var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
                function toArray(obj) {
                    if (!obj) return [];
                    if (isArray(obj)) return slice.call(obj);
                    if (isString(obj)) {
                        // Keep surrogate pair characters together.
                        return obj.match(reStrSymbol);
                    }
                    if (isArrayLike(obj)) return map(obj, identity);
                    return values(obj);
                }

                // Sample **n** random values from a collection using the modern version of the
                // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
                // If **n** is not specified, returns a single random element.
                // The internal `guard` argument allows it to work with `_.map`.
                function sample(obj, n, guard) {
                    if (n == null || guard) {
                        if (!isArrayLike(obj)) obj = values(obj);
                        return obj[random(obj.length - 1)];
                    }
                    var sample = toArray(obj);
                    var length = getLength(sample);
                    n = Math.max(Math.min(n, length), 0);
                    var last = length - 1;
                    for (var index = 0; index < n; index++) {
                        var rand = random(index, last);
                        var temp = sample[index];
                        sample[index] = sample[rand];
                        sample[rand] = temp;
                    }
                    return sample.slice(0, n);
                }

                // Shuffle a collection.
                function shuffle(obj) {
                    return sample(obj, Infinity);
                }

                // Sort the object's values by a criterion produced by an iteratee.
                function sortBy(obj, iteratee, context) {
                    var index = 0;
                    iteratee = cb(iteratee, context);
                    return pluck(map(obj, function(value, key, list) {
                        return {
                            value: value,
                            index: index++,
                            criteria: iteratee(value, key, list)
                        };
                    }).sort(function(left, right) {
                        var a = left.criteria;
                        var b = right.criteria;
                        if (a !== b) {
                            if (a > b || a === void 0) return 1;
                            if (a < b || b === void 0) return -1;
                        }
                        return left.index - right.index;
                    }), 'value');
                }

                // An internal function used for aggregate "group by" operations.
                function group(behavior, partition) {
                    return function(obj, iteratee, context) {
                        var result = partition ? [[], []] : {};
                        iteratee = cb(iteratee, context);
                        each(obj, function(value, index) {
                            var key = iteratee(value, index, obj);
                            behavior(result, value, key);
                        });
                        return result;
                    };
                }

                // Groups the object's values by a criterion. Pass either a string attribute
                // to group by, or a function that returns the criterion.
                var groupBy = group(function(result, value, key) {
                    if (has$1(result, key)) result[key].push(value); else result[key] = [value];
                });

                // Indexes the object's values by a criterion, similar to `_.groupBy`, but for
                // when you know that your index values will be unique.
                var indexBy = group(function(result, value, key) {
                    result[key] = value;
                });

                // Counts instances of an object that group by a certain criterion. Pass
                // either a string attribute to count by, or a function that returns the
                // criterion.
                var countBy = group(function(result, value, key) {
                    if (has$1(result, key)) result[key]++; else result[key] = 1;
                });

                // Split a collection into two arrays: one whose elements all pass the given
                // truth test, and one whose elements all do not pass the truth test.
                var partition = group(function(result, value, pass) {
                    result[pass ? 0 : 1].push(value);
                }, true);

                // Return the number of elements in a collection.
                function size(obj) {
                    if (obj == null) return 0;
                    return isArrayLike(obj) ? obj.length : keys(obj).length;
                }

                // Internal `_.pick` helper function to determine whether `key` is an enumerable
                // property name of `obj`.
                function keyInObj(value, key, obj) {
                    return key in obj;
                }

                // Return a copy of the object only containing the allowed properties.
                var pick = restArguments(function(obj, keys) {
                    var result = {}, iteratee = keys[0];
                    if (obj == null) return result;
                    if (isFunction$1(iteratee)) {
                        if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);
                        keys = allKeys(obj);
                    } else {
                        iteratee = keyInObj;
                        keys = flatten$1(keys, false, false);
                        obj = Object(obj);
                    }
                    for (var i = 0, length = keys.length; i < length; i++) {
                        var key = keys[i];
                        var value = obj[key];
                        if (iteratee(value, key, obj)) result[key] = value;
                    }
                    return result;
                });

                // Return a copy of the object without the disallowed properties.
                var omit = restArguments(function(obj, keys) {
                    var iteratee = keys[0], context;
                    if (isFunction$1(iteratee)) {
                        iteratee = negate(iteratee);
                        if (keys.length > 1) context = keys[1];
                    } else {
                        keys = map(flatten$1(keys, false, false), String);
                        iteratee = function(value, key) {
                            return !contains(keys, key);
                        };
                    }
                    return pick(obj, iteratee, context);
                });

                // Returns everything but the last entry of the array. Especially useful on
                // the arguments object. Passing **n** will return all the values in
                // the array, excluding the last N.
                function initial(array, n, guard) {
                    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
                }

                // Get the first element of an array. Passing **n** will return the first N
                // values in the array. The **guard** check allows it to work with `_.map`.
                function first(array, n, guard) {
                    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];
                    if (n == null || guard) return array[0];
                    return initial(array, array.length - n);
                }

                // Returns everything but the first entry of the `array`. Especially useful on
                // the `arguments` object. Passing an **n** will return the rest N values in the
                // `array`.
                function rest(array, n, guard) {
                    return slice.call(array, n == null || guard ? 1 : n);
                }

                // Get the last element of an array. Passing **n** will return the last N
                // values in the array.
                function last(array, n, guard) {
                    if (array == null || array.length < 1) return n == null || guard ? void 0 : [];
                    if (n == null || guard) return array[array.length - 1];
                    return rest(array, Math.max(0, array.length - n));
                }

                // Trim out all falsy values from an array.
                function compact(array) {
                    return filter(array, Boolean);
                }

                // Flatten out an array, either recursively (by default), or up to `depth`.
                // Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.
                function flatten(array, depth) {
                    return flatten$1(array, depth, false);
                }

                // Take the difference between one array and a number of other arrays.
                // Only the elements present in just the first array will remain.
                var difference = restArguments(function(array, rest) {
                    rest = flatten$1(rest, true, true);
                    return filter(array, function(value){
                        return !contains(rest, value);
                    });
                });

                // Return a version of the array that does not contain the specified value(s).
                var without = restArguments(function(array, otherArrays) {
                    return difference(array, otherArrays);
                });

                // Produce a duplicate-free version of the array. If the array has already
                // been sorted, you have the option of using a faster algorithm.
                // The faster algorithm will not work with an iteratee if the iteratee
                // is not a one-to-one function, so providing an iteratee will disable
                // the faster algorithm.
                function uniq(array, isSorted, iteratee, context) {
                    if (!isBoolean(isSorted)) {
                        context = iteratee;
                        iteratee = isSorted;
                        isSorted = false;
                    }
                    if (iteratee != null) iteratee = cb(iteratee, context);
                    var result = [];
                    var seen = [];
                    for (var i = 0, length = getLength(array); i < length; i++) {
                        var value = array[i],
                            computed = iteratee ? iteratee(value, i, array) : value;
                        if (isSorted && !iteratee) {
                            if (!i || seen !== computed) result.push(value);
                            seen = computed;
                        } else if (iteratee) {
                            if (!contains(seen, computed)) {
                                seen.push(computed);
                                result.push(value);
                            }
                        } else if (!contains(result, value)) {
                            result.push(value);
                        }
                    }
                    return result;
                }

                // Produce an array that contains the union: each distinct element from all of
                // the passed-in arrays.
                var union = restArguments(function(arrays) {
                    return uniq(flatten$1(arrays, true, true));
                });

                // Produce an array that contains every item shared between all the
                // passed-in arrays.
                function intersection(array) {
                    var result = [];
                    var argsLength = arguments.length;
                    for (var i = 0, length = getLength(array); i < length; i++) {
                        var item = array[i];
                        if (contains(result, item)) continue;
                        var j;
                        for (j = 1; j < argsLength; j++) {
                            if (!contains(arguments[j], item)) break;
                        }
                        if (j === argsLength) result.push(item);
                    }
                    return result;
                }

                // Complement of zip. Unzip accepts an array of arrays and groups
                // each array's elements on shared indices.
                function unzip(array) {
                    var length = (array && max(array, getLength).length) || 0;
                    var result = Array(length);

                    for (var index = 0; index < length; index++) {
                        result[index] = pluck(array, index);
                    }
                    return result;
                }

                // Zip together multiple lists into a single array -- elements that share
                // an index go together.
                var zip = restArguments(unzip);

                // Converts lists into objects. Pass either a single array of `[key, value]`
                // pairs, or two parallel arrays of the same length -- one of keys, and one of
                // the corresponding values. Passing by pairs is the reverse of `_.pairs`.
                function object(list, values) {
                    var result = {};
                    for (var i = 0, length = getLength(list); i < length; i++) {
                        if (values) {
                            result[list[i]] = values[i];
                        } else {
                            result[list[i][0]] = list[i][1];
                        }
                    }
                    return result;
                }

                // Generate an integer Array containing an arithmetic progression. A port of
                // the native Python `range()` function. See
                // [the Python documentation](https://docs.python.org/library/functions.html#range).
                function range(start, stop, step) {
                    if (stop == null) {
                        stop = start || 0;
                        start = 0;
                    }
                    if (!step) {
                        step = stop < start ? -1 : 1;
                    }

                    var length = Math.max(Math.ceil((stop - start) / step), 0);
                    var range = Array(length);

                    for (var idx = 0; idx < length; idx++, start += step) {
                        range[idx] = start;
                    }

                    return range;
                }

                // Chunk a single array into multiple arrays, each containing `count` or fewer
                // items.
                function chunk(array, count) {
                    if (count == null || count < 1) return [];
                    var result = [];
                    var i = 0, length = array.length;
                    while (i < length) {
                        result.push(slice.call(array, i, i += count));
                    }
                    return result;
                }

                // Helper function to continue chaining intermediate results.
                function chainResult(instance, obj) {
                    return instance._chain ? _$1(obj).chain() : obj;
                }

                // Add your own custom functions to the Underscore object.
                function mixin(obj) {
                    each(functions(obj), function(name) {
                        var func = _$1[name] = obj[name];
                        _$1.prototype[name] = function() {
                            var args = [this._wrapped];
                            push.apply(args, arguments);
                            return chainResult(this, func.apply(_$1, args));
                        };
                    });
                    return _$1;
                }

                // Add all mutator `Array` functions to the wrapper.
                each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
                    var method = ArrayProto[name];
                    _$1.prototype[name] = function() {
                        var obj = this._wrapped;
                        if (obj != null) {
                            method.apply(obj, arguments);
                            if ((name === 'shift' || name === 'splice') && obj.length === 0) {
                                delete obj[0];
                            }
                        }
                        return chainResult(this, obj);
                    };
                });

                // Add all accessor `Array` functions to the wrapper.
                each(['concat', 'join', 'slice'], function(name) {
                    var method = ArrayProto[name];
                    _$1.prototype[name] = function() {
                        var obj = this._wrapped;
                        if (obj != null) obj = method.apply(obj, arguments);
                        return chainResult(this, obj);
                    };
                });

                // Named Exports

                var allExports = {
                    __proto__: null,
                    VERSION: VERSION,
                    restArguments: restArguments,
                    isObject: isObject,
                    isNull: isNull,
                    isUndefined: isUndefined,
                    isBoolean: isBoolean,
                    isElement: isElement,
                    isString: isString,
                    isNumber: isNumber,
                    isDate: isDate,
                    isRegExp: isRegExp,
                    isError: isError,
                    isSymbol: isSymbol,
                    isArrayBuffer: isArrayBuffer,
                    isDataView: isDataView$1,
                    isArray: isArray,
                    isFunction: isFunction$1,
                    isArguments: isArguments$1,
                    isFinite: isFinite$1,
                    isNaN: isNaN$1,
                    isTypedArray: isTypedArray$1,
                    isEmpty: isEmpty,
                    isMatch: isMatch,
                    isEqual: isEqual,
                    isMap: isMap,
                    isWeakMap: isWeakMap,
                    isSet: isSet,
                    isWeakSet: isWeakSet,
                    keys: keys,
                    allKeys: allKeys,
                    values: values,
                    pairs: pairs,
                    invert: invert,
                    functions: functions,
                    methods: functions,
                    extend: extend,
                    extendOwn: extendOwn,
                    assign: extendOwn,
                    defaults: defaults,
                    create: create,
                    clone: clone,
                    tap: tap,
                    get: get,
                    has: has,
                    mapObject: mapObject,
                    identity: identity,
                    constant: constant,
                    noop: noop,
                    toPath: toPath$1,
                    property: property,
                    propertyOf: propertyOf,
                    matcher: matcher,
                    matches: matcher,
                    times: times,
                    random: random,
                    now: now,
                    escape: _escape,
                    unescape: _unescape,
                    templateSettings: templateSettings,
                    template: template,
                    result: result,
                    uniqueId: uniqueId,
                    chain: chain,
                    iteratee: iteratee,
                    partial: partial,
                    bind: bind,
                    bindAll: bindAll,
                    memoize: memoize,
                    delay: delay,
                    defer: defer,
                    throttle: throttle,
                    debounce: debounce,
                    wrap: wrap,
                    negate: negate,
                    compose: compose,
                    after: after,
                    before: before,
                    once: once,
                    findKey: findKey,
                    findIndex: findIndex,
                    findLastIndex: findLastIndex,
                    sortedIndex: sortedIndex,
                    indexOf: indexOf,
                    lastIndexOf: lastIndexOf,
                    find: find,
                    detect: find,
                    findWhere: findWhere,
                    each: each,
                    forEach: each,
                    map: map,
                    collect: map,
                    reduce: reduce,
                    foldl: reduce,
                    inject: reduce,
                    reduceRight: reduceRight,
                    foldr: reduceRight,
                    filter: filter,
                    select: filter,
                    reject: reject,
                    every: every,
                    all: every,
                    some: some,
                    any: some,
                    contains: contains,
                    includes: contains,
                    include: contains,
                    invoke: invoke,
                    pluck: pluck,
                    where: where,
                    max: max,
                    min: min,
                    shuffle: shuffle,
                    sample: sample,
                    sortBy: sortBy,
                    groupBy: groupBy,
                    indexBy: indexBy,
                    countBy: countBy,
                    partition: partition,
                    toArray: toArray,
                    size: size,
                    pick: pick,
                    omit: omit,
                    first: first,
                    head: first,
                    take: first,
                    initial: initial,
                    last: last,
                    rest: rest,
                    tail: rest,
                    drop: rest,
                    compact: compact,
                    flatten: flatten,
                    without: without,
                    uniq: uniq,
                    unique: uniq,
                    union: union,
                    intersection: intersection,
                    difference: difference,
                    unzip: unzip,
                    transpose: unzip,
                    zip: zip,
                    object: object,
                    range: range,
                    chunk: chunk,
                    mixin: mixin,
                    'default': _$1
                };

                // Default Export

                // Add all of the Underscore functions to the wrapper object.
                var _ = mixin(allExports);
                // Legacy Node.js API.
                _._ = _;

                return _;

            })));


        }).call(this)}).call(this,typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],123:[function(require,module,exports){
        (function (global){(function (){

            /**
             * 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)}).call(this,typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{}],124:[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';
        }
    },{}],125:[function(require,module,exports){
        (function (process,global){(function (){
// 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)}).call(this,require('_process'),typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    },{"./support/isBuffer":124,"_process":102,"inherits":83}],126:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject,
                slice = [].slice,
                hasProp = {}.hasOwnProperty;

            assign = function() {
                var i, key, len, source, sources, target;
                target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];
                if (isFunction(Object.assign)) {
                    Object.assign.apply(null, arguments);
                } else {
                    for (i = 0, len = sources.length; i < len; i++) {
                        source = sources[i];
                        if (source != null) {
                            for (key in source) {
                                if (!hasProp.call(source, key)) continue;
                                target[key] = source[key];
                            }
                        }
                    }
                }
                return target;
            };

            isFunction = function(val) {
                return !!val && Object.prototype.toString.call(val) === '[object Function]';
            };

            isObject = function(val) {
                var ref;
                return !!val && ((ref = typeof val) === 'function' || ref === 'object');
            };

            isArray = function(val) {
                if (isFunction(Array.isArray)) {
                    return Array.isArray(val);
                } else {
                    return Object.prototype.toString.call(val) === '[object Array]';
                }
            };

            isEmpty = function(val) {
                var key;
                if (isArray(val)) {
                    return !val.length;
                } else {
                    for (key in val) {
                        if (!hasProp.call(val, key)) continue;
                        return false;
                    }
                    return true;
                }
            };

            isPlainObject = function(val) {
                var ctor, proto;
                return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
            };

            getValue = function(obj) {
                if (isFunction(obj.valueOf)) {
                    return obj.valueOf();
                } else {
                    return obj;
                }
            };

            module.exports.assign = assign;

            module.exports.isFunction = isFunction;

            module.exports.isObject = isObject;

            module.exports.isArray = isArray;

            module.exports.isEmpty = isEmpty;

            module.exports.isPlainObject = isPlainObject;

            module.exports.getValue = getValue;

        }).call(this);

    },{}],127:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLAttribute;

            module.exports = XMLAttribute = (function() {
                function XMLAttribute(parent, name, value) {
                    this.options = parent.options;
                    this.stringify = parent.stringify;
                    this.parent = parent;
                    if (name == null) {
                        throw new Error("Missing attribute name. " + this.debugInfo(name));
                    }
                    if (value == null) {
                        throw new Error("Missing attribute value. " + this.debugInfo(name));
                    }
                    this.name = this.stringify.attName(name);
                    this.value = this.stringify.attValue(value);
                }

                XMLAttribute.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLAttribute.prototype.toString = function(options) {
                    return this.options.writer.set(options).attribute(this);
                };

                XMLAttribute.prototype.debugInfo = function(name) {
                    name = name || this.name;
                    if (name == null) {
                        return "parent: <" + this.parent.name + ">";
                    } else {
                        return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
                    }
                };

                return XMLAttribute;

            })();

        }).call(this);

    },{}],128:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLCData, XMLNode,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLCData = (function(superClass) {
                extend(XMLCData, superClass);

                function XMLCData(parent, text) {
                    XMLCData.__super__.constructor.call(this, parent);
                    if (text == null) {
                        throw new Error("Missing CDATA text. " + this.debugInfo());
                    }
                    this.text = this.stringify.cdata(text);
                }

                XMLCData.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLCData.prototype.toString = function(options) {
                    return this.options.writer.set(options).cdata(this);
                };

                return XMLCData;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],129:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLComment, XMLNode,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLComment = (function(superClass) {
                extend(XMLComment, superClass);

                function XMLComment(parent, text) {
                    XMLComment.__super__.constructor.call(this, parent);
                    if (text == null) {
                        throw new Error("Missing comment text. " + this.debugInfo());
                    }
                    this.text = this.stringify.comment(text);
                }

                XMLComment.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLComment.prototype.toString = function(options) {
                    return this.options.writer.set(options).comment(this);
                };

                return XMLComment;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],130:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDTDAttList, XMLNode,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLDTDAttList = (function(superClass) {
                extend(XMLDTDAttList, superClass);

                function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
                    XMLDTDAttList.__super__.constructor.call(this, parent);
                    if (elementName == null) {
                        throw new Error("Missing DTD element name. " + this.debugInfo());
                    }
                    if (attributeName == null) {
                        throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
                    }
                    if (!attributeType) {
                        throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
                    }
                    if (!defaultValueType) {
                        throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
                    }
                    if (defaultValueType.indexOf('#') !== 0) {
                        defaultValueType = '#' + defaultValueType;
                    }
                    if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
                        throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
                    }
                    if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
                        throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
                    }
                    this.elementName = this.stringify.eleName(elementName);
                    this.attributeName = this.stringify.attName(attributeName);
                    this.attributeType = this.stringify.dtdAttType(attributeType);
                    this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
                    this.defaultValueType = defaultValueType;
                }

                XMLDTDAttList.prototype.toString = function(options) {
                    return this.options.writer.set(options).dtdAttList(this);
                };

                return XMLDTDAttList;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],131:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDTDElement, XMLNode,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLDTDElement = (function(superClass) {
                extend(XMLDTDElement, superClass);

                function XMLDTDElement(parent, name, value) {
                    XMLDTDElement.__super__.constructor.call(this, parent);
                    if (name == null) {
                        throw new Error("Missing DTD element name. " + this.debugInfo());
                    }
                    if (!value) {
                        value = '(#PCDATA)';
                    }
                    if (Array.isArray(value)) {
                        value = '(' + value.join(',') + ')';
                    }
                    this.name = this.stringify.eleName(name);
                    this.value = this.stringify.dtdElementValue(value);
                }

                XMLDTDElement.prototype.toString = function(options) {
                    return this.options.writer.set(options).dtdElement(this);
                };

                return XMLDTDElement;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],132:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDTDEntity, XMLNode, isObject,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            isObject = require('./Utility').isObject;

            XMLNode = require('./XMLNode');

            module.exports = XMLDTDEntity = (function(superClass) {
                extend(XMLDTDEntity, superClass);

                function XMLDTDEntity(parent, pe, name, value) {
                    XMLDTDEntity.__super__.constructor.call(this, parent);
                    if (name == null) {
                        throw new Error("Missing DTD entity name. " + this.debugInfo(name));
                    }
                    if (value == null) {
                        throw new Error("Missing DTD entity value. " + this.debugInfo(name));
                    }
                    this.pe = !!pe;
                    this.name = this.stringify.eleName(name);
                    if (!isObject(value)) {
                        this.value = this.stringify.dtdEntityValue(value);
                    } else {
                        if (!value.pubID && !value.sysID) {
                            throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
                        }
                        if (value.pubID && !value.sysID) {
                            throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
                        }
                        if (value.pubID != null) {
                            this.pubID = this.stringify.dtdPubID(value.pubID);
                        }
                        if (value.sysID != null) {
                            this.sysID = this.stringify.dtdSysID(value.sysID);
                        }
                        if (value.nData != null) {
                            this.nData = this.stringify.dtdNData(value.nData);
                        }
                        if (this.pe && this.nData) {
                            throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
                        }
                    }
                }

                XMLDTDEntity.prototype.toString = function(options) {
                    return this.options.writer.set(options).dtdEntity(this);
                };

                return XMLDTDEntity;

            })(XMLNode);

        }).call(this);

    },{"./Utility":126,"./XMLNode":140}],133:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDTDNotation, XMLNode,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLDTDNotation = (function(superClass) {
                extend(XMLDTDNotation, superClass);

                function XMLDTDNotation(parent, name, value) {
                    XMLDTDNotation.__super__.constructor.call(this, parent);
                    if (name == null) {
                        throw new Error("Missing DTD notation name. " + this.debugInfo(name));
                    }
                    if (!value.pubID && !value.sysID) {
                        throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
                    }
                    this.name = this.stringify.eleName(name);
                    if (value.pubID != null) {
                        this.pubID = this.stringify.dtdPubID(value.pubID);
                    }
                    if (value.sysID != null) {
                        this.sysID = this.stringify.dtdSysID(value.sysID);
                    }
                }

                XMLDTDNotation.prototype.toString = function(options) {
                    return this.options.writer.set(options).dtdNotation(this);
                };

                return XMLDTDNotation;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],134:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDeclaration, XMLNode, isObject,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            isObject = require('./Utility').isObject;

            XMLNode = require('./XMLNode');

            module.exports = XMLDeclaration = (function(superClass) {
                extend(XMLDeclaration, superClass);

                function XMLDeclaration(parent, version, encoding, standalone) {
                    var ref;
                    XMLDeclaration.__super__.constructor.call(this, parent);
                    if (isObject(version)) {
                        ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
                    }
                    if (!version) {
                        version = '1.0';
                    }
                    this.version = this.stringify.xmlVersion(version);
                    if (encoding != null) {
                        this.encoding = this.stringify.xmlEncoding(encoding);
                    }
                    if (standalone != null) {
                        this.standalone = this.stringify.xmlStandalone(standalone);
                    }
                }

                XMLDeclaration.prototype.toString = function(options) {
                    return this.options.writer.set(options).declaration(this);
                };

                return XMLDeclaration;

            })(XMLNode);

        }).call(this);

    },{"./Utility":126,"./XMLNode":140}],135:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNode, isObject,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            isObject = require('./Utility').isObject;

            XMLNode = require('./XMLNode');

            XMLDTDAttList = require('./XMLDTDAttList');

            XMLDTDEntity = require('./XMLDTDEntity');

            XMLDTDElement = require('./XMLDTDElement');

            XMLDTDNotation = require('./XMLDTDNotation');

            module.exports = XMLDocType = (function(superClass) {
                extend(XMLDocType, superClass);

                function XMLDocType(parent, pubID, sysID) {
                    var ref, ref1;
                    XMLDocType.__super__.constructor.call(this, parent);
                    this.name = "!DOCTYPE";
                    this.documentObject = parent;
                    if (isObject(pubID)) {
                        ref = pubID, pubID = ref.pubID, sysID = ref.sysID;
                    }
                    if (sysID == null) {
                        ref1 = [pubID, sysID], sysID = ref1[0], pubID = ref1[1];
                    }
                    if (pubID != null) {
                        this.pubID = this.stringify.dtdPubID(pubID);
                    }
                    if (sysID != null) {
                        this.sysID = this.stringify.dtdSysID(sysID);
                    }
                }

                XMLDocType.prototype.element = function(name, value) {
                    var child;
                    child = new XMLDTDElement(this, name, value);
                    this.children.push(child);
                    return this;
                };

                XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
                    var child;
                    child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
                    this.children.push(child);
                    return this;
                };

                XMLDocType.prototype.entity = function(name, value) {
                    var child;
                    child = new XMLDTDEntity(this, false, name, value);
                    this.children.push(child);
                    return this;
                };

                XMLDocType.prototype.pEntity = function(name, value) {
                    var child;
                    child = new XMLDTDEntity(this, true, name, value);
                    this.children.push(child);
                    return this;
                };

                XMLDocType.prototype.notation = function(name, value) {
                    var child;
                    child = new XMLDTDNotation(this, name, value);
                    this.children.push(child);
                    return this;
                };

                XMLDocType.prototype.toString = function(options) {
                    return this.options.writer.set(options).docType(this);
                };

                XMLDocType.prototype.ele = function(name, value) {
                    return this.element(name, value);
                };

                XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
                    return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
                };

                XMLDocType.prototype.ent = function(name, value) {
                    return this.entity(name, value);
                };

                XMLDocType.prototype.pent = function(name, value) {
                    return this.pEntity(name, value);
                };

                XMLDocType.prototype.not = function(name, value) {
                    return this.notation(name, value);
                };

                XMLDocType.prototype.up = function() {
                    return this.root() || this.documentObject;
                };

                return XMLDocType;

            })(XMLNode);

        }).call(this);

    },{"./Utility":126,"./XMLDTDAttList":130,"./XMLDTDElement":131,"./XMLDTDEntity":132,"./XMLDTDNotation":133,"./XMLNode":140}],136:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            isPlainObject = require('./Utility').isPlainObject;

            XMLNode = require('./XMLNode');

            XMLStringifier = require('./XMLStringifier');

            XMLStringWriter = require('./XMLStringWriter');

            module.exports = XMLDocument = (function(superClass) {
                extend(XMLDocument, superClass);

                function XMLDocument(options) {
                    XMLDocument.__super__.constructor.call(this, null);
                    this.name = "?xml";
                    options || (options = {});
                    if (!options.writer) {
                        options.writer = new XMLStringWriter();
                    }
                    this.options = options;
                    this.stringify = new XMLStringifier(options);
                    this.isDocument = true;
                }

                XMLDocument.prototype.end = function(writer) {
                    var writerOptions;
                    if (!writer) {
                        writer = this.options.writer;
                    } else if (isPlainObject(writer)) {
                        writerOptions = writer;
                        writer = this.options.writer.set(writerOptions);
                    }
                    return writer.document(this);
                };

                XMLDocument.prototype.toString = function(options) {
                    return this.options.writer.set(options).document(this);
                };

                return XMLDocument;

            })(XMLNode);

        }).call(this);

    },{"./Utility":126,"./XMLNode":140,"./XMLStringWriter":144,"./XMLStringifier":145}],137:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref,
                hasProp = {}.hasOwnProperty;

            ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue;

            XMLElement = require('./XMLElement');

            XMLCData = require('./XMLCData');

            XMLComment = require('./XMLComment');

            XMLRaw = require('./XMLRaw');

            XMLText = require('./XMLText');

            XMLProcessingInstruction = require('./XMLProcessingInstruction');

            XMLDeclaration = require('./XMLDeclaration');

            XMLDocType = require('./XMLDocType');

            XMLDTDAttList = require('./XMLDTDAttList');

            XMLDTDEntity = require('./XMLDTDEntity');

            XMLDTDElement = require('./XMLDTDElement');

            XMLDTDNotation = require('./XMLDTDNotation');

            XMLAttribute = require('./XMLAttribute');

            XMLStringifier = require('./XMLStringifier');

            XMLStringWriter = require('./XMLStringWriter');

            module.exports = XMLDocumentCB = (function() {
                function XMLDocumentCB(options, onData, onEnd) {
                    var writerOptions;
                    this.name = "?xml";
                    options || (options = {});
                    if (!options.writer) {
                        options.writer = new XMLStringWriter(options);
                    } else if (isPlainObject(options.writer)) {
                        writerOptions = options.writer;
                        options.writer = new XMLStringWriter(writerOptions);
                    }
                    this.options = options;
                    this.writer = options.writer;
                    this.stringify = new XMLStringifier(options);
                    this.onDataCallback = onData || function() {};
                    this.onEndCallback = onEnd || function() {};
                    this.currentNode = null;
                    this.currentLevel = -1;
                    this.openTags = {};
                    this.documentStarted = false;
                    this.documentCompleted = false;
                    this.root = null;
                }

                XMLDocumentCB.prototype.node = function(name, attributes, text) {
                    var ref1, ref2;
                    if (name == null) {
                        throw new Error("Missing node name.");
                    }
                    if (this.root && this.currentLevel === -1) {
                        throw new Error("Document can only have one root node. " + this.debugInfo(name));
                    }
                    this.openCurrent();
                    name = getValue(name);
                    if (attributes === null && (text == null)) {
                        ref1 = [{}, null], attributes = ref1[0], text = ref1[1];
                    }
                    if (attributes == null) {
                        attributes = {};
                    }
                    attributes = getValue(attributes);
                    if (!isObject(attributes)) {
                        ref2 = [attributes, text], text = ref2[0], attributes = ref2[1];
                    }
                    this.currentNode = new XMLElement(this, name, attributes);
                    this.currentNode.children = false;
                    this.currentLevel++;
                    this.openTags[this.currentLevel] = this.currentNode;
                    if (text != null) {
                        this.text(text);
                    }
                    return this;
                };

                XMLDocumentCB.prototype.element = function(name, attributes, text) {
                    if (this.currentNode && this.currentNode instanceof XMLDocType) {
                        return this.dtdElement.apply(this, arguments);
                    } else {
                        return this.node(name, attributes, text);
                    }
                };

                XMLDocumentCB.prototype.attribute = function(name, value) {
                    var attName, attValue;
                    if (!this.currentNode || this.currentNode.children) {
                        throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
                    }
                    if (name != null) {
                        name = getValue(name);
                    }
                    if (isObject(name)) {
                        for (attName in name) {
                            if (!hasProp.call(name, attName)) continue;
                            attValue = name[attName];
                            this.attribute(attName, attValue);
                        }
                    } else {
                        if (isFunction(value)) {
                            value = value.apply();
                        }
                        if (!this.options.skipNullAttributes || (value != null)) {
                            this.currentNode.attributes[name] = new XMLAttribute(this, name, value);
                        }
                    }
                    return this;
                };

                XMLDocumentCB.prototype.text = function(value) {
                    var node;
                    this.openCurrent();
                    node = new XMLText(this, value);
                    this.onData(this.writer.text(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.cdata = function(value) {
                    var node;
                    this.openCurrent();
                    node = new XMLCData(this, value);
                    this.onData(this.writer.cdata(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.comment = function(value) {
                    var node;
                    this.openCurrent();
                    node = new XMLComment(this, value);
                    this.onData(this.writer.comment(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.raw = function(value) {
                    var node;
                    this.openCurrent();
                    node = new XMLRaw(this, value);
                    this.onData(this.writer.raw(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.instruction = function(target, value) {
                    var i, insTarget, insValue, len, node;
                    this.openCurrent();
                    if (target != null) {
                        target = getValue(target);
                    }
                    if (value != null) {
                        value = getValue(value);
                    }
                    if (Array.isArray(target)) {
                        for (i = 0, len = target.length; i < len; i++) {
                            insTarget = target[i];
                            this.instruction(insTarget);
                        }
                    } else if (isObject(target)) {
                        for (insTarget in target) {
                            if (!hasProp.call(target, insTarget)) continue;
                            insValue = target[insTarget];
                            this.instruction(insTarget, insValue);
                        }
                    } else {
                        if (isFunction(value)) {
                            value = value.apply();
                        }
                        node = new XMLProcessingInstruction(this, target, value);
                        this.onData(this.writer.processingInstruction(node, this.currentLevel + 1), this.currentLevel + 1);
                    }
                    return this;
                };

                XMLDocumentCB.prototype.declaration = function(version, encoding, standalone) {
                    var node;
                    this.openCurrent();
                    if (this.documentStarted) {
                        throw new Error("declaration() must be the first node.");
                    }
                    node = new XMLDeclaration(this, version, encoding, standalone);
                    this.onData(this.writer.declaration(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.doctype = function(root, pubID, sysID) {
                    this.openCurrent();
                    if (root == null) {
                        throw new Error("Missing root node name.");
                    }
                    if (this.root) {
                        throw new Error("dtd() must come before the root node.");
                    }
                    this.currentNode = new XMLDocType(this, pubID, sysID);
                    this.currentNode.rootNodeName = root;
                    this.currentNode.children = false;
                    this.currentLevel++;
                    this.openTags[this.currentLevel] = this.currentNode;
                    return this;
                };

                XMLDocumentCB.prototype.dtdElement = function(name, value) {
                    var node;
                    this.openCurrent();
                    node = new XMLDTDElement(this, name, value);
                    this.onData(this.writer.dtdElement(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
                    var node;
                    this.openCurrent();
                    node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
                    this.onData(this.writer.dtdAttList(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.entity = function(name, value) {
                    var node;
                    this.openCurrent();
                    node = new XMLDTDEntity(this, false, name, value);
                    this.onData(this.writer.dtdEntity(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.pEntity = function(name, value) {
                    var node;
                    this.openCurrent();
                    node = new XMLDTDEntity(this, true, name, value);
                    this.onData(this.writer.dtdEntity(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.notation = function(name, value) {
                    var node;
                    this.openCurrent();
                    node = new XMLDTDNotation(this, name, value);
                    this.onData(this.writer.dtdNotation(node, this.currentLevel + 1), this.currentLevel + 1);
                    return this;
                };

                XMLDocumentCB.prototype.up = function() {
                    if (this.currentLevel < 0) {
                        throw new Error("The document node has no parent.");
                    }
                    if (this.currentNode) {
                        if (this.currentNode.children) {
                            this.closeNode(this.currentNode);
                        } else {
                            this.openNode(this.currentNode);
                        }
                        this.currentNode = null;
                    } else {
                        this.closeNode(this.openTags[this.currentLevel]);
                    }
                    delete this.openTags[this.currentLevel];
                    this.currentLevel--;
                    return this;
                };

                XMLDocumentCB.prototype.end = function() {
                    while (this.currentLevel >= 0) {
                        this.up();
                    }
                    return this.onEnd();
                };

                XMLDocumentCB.prototype.openCurrent = function() {
                    if (this.currentNode) {
                        this.currentNode.children = true;
                        return this.openNode(this.currentNode);
                    }
                };

                XMLDocumentCB.prototype.openNode = function(node) {
                    if (!node.isOpen) {
                        if (!this.root && this.currentLevel === 0 && node instanceof XMLElement) {
                            this.root = node;
                        }
                        this.onData(this.writer.openNode(node, this.currentLevel), this.currentLevel);
                        return node.isOpen = true;
                    }
                };

                XMLDocumentCB.prototype.closeNode = function(node) {
                    if (!node.isClosed) {
                        this.onData(this.writer.closeNode(node, this.currentLevel), this.currentLevel);
                        return node.isClosed = true;
                    }
                };

                XMLDocumentCB.prototype.onData = function(chunk, level) {
                    this.documentStarted = true;
                    return this.onDataCallback(chunk, level + 1);
                };

                XMLDocumentCB.prototype.onEnd = function() {
                    this.documentCompleted = true;
                    return this.onEndCallback();
                };

                XMLDocumentCB.prototype.debugInfo = function(name) {
                    if (name == null) {
                        return "";
                    } else {
                        return "node: <" + name + ">";
                    }
                };

                XMLDocumentCB.prototype.ele = function() {
                    return this.element.apply(this, arguments);
                };

                XMLDocumentCB.prototype.nod = function(name, attributes, text) {
                    return this.node(name, attributes, text);
                };

                XMLDocumentCB.prototype.txt = function(value) {
                    return this.text(value);
                };

                XMLDocumentCB.prototype.dat = function(value) {
                    return this.cdata(value);
                };

                XMLDocumentCB.prototype.com = function(value) {
                    return this.comment(value);
                };

                XMLDocumentCB.prototype.ins = function(target, value) {
                    return this.instruction(target, value);
                };

                XMLDocumentCB.prototype.dec = function(version, encoding, standalone) {
                    return this.declaration(version, encoding, standalone);
                };

                XMLDocumentCB.prototype.dtd = function(root, pubID, sysID) {
                    return this.doctype(root, pubID, sysID);
                };

                XMLDocumentCB.prototype.e = function(name, attributes, text) {
                    return this.element(name, attributes, text);
                };

                XMLDocumentCB.prototype.n = function(name, attributes, text) {
                    return this.node(name, attributes, text);
                };

                XMLDocumentCB.prototype.t = function(value) {
                    return this.text(value);
                };

                XMLDocumentCB.prototype.d = function(value) {
                    return this.cdata(value);
                };

                XMLDocumentCB.prototype.c = function(value) {
                    return this.comment(value);
                };

                XMLDocumentCB.prototype.r = function(value) {
                    return this.raw(value);
                };

                XMLDocumentCB.prototype.i = function(target, value) {
                    return this.instruction(target, value);
                };

                XMLDocumentCB.prototype.att = function() {
                    if (this.currentNode && this.currentNode instanceof XMLDocType) {
                        return this.attList.apply(this, arguments);
                    } else {
                        return this.attribute.apply(this, arguments);
                    }
                };

                XMLDocumentCB.prototype.a = function() {
                    if (this.currentNode && this.currentNode instanceof XMLDocType) {
                        return this.attList.apply(this, arguments);
                    } else {
                        return this.attribute.apply(this, arguments);
                    }
                };

                XMLDocumentCB.prototype.ent = function(name, value) {
                    return this.entity(name, value);
                };

                XMLDocumentCB.prototype.pent = function(name, value) {
                    return this.pEntity(name, value);
                };

                XMLDocumentCB.prototype.not = function(name, value) {
                    return this.notation(name, value);
                };

                return XMLDocumentCB;

            })();

        }).call(this);

    },{"./Utility":126,"./XMLAttribute":127,"./XMLCData":128,"./XMLComment":129,"./XMLDTDAttList":130,"./XMLDTDElement":131,"./XMLDTDEntity":132,"./XMLDTDNotation":133,"./XMLDeclaration":134,"./XMLDocType":135,"./XMLElement":139,"./XMLProcessingInstruction":141,"./XMLRaw":142,"./XMLStringWriter":144,"./XMLStringifier":145,"./XMLText":146}],138:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDummy, XMLNode,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLDummy = (function(superClass) {
                extend(XMLDummy, superClass);

                function XMLDummy(parent) {
                    XMLDummy.__super__.constructor.call(this, parent);
                    this.isDummy = true;
                }

                XMLDummy.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLDummy.prototype.toString = function(options) {
                    return '';
                };

                return XMLDummy;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],139:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLAttribute, XMLElement, XMLNode, getValue, isFunction, isObject, ref,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue;

            XMLNode = require('./XMLNode');

            XMLAttribute = require('./XMLAttribute');

            module.exports = XMLElement = (function(superClass) {
                extend(XMLElement, superClass);

                function XMLElement(parent, name, attributes) {
                    XMLElement.__super__.constructor.call(this, parent);
                    if (name == null) {
                        throw new Error("Missing element name. " + this.debugInfo());
                    }
                    this.name = this.stringify.eleName(name);
                    this.attributes = {};
                    if (attributes != null) {
                        this.attribute(attributes);
                    }
                    if (parent.isDocument) {
                        this.isRoot = true;
                        this.documentObject = parent;
                        parent.rootObject = this;
                    }
                }

                XMLElement.prototype.clone = function() {
                    var att, attName, clonedSelf, ref1;
                    clonedSelf = Object.create(this);
                    if (clonedSelf.isRoot) {
                        clonedSelf.documentObject = null;
                    }
                    clonedSelf.attributes = {};
                    ref1 = this.attributes;
                    for (attName in ref1) {
                        if (!hasProp.call(ref1, attName)) continue;
                        att = ref1[attName];
                        clonedSelf.attributes[attName] = att.clone();
                    }
                    clonedSelf.children = [];
                    this.children.forEach(function(child) {
                        var clonedChild;
                        clonedChild = child.clone();
                        clonedChild.parent = clonedSelf;
                        return clonedSelf.children.push(clonedChild);
                    });
                    return clonedSelf;
                };

                XMLElement.prototype.attribute = function(name, value) {
                    var attName, attValue;
                    if (name != null) {
                        name = getValue(name);
                    }
                    if (isObject(name)) {
                        for (attName in name) {
                            if (!hasProp.call(name, attName)) continue;
                            attValue = name[attName];
                            this.attribute(attName, attValue);
                        }
                    } else {
                        if (isFunction(value)) {
                            value = value.apply();
                        }
                        if (!this.options.skipNullAttributes || (value != null)) {
                            this.attributes[name] = new XMLAttribute(this, name, value);
                        }
                    }
                    return this;
                };

                XMLElement.prototype.removeAttribute = function(name) {
                    var attName, i, len;
                    if (name == null) {
                        throw new Error("Missing attribute name. " + this.debugInfo());
                    }
                    name = getValue(name);
                    if (Array.isArray(name)) {
                        for (i = 0, len = name.length; i < len; i++) {
                            attName = name[i];
                            delete this.attributes[attName];
                        }
                    } else {
                        delete this.attributes[name];
                    }
                    return this;
                };

                XMLElement.prototype.toString = function(options) {
                    return this.options.writer.set(options).element(this);
                };

                XMLElement.prototype.att = function(name, value) {
                    return this.attribute(name, value);
                };

                XMLElement.prototype.a = function(name, value) {
                    return this.attribute(name, value);
                };

                return XMLElement;

            })(XMLNode);

        }).call(this);

    },{"./Utility":126,"./XMLAttribute":127,"./XMLNode":140}],140:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNode, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref,
                hasProp = {}.hasOwnProperty;

            ref = require('./Utility'), isObject = ref.isObject, isFunction = ref.isFunction, isEmpty = ref.isEmpty, getValue = ref.getValue;

            XMLElement = null;

            XMLCData = null;

            XMLComment = null;

            XMLDeclaration = null;

            XMLDocType = null;

            XMLRaw = null;

            XMLText = null;

            XMLProcessingInstruction = null;

            XMLDummy = null;

            module.exports = XMLNode = (function() {
                function XMLNode(parent) {
                    this.parent = parent;
                    if (this.parent) {
                        this.options = this.parent.options;
                        this.stringify = this.parent.stringify;
                    }
                    this.children = [];
                    if (!XMLElement) {
                        XMLElement = require('./XMLElement');
                        XMLCData = require('./XMLCData');
                        XMLComment = require('./XMLComment');
                        XMLDeclaration = require('./XMLDeclaration');
                        XMLDocType = require('./XMLDocType');
                        XMLRaw = require('./XMLRaw');
                        XMLText = require('./XMLText');
                        XMLProcessingInstruction = require('./XMLProcessingInstruction');
                        XMLDummy = require('./XMLDummy');
                    }
                }

                XMLNode.prototype.element = function(name, attributes, text) {
                    var childNode, item, j, k, key, lastChild, len, len1, ref1, ref2, val;
                    lastChild = null;
                    if (attributes === null && (text == null)) {
                        ref1 = [{}, null], attributes = ref1[0], text = ref1[1];
                    }
                    if (attributes == null) {
                        attributes = {};
                    }
                    attributes = getValue(attributes);
                    if (!isObject(attributes)) {
                        ref2 = [attributes, text], text = ref2[0], attributes = ref2[1];
                    }
                    if (name != null) {
                        name = getValue(name);
                    }
                    if (Array.isArray(name)) {
                        for (j = 0, len = name.length; j < len; j++) {
                            item = name[j];
                            lastChild = this.element(item);
                        }
                    } else if (isFunction(name)) {
                        lastChild = this.element(name.apply());
                    } else if (isObject(name)) {
                        for (key in name) {
                            if (!hasProp.call(name, key)) continue;
                            val = name[key];
                            if (isFunction(val)) {
                                val = val.apply();
                            }
                            if ((isObject(val)) && (isEmpty(val))) {
                                val = null;
                            }
                            if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
                                lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
                            } else if (!this.options.separateArrayItems && Array.isArray(val)) {
                                for (k = 0, len1 = val.length; k < len1; k++) {
                                    item = val[k];
                                    childNode = {};
                                    childNode[key] = item;
                                    lastChild = this.element(childNode);
                                }
                            } else if (isObject(val)) {
                                lastChild = this.element(key);
                                lastChild.element(val);
                            } else {
                                lastChild = this.element(key, val);
                            }
                        }
                    } else if (this.options.skipNullNodes && text === null) {
                        lastChild = this.dummy();
                    } else {
                        if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
                            lastChild = this.text(text);
                        } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
                            lastChild = this.cdata(text);
                        } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
                            lastChild = this.comment(text);
                        } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
                            lastChild = this.raw(text);
                        } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
                            lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
                        } else {
                            lastChild = this.node(name, attributes, text);
                        }
                    }
                    if (lastChild == null) {
                        throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
                    }
                    return lastChild;
                };

                XMLNode.prototype.insertBefore = function(name, attributes, text) {
                    var child, i, removed;
                    if (this.isRoot) {
                        throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
                    }
                    i = this.parent.children.indexOf(this);
                    removed = this.parent.children.splice(i);
                    child = this.parent.element(name, attributes, text);
                    Array.prototype.push.apply(this.parent.children, removed);
                    return child;
                };

                XMLNode.prototype.insertAfter = function(name, attributes, text) {
                    var child, i, removed;
                    if (this.isRoot) {
                        throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
                    }
                    i = this.parent.children.indexOf(this);
                    removed = this.parent.children.splice(i + 1);
                    child = this.parent.element(name, attributes, text);
                    Array.prototype.push.apply(this.parent.children, removed);
                    return child;
                };

                XMLNode.prototype.remove = function() {
                    var i, ref1;
                    if (this.isRoot) {
                        throw new Error("Cannot remove the root element. " + this.debugInfo());
                    }
                    i = this.parent.children.indexOf(this);
                    [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref1 = [])), ref1;
                    return this.parent;
                };

                XMLNode.prototype.node = function(name, attributes, text) {
                    var child, ref1;
                    if (name != null) {
                        name = getValue(name);
                    }
                    attributes || (attributes = {});
                    attributes = getValue(attributes);
                    if (!isObject(attributes)) {
                        ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
                    }
                    child = new XMLElement(this, name, attributes);
                    if (text != null) {
                        child.text(text);
                    }
                    this.children.push(child);
                    return child;
                };

                XMLNode.prototype.text = function(value) {
                    var child;
                    child = new XMLText(this, value);
                    this.children.push(child);
                    return this;
                };

                XMLNode.prototype.cdata = function(value) {
                    var child;
                    child = new XMLCData(this, value);
                    this.children.push(child);
                    return this;
                };

                XMLNode.prototype.comment = function(value) {
                    var child;
                    child = new XMLComment(this, value);
                    this.children.push(child);
                    return this;
                };

                XMLNode.prototype.commentBefore = function(value) {
                    var child, i, removed;
                    i = this.parent.children.indexOf(this);
                    removed = this.parent.children.splice(i);
                    child = this.parent.comment(value);
                    Array.prototype.push.apply(this.parent.children, removed);
                    return this;
                };

                XMLNode.prototype.commentAfter = function(value) {
                    var child, i, removed;
                    i = this.parent.children.indexOf(this);
                    removed = this.parent.children.splice(i + 1);
                    child = this.parent.comment(value);
                    Array.prototype.push.apply(this.parent.children, removed);
                    return this;
                };

                XMLNode.prototype.raw = function(value) {
                    var child;
                    child = new XMLRaw(this, value);
                    this.children.push(child);
                    return this;
                };

                XMLNode.prototype.dummy = function() {
                    var child;
                    child = new XMLDummy(this);
                    this.children.push(child);
                    return child;
                };

                XMLNode.prototype.instruction = function(target, value) {
                    var insTarget, insValue, instruction, j, len;
                    if (target != null) {
                        target = getValue(target);
                    }
                    if (value != null) {
                        value = getValue(value);
                    }
                    if (Array.isArray(target)) {
                        for (j = 0, len = target.length; j < len; j++) {
                            insTarget = target[j];
                            this.instruction(insTarget);
                        }
                    } else if (isObject(target)) {
                        for (insTarget in target) {
                            if (!hasProp.call(target, insTarget)) continue;
                            insValue = target[insTarget];
                            this.instruction(insTarget, insValue);
                        }
                    } else {
                        if (isFunction(value)) {
                            value = value.apply();
                        }
                        instruction = new XMLProcessingInstruction(this, target, value);
                        this.children.push(instruction);
                    }
                    return this;
                };

                XMLNode.prototype.instructionBefore = function(target, value) {
                    var child, i, removed;
                    i = this.parent.children.indexOf(this);
                    removed = this.parent.children.splice(i);
                    child = this.parent.instruction(target, value);
                    Array.prototype.push.apply(this.parent.children, removed);
                    return this;
                };

                XMLNode.prototype.instructionAfter = function(target, value) {
                    var child, i, removed;
                    i = this.parent.children.indexOf(this);
                    removed = this.parent.children.splice(i + 1);
                    child = this.parent.instruction(target, value);
                    Array.prototype.push.apply(this.parent.children, removed);
                    return this;
                };

                XMLNode.prototype.declaration = function(version, encoding, standalone) {
                    var doc, xmldec;
                    doc = this.document();
                    xmldec = new XMLDeclaration(doc, version, encoding, standalone);
                    if (doc.children[0] instanceof XMLDeclaration) {
                        doc.children[0] = xmldec;
                    } else {
                        doc.children.unshift(xmldec);
                    }
                    return doc.root() || doc;
                };

                XMLNode.prototype.doctype = function(pubID, sysID) {
                    var child, doc, doctype, i, j, k, len, len1, ref1, ref2;
                    doc = this.document();
                    doctype = new XMLDocType(doc, pubID, sysID);
                    ref1 = doc.children;
                    for (i = j = 0, len = ref1.length; j < len; i = ++j) {
                        child = ref1[i];
                        if (child instanceof XMLDocType) {
                            doc.children[i] = doctype;
                            return doctype;
                        }
                    }
                    ref2 = doc.children;
                    for (i = k = 0, len1 = ref2.length; k < len1; i = ++k) {
                        child = ref2[i];
                        if (child.isRoot) {
                            doc.children.splice(i, 0, doctype);
                            return doctype;
                        }
                    }
                    doc.children.push(doctype);
                    return doctype;
                };

                XMLNode.prototype.up = function() {
                    if (this.isRoot) {
                        throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
                    }
                    return this.parent;
                };

                XMLNode.prototype.root = function() {
                    var node;
                    node = this;
                    while (node) {
                        if (node.isDocument) {
                            return node.rootObject;
                        } else if (node.isRoot) {
                            return node;
                        } else {
                            node = node.parent;
                        }
                    }
                };

                XMLNode.prototype.document = function() {
                    var node;
                    node = this;
                    while (node) {
                        if (node.isDocument) {
                            return node;
                        } else {
                            node = node.parent;
                        }
                    }
                };

                XMLNode.prototype.end = function(options) {
                    return this.document().end(options);
                };

                XMLNode.prototype.prev = function() {
                    var i;
                    i = this.parent.children.indexOf(this);
                    while (i > 0 && this.parent.children[i - 1].isDummy) {
                        i = i - 1;
                    }
                    if (i < 1) {
                        throw new Error("Already at the first node. " + this.debugInfo());
                    }
                    return this.parent.children[i - 1];
                };

                XMLNode.prototype.next = function() {
                    var i;
                    i = this.parent.children.indexOf(this);
                    while (i < this.parent.children.length - 1 && this.parent.children[i + 1].isDummy) {
                        i = i + 1;
                    }
                    if (i === -1 || i === this.parent.children.length - 1) {
                        throw new Error("Already at the last node. " + this.debugInfo());
                    }
                    return this.parent.children[i + 1];
                };

                XMLNode.prototype.importDocument = function(doc) {
                    var clonedRoot;
                    clonedRoot = doc.root().clone();
                    clonedRoot.parent = this;
                    clonedRoot.isRoot = false;
                    this.children.push(clonedRoot);
                    return this;
                };

                XMLNode.prototype.debugInfo = function(name) {
                    var ref1, ref2;
                    name = name || this.name;
                    if ((name == null) && !((ref1 = this.parent) != null ? ref1.name : void 0)) {
                        return "";
                    } else if (name == null) {
                        return "parent: <" + this.parent.name + ">";
                    } else if (!((ref2 = this.parent) != null ? ref2.name : void 0)) {
                        return "node: <" + name + ">";
                    } else {
                        return "node: <" + name + ">, parent: <" + this.parent.name + ">";
                    }
                };

                XMLNode.prototype.ele = function(name, attributes, text) {
                    return this.element(name, attributes, text);
                };

                XMLNode.prototype.nod = function(name, attributes, text) {
                    return this.node(name, attributes, text);
                };

                XMLNode.prototype.txt = function(value) {
                    return this.text(value);
                };

                XMLNode.prototype.dat = function(value) {
                    return this.cdata(value);
                };

                XMLNode.prototype.com = function(value) {
                    return this.comment(value);
                };

                XMLNode.prototype.ins = function(target, value) {
                    return this.instruction(target, value);
                };

                XMLNode.prototype.doc = function() {
                    return this.document();
                };

                XMLNode.prototype.dec = function(version, encoding, standalone) {
                    return this.declaration(version, encoding, standalone);
                };

                XMLNode.prototype.dtd = function(pubID, sysID) {
                    return this.doctype(pubID, sysID);
                };

                XMLNode.prototype.e = function(name, attributes, text) {
                    return this.element(name, attributes, text);
                };

                XMLNode.prototype.n = function(name, attributes, text) {
                    return this.node(name, attributes, text);
                };

                XMLNode.prototype.t = function(value) {
                    return this.text(value);
                };

                XMLNode.prototype.d = function(value) {
                    return this.cdata(value);
                };

                XMLNode.prototype.c = function(value) {
                    return this.comment(value);
                };

                XMLNode.prototype.r = function(value) {
                    return this.raw(value);
                };

                XMLNode.prototype.i = function(target, value) {
                    return this.instruction(target, value);
                };

                XMLNode.prototype.u = function() {
                    return this.up();
                };

                XMLNode.prototype.importXMLBuilder = function(doc) {
                    return this.importDocument(doc);
                };

                return XMLNode;

            })();

        }).call(this);

    },{"./Utility":126,"./XMLCData":128,"./XMLComment":129,"./XMLDeclaration":134,"./XMLDocType":135,"./XMLDummy":138,"./XMLElement":139,"./XMLProcessingInstruction":141,"./XMLRaw":142,"./XMLText":146}],141:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLNode, XMLProcessingInstruction,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLProcessingInstruction = (function(superClass) {
                extend(XMLProcessingInstruction, superClass);

                function XMLProcessingInstruction(parent, target, value) {
                    XMLProcessingInstruction.__super__.constructor.call(this, parent);
                    if (target == null) {
                        throw new Error("Missing instruction target. " + this.debugInfo());
                    }
                    this.target = this.stringify.insTarget(target);
                    if (value) {
                        this.value = this.stringify.insValue(value);
                    }
                }

                XMLProcessingInstruction.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLProcessingInstruction.prototype.toString = function(options) {
                    return this.options.writer.set(options).processingInstruction(this);
                };

                return XMLProcessingInstruction;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],142:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLNode, XMLRaw,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLRaw = (function(superClass) {
                extend(XMLRaw, superClass);

                function XMLRaw(parent, text) {
                    XMLRaw.__super__.constructor.call(this, parent);
                    if (text == null) {
                        throw new Error("Missing raw text. " + this.debugInfo());
                    }
                    this.value = this.stringify.raw(text);
                }

                XMLRaw.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLRaw.prototype.toString = function(options) {
                    return this.options.writer.set(options).raw(this);
                };

                return XMLRaw;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],143:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStreamWriter, XMLText, XMLWriterBase,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLDeclaration = require('./XMLDeclaration');

            XMLDocType = require('./XMLDocType');

            XMLCData = require('./XMLCData');

            XMLComment = require('./XMLComment');

            XMLElement = require('./XMLElement');

            XMLRaw = require('./XMLRaw');

            XMLText = require('./XMLText');

            XMLProcessingInstruction = require('./XMLProcessingInstruction');

            XMLDummy = require('./XMLDummy');

            XMLDTDAttList = require('./XMLDTDAttList');

            XMLDTDElement = require('./XMLDTDElement');

            XMLDTDEntity = require('./XMLDTDEntity');

            XMLDTDNotation = require('./XMLDTDNotation');

            XMLWriterBase = require('./XMLWriterBase');

            module.exports = XMLStreamWriter = (function(superClass) {
                extend(XMLStreamWriter, superClass);

                function XMLStreamWriter(stream, options) {
                    XMLStreamWriter.__super__.constructor.call(this, options);
                    this.stream = stream;
                }

                XMLStreamWriter.prototype.document = function(doc) {
                    var child, i, j, len, len1, ref, ref1, results;
                    ref = doc.children;
                    for (i = 0, len = ref.length; i < len; i++) {
                        child = ref[i];
                        child.isLastRootNode = false;
                    }
                    doc.children[doc.children.length - 1].isLastRootNode = true;
                    ref1 = doc.children;
                    results = [];
                    for (j = 0, len1 = ref1.length; j < len1; j++) {
                        child = ref1[j];
                        if (child instanceof XMLDummy) {
                            continue;
                        }
                        switch (false) {
                            case !(child instanceof XMLDeclaration):
                                results.push(this.declaration(child));
                                break;
                            case !(child instanceof XMLDocType):
                                results.push(this.docType(child));
                                break;
                            case !(child instanceof XMLComment):
                                results.push(this.comment(child));
                                break;
                            case !(child instanceof XMLProcessingInstruction):
                                results.push(this.processingInstruction(child));
                                break;
                            default:
                                results.push(this.element(child));
                        }
                    }
                    return results;
                };

                XMLStreamWriter.prototype.attribute = function(att) {
                    return this.stream.write(' ' + att.name + '="' + att.value + '"');
                };

                XMLStreamWriter.prototype.cdata = function(node, level) {
                    return this.stream.write(this.space(level) + '<![CDATA[' + node.text + ']]>' + this.endline(node));
                };

                XMLStreamWriter.prototype.comment = function(node, level) {
                    return this.stream.write(this.space(level) + '<!-- ' + node.text + ' -->' + this.endline(node));
                };

                XMLStreamWriter.prototype.declaration = function(node, level) {
                    this.stream.write(this.space(level));
                    this.stream.write('<?xml version="' + node.version + '"');
                    if (node.encoding != null) {
                        this.stream.write(' encoding="' + node.encoding + '"');
                    }
                    if (node.standalone != null) {
                        this.stream.write(' standalone="' + node.standalone + '"');
                    }
                    this.stream.write(this.spacebeforeslash + '?>');
                    return this.stream.write(this.endline(node));
                };

                XMLStreamWriter.prototype.docType = function(node, level) {
                    var child, i, len, ref;
                    level || (level = 0);
                    this.stream.write(this.space(level));
                    this.stream.write('<!DOCTYPE ' + node.root().name);
                    if (node.pubID && node.sysID) {
                        this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
                    } else if (node.sysID) {
                        this.stream.write(' SYSTEM "' + node.sysID + '"');
                    }
                    if (node.children.length > 0) {
                        this.stream.write(' [');
                        this.stream.write(this.endline(node));
                        ref = node.children;
                        for (i = 0, len = ref.length; i < len; i++) {
                            child = ref[i];
                            switch (false) {
                                case !(child instanceof XMLDTDAttList):
                                    this.dtdAttList(child, level + 1);
                                    break;
                                case !(child instanceof XMLDTDElement):
                                    this.dtdElement(child, level + 1);
                                    break;
                                case !(child instanceof XMLDTDEntity):
                                    this.dtdEntity(child, level + 1);
                                    break;
                                case !(child instanceof XMLDTDNotation):
                                    this.dtdNotation(child, level + 1);
                                    break;
                                case !(child instanceof XMLCData):
                                    this.cdata(child, level + 1);
                                    break;
                                case !(child instanceof XMLComment):
                                    this.comment(child, level + 1);
                                    break;
                                case !(child instanceof XMLProcessingInstruction):
                                    this.processingInstruction(child, level + 1);
                                    break;
                                default:
                                    throw new Error("Unknown DTD node type: " + child.constructor.name);
                            }
                        }
                        this.stream.write(']');
                    }
                    this.stream.write(this.spacebeforeslash + '>');
                    return this.stream.write(this.endline(node));
                };

                XMLStreamWriter.prototype.element = function(node, level) {
                    var att, child, i, len, name, ref, ref1, space;
                    level || (level = 0);
                    space = this.space(level);
                    this.stream.write(space + '<' + node.name);
                    ref = node.attributes;
                    for (name in ref) {
                        if (!hasProp.call(ref, name)) continue;
                        att = ref[name];
                        this.attribute(att);
                    }
                    if (node.children.length === 0 || node.children.every(function(e) {
                        return e.value === '';
                    })) {
                        if (this.allowEmpty) {
                            this.stream.write('></' + node.name + '>');
                        } else {
                            this.stream.write(this.spacebeforeslash + '/>');
                        }
                    } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) {
                        this.stream.write('>');
                        this.stream.write(node.children[0].value);
                        this.stream.write('</' + node.name + '>');
                    } else {
                        this.stream.write('>' + this.newline);
                        ref1 = node.children;
                        for (i = 0, len = ref1.length; i < len; i++) {
                            child = ref1[i];
                            switch (false) {
                                case !(child instanceof XMLCData):
                                    this.cdata(child, level + 1);
                                    break;
                                case !(child instanceof XMLComment):
                                    this.comment(child, level + 1);
                                    break;
                                case !(child instanceof XMLElement):
                                    this.element(child, level + 1);
                                    break;
                                case !(child instanceof XMLRaw):
                                    this.raw(child, level + 1);
                                    break;
                                case !(child instanceof XMLText):
                                    this.text(child, level + 1);
                                    break;
                                case !(child instanceof XMLProcessingInstruction):
                                    this.processingInstruction(child, level + 1);
                                    break;
                                case !(child instanceof XMLDummy):
                                    '';
                                    break;
                                default:
                                    throw new Error("Unknown XML node type: " + child.constructor.name);
                            }
                        }
                        this.stream.write(space + '</' + node.name + '>');
                    }
                    return this.stream.write(this.endline(node));
                };

                XMLStreamWriter.prototype.processingInstruction = function(node, level) {
                    this.stream.write(this.space(level) + '<?' + node.target);
                    if (node.value) {
                        this.stream.write(' ' + node.value);
                    }
                    return this.stream.write(this.spacebeforeslash + '?>' + this.endline(node));
                };

                XMLStreamWriter.prototype.raw = function(node, level) {
                    return this.stream.write(this.space(level) + node.value + this.endline(node));
                };

                XMLStreamWriter.prototype.text = function(node, level) {
                    return this.stream.write(this.space(level) + node.value + this.endline(node));
                };

                XMLStreamWriter.prototype.dtdAttList = function(node, level) {
                    this.stream.write(this.space(level) + '<!ATTLIST ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType);
                    if (node.defaultValueType !== '#DEFAULT') {
                        this.stream.write(' ' + node.defaultValueType);
                    }
                    if (node.defaultValue) {
                        this.stream.write(' "' + node.defaultValue + '"');
                    }
                    return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
                };

                XMLStreamWriter.prototype.dtdElement = function(node, level) {
                    this.stream.write(this.space(level) + '<!ELEMENT ' + node.name + ' ' + node.value);
                    return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
                };

                XMLStreamWriter.prototype.dtdEntity = function(node, level) {
                    this.stream.write(this.space(level) + '<!ENTITY');
                    if (node.pe) {
                        this.stream.write(' %');
                    }
                    this.stream.write(' ' + node.name);
                    if (node.value) {
                        this.stream.write(' "' + node.value + '"');
                    } else {
                        if (node.pubID && node.sysID) {
                            this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
                        } else if (node.sysID) {
                            this.stream.write(' SYSTEM "' + node.sysID + '"');
                        }
                        if (node.nData) {
                            this.stream.write(' NDATA ' + node.nData);
                        }
                    }
                    return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
                };

                XMLStreamWriter.prototype.dtdNotation = function(node, level) {
                    this.stream.write(this.space(level) + '<!NOTATION ' + node.name);
                    if (node.pubID && node.sysID) {
                        this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
                    } else if (node.pubID) {
                        this.stream.write(' PUBLIC "' + node.pubID + '"');
                    } else if (node.sysID) {
                        this.stream.write(' SYSTEM "' + node.sysID + '"');
                    }
                    return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
                };

                XMLStreamWriter.prototype.endline = function(node) {
                    if (!node.isLastRootNode) {
                        return this.newline;
                    } else {
                        return '';
                    }
                };

                return XMLStreamWriter;

            })(XMLWriterBase);

        }).call(this);

    },{"./XMLCData":128,"./XMLComment":129,"./XMLDTDAttList":130,"./XMLDTDElement":131,"./XMLDTDEntity":132,"./XMLDTDNotation":133,"./XMLDeclaration":134,"./XMLDocType":135,"./XMLDummy":138,"./XMLElement":139,"./XMLProcessingInstruction":141,"./XMLRaw":142,"./XMLText":146,"./XMLWriterBase":147}],144:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLText, XMLWriterBase,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLDeclaration = require('./XMLDeclaration');

            XMLDocType = require('./XMLDocType');

            XMLCData = require('./XMLCData');

            XMLComment = require('./XMLComment');

            XMLElement = require('./XMLElement');

            XMLRaw = require('./XMLRaw');

            XMLText = require('./XMLText');

            XMLProcessingInstruction = require('./XMLProcessingInstruction');

            XMLDummy = require('./XMLDummy');

            XMLDTDAttList = require('./XMLDTDAttList');

            XMLDTDElement = require('./XMLDTDElement');

            XMLDTDEntity = require('./XMLDTDEntity');

            XMLDTDNotation = require('./XMLDTDNotation');

            XMLWriterBase = require('./XMLWriterBase');

            module.exports = XMLStringWriter = (function(superClass) {
                extend(XMLStringWriter, superClass);

                function XMLStringWriter(options) {
                    XMLStringWriter.__super__.constructor.call(this, options);
                }

                XMLStringWriter.prototype.document = function(doc) {
                    var child, i, len, r, ref;
                    this.textispresent = false;
                    r = '';
                    ref = doc.children;
                    for (i = 0, len = ref.length; i < len; i++) {
                        child = ref[i];
                        if (child instanceof XMLDummy) {
                            continue;
                        }
                        r += (function() {
                            switch (false) {
                                case !(child instanceof XMLDeclaration):
                                    return this.declaration(child);
                                case !(child instanceof XMLDocType):
                                    return this.docType(child);
                                case !(child instanceof XMLComment):
                                    return this.comment(child);
                                case !(child instanceof XMLProcessingInstruction):
                                    return this.processingInstruction(child);
                                default:
                                    return this.element(child, 0);
                            }
                        }).call(this);
                    }
                    if (this.pretty && r.slice(-this.newline.length) === this.newline) {
                        r = r.slice(0, -this.newline.length);
                    }
                    return r;
                };

                XMLStringWriter.prototype.attribute = function(att) {
                    return ' ' + att.name + '="' + att.value + '"';
                };

                XMLStringWriter.prototype.cdata = function(node, level) {
                    return this.space(level) + '<![CDATA[' + node.text + ']]>' + this.newline;
                };

                XMLStringWriter.prototype.comment = function(node, level) {
                    return this.space(level) + '<!-- ' + node.text + ' -->' + this.newline;
                };

                XMLStringWriter.prototype.declaration = function(node, level) {
                    var r;
                    r = this.space(level);
                    r += '<?xml version="' + node.version + '"';
                    if (node.encoding != null) {
                        r += ' encoding="' + node.encoding + '"';
                    }
                    if (node.standalone != null) {
                        r += ' standalone="' + node.standalone + '"';
                    }
                    r += this.spacebeforeslash + '?>';
                    r += this.newline;
                    return r;
                };

                XMLStringWriter.prototype.docType = function(node, level) {
                    var child, i, len, r, ref;
                    level || (level = 0);
                    r = this.space(level);
                    r += '<!DOCTYPE ' + node.root().name;
                    if (node.pubID && node.sysID) {
                        r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
                    } else if (node.sysID) {
                        r += ' SYSTEM "' + node.sysID + '"';
                    }
                    if (node.children.length > 0) {
                        r += ' [';
                        r += this.newline;
                        ref = node.children;
                        for (i = 0, len = ref.length; i < len; i++) {
                            child = ref[i];
                            r += (function() {
                                switch (false) {
                                    case !(child instanceof XMLDTDAttList):
                                        return this.dtdAttList(child, level + 1);
                                    case !(child instanceof XMLDTDElement):
                                        return this.dtdElement(child, level + 1);
                                    case !(child instanceof XMLDTDEntity):
                                        return this.dtdEntity(child, level + 1);
                                    case !(child instanceof XMLDTDNotation):
                                        return this.dtdNotation(child, level + 1);
                                    case !(child instanceof XMLCData):
                                        return this.cdata(child, level + 1);
                                    case !(child instanceof XMLComment):
                                        return this.comment(child, level + 1);
                                    case !(child instanceof XMLProcessingInstruction):
                                        return this.processingInstruction(child, level + 1);
                                    default:
                                        throw new Error("Unknown DTD node type: " + child.constructor.name);
                                }
                            }).call(this);
                        }
                        r += ']';
                    }
                    r += this.spacebeforeslash + '>';
                    r += this.newline;
                    return r;
                };

                XMLStringWriter.prototype.element = function(node, level) {
                    var att, child, i, j, len, len1, name, r, ref, ref1, ref2, space, textispresentwasset;
                    level || (level = 0);
                    textispresentwasset = false;
                    if (this.textispresent) {
                        this.newline = '';
                        this.pretty = false;
                    } else {
                        this.newline = this.newlinedefault;
                        this.pretty = this.prettydefault;
                    }
                    space = this.space(level);
                    r = '';
                    r += space + '<' + node.name;
                    ref = node.attributes;
                    for (name in ref) {
                        if (!hasProp.call(ref, name)) continue;
                        att = ref[name];
                        r += this.attribute(att);
                    }
                    if (node.children.length === 0 || node.children.every(function(e) {
                        return e.value === '';
                    })) {
                        if (this.allowEmpty) {
                            r += '></' + node.name + '>' + this.newline;
                        } else {
                            r += this.spacebeforeslash + '/>' + this.newline;
                        }
                    } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) {
                        r += '>';
                        r += node.children[0].value;
                        r += '</' + node.name + '>' + this.newline;
                    } else {
                        if (this.dontprettytextnodes) {
                            ref1 = node.children;
                            for (i = 0, len = ref1.length; i < len; i++) {
                                child = ref1[i];
                                if (child.value != null) {
                                    this.textispresent++;
                                    textispresentwasset = true;
                                    break;
                                }
                            }
                        }
                        if (this.textispresent) {
                            this.newline = '';
                            this.pretty = false;
                            space = this.space(level);
                        }
                        r += '>' + this.newline;
                        ref2 = node.children;
                        for (j = 0, len1 = ref2.length; j < len1; j++) {
                            child = ref2[j];
                            r += (function() {
                                switch (false) {
                                    case !(child instanceof XMLCData):
                                        return this.cdata(child, level + 1);
                                    case !(child instanceof XMLComment):
                                        return this.comment(child, level + 1);
                                    case !(child instanceof XMLElement):
                                        return this.element(child, level + 1);
                                    case !(child instanceof XMLRaw):
                                        return this.raw(child, level + 1);
                                    case !(child instanceof XMLText):
                                        return this.text(child, level + 1);
                                    case !(child instanceof XMLProcessingInstruction):
                                        return this.processingInstruction(child, level + 1);
                                    case !(child instanceof XMLDummy):
                                        return '';
                                    default:
                                        throw new Error("Unknown XML node type: " + child.constructor.name);
                                }
                            }).call(this);
                        }
                        if (textispresentwasset) {
                            this.textispresent--;
                        }
                        if (!this.textispresent) {
                            this.newline = this.newlinedefault;
                            this.pretty = this.prettydefault;
                        }
                        r += space + '</' + node.name + '>' + this.newline;
                    }
                    return r;
                };

                XMLStringWriter.prototype.processingInstruction = function(node, level) {
                    var r;
                    r = this.space(level) + '<?' + node.target;
                    if (node.value) {
                        r += ' ' + node.value;
                    }
                    r += this.spacebeforeslash + '?>' + this.newline;
                    return r;
                };

                XMLStringWriter.prototype.raw = function(node, level) {
                    return this.space(level) + node.value + this.newline;
                };

                XMLStringWriter.prototype.text = function(node, level) {
                    return this.space(level) + node.value + this.newline;
                };

                XMLStringWriter.prototype.dtdAttList = function(node, level) {
                    var r;
                    r = this.space(level) + '<!ATTLIST ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;
                    if (node.defaultValueType !== '#DEFAULT') {
                        r += ' ' + node.defaultValueType;
                    }
                    if (node.defaultValue) {
                        r += ' "' + node.defaultValue + '"';
                    }
                    r += this.spacebeforeslash + '>' + this.newline;
                    return r;
                };

                XMLStringWriter.prototype.dtdElement = function(node, level) {
                    return this.space(level) + '<!ELEMENT ' + node.name + ' ' + node.value + this.spacebeforeslash + '>' + this.newline;
                };

                XMLStringWriter.prototype.dtdEntity = function(node, level) {
                    var r;
                    r = this.space(level) + '<!ENTITY';
                    if (node.pe) {
                        r += ' %';
                    }
                    r += ' ' + node.name;
                    if (node.value) {
                        r += ' "' + node.value + '"';
                    } else {
                        if (node.pubID && node.sysID) {
                            r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
                        } else if (node.sysID) {
                            r += ' SYSTEM "' + node.sysID + '"';
                        }
                        if (node.nData) {
                            r += ' NDATA ' + node.nData;
                        }
                    }
                    r += this.spacebeforeslash + '>' + this.newline;
                    return r;
                };

                XMLStringWriter.prototype.dtdNotation = function(node, level) {
                    var r;
                    r = this.space(level) + '<!NOTATION ' + node.name;
                    if (node.pubID && node.sysID) {
                        r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
                    } else if (node.pubID) {
                        r += ' PUBLIC "' + node.pubID + '"';
                    } else if (node.sysID) {
                        r += ' SYSTEM "' + node.sysID + '"';
                    }
                    r += this.spacebeforeslash + '>' + this.newline;
                    return r;
                };

                XMLStringWriter.prototype.openNode = function(node, level) {
                    var att, name, r, ref;
                    level || (level = 0);
                    if (node instanceof XMLElement) {
                        r = this.space(level) + '<' + node.name;
                        ref = node.attributes;
                        for (name in ref) {
                            if (!hasProp.call(ref, name)) continue;
                            att = ref[name];
                            r += this.attribute(att);
                        }
                        r += (node.children ? '>' : '/>') + this.newline;
                        return r;
                    } else {
                        r = this.space(level) + '<!DOCTYPE ' + node.rootNodeName;
                        if (node.pubID && node.sysID) {
                            r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
                        } else if (node.sysID) {
                            r += ' SYSTEM "' + node.sysID + '"';
                        }
                        r += (node.children ? ' [' : '>') + this.newline;
                        return r;
                    }
                };

                XMLStringWriter.prototype.closeNode = function(node, level) {
                    level || (level = 0);
                    switch (false) {
                        case !(node instanceof XMLElement):
                            return this.space(level) + '</' + node.name + '>' + this.newline;
                        case !(node instanceof XMLDocType):
                            return this.space(level) + ']>' + this.newline;
                    }
                };

                return XMLStringWriter;

            })(XMLWriterBase);

        }).call(this);

    },{"./XMLCData":128,"./XMLComment":129,"./XMLDTDAttList":130,"./XMLDTDElement":131,"./XMLDTDEntity":132,"./XMLDTDNotation":133,"./XMLDeclaration":134,"./XMLDocType":135,"./XMLDummy":138,"./XMLElement":139,"./XMLProcessingInstruction":141,"./XMLRaw":142,"./XMLText":146,"./XMLWriterBase":147}],145:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLStringifier,
                bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
                hasProp = {}.hasOwnProperty;

            module.exports = XMLStringifier = (function() {
                function XMLStringifier(options) {
                    this.assertLegalChar = bind(this.assertLegalChar, this);
                    var key, ref, value;
                    options || (options = {});
                    this.noDoubleEncoding = options.noDoubleEncoding;
                    ref = options.stringify || {};
                    for (key in ref) {
                        if (!hasProp.call(ref, key)) continue;
                        value = ref[key];
                        this[key] = value;
                    }
                }

                XMLStringifier.prototype.eleName = function(val) {
                    val = '' + val || '';
                    return this.assertLegalChar(val);
                };

                XMLStringifier.prototype.eleText = function(val) {
                    val = '' + val || '';
                    return this.assertLegalChar(this.elEscape(val));
                };

                XMLStringifier.prototype.cdata = function(val) {
                    val = '' + val || '';
                    val = val.replace(']]>', ']]]]><![CDATA[>');
                    return this.assertLegalChar(val);
                };

                XMLStringifier.prototype.comment = function(val) {
                    val = '' + val || '';
                    if (val.match(/--/)) {
                        throw new Error("Comment text cannot contain double-hypen: " + val);
                    }
                    return this.assertLegalChar(val);
                };

                XMLStringifier.prototype.raw = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.attName = function(val) {
                    return val = '' + val || '';
                };

                XMLStringifier.prototype.attValue = function(val) {
                    val = '' + val || '';
                    return this.attEscape(val);
                };

                XMLStringifier.prototype.insTarget = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.insValue = function(val) {
                    val = '' + val || '';
                    if (val.match(/\?>/)) {
                        throw new Error("Invalid processing instruction value: " + val);
                    }
                    return val;
                };

                XMLStringifier.prototype.xmlVersion = function(val) {
                    val = '' + val || '';
                    if (!val.match(/1\.[0-9]+/)) {
                        throw new Error("Invalid version number: " + val);
                    }
                    return val;
                };

                XMLStringifier.prototype.xmlEncoding = function(val) {
                    val = '' + val || '';
                    if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {
                        throw new Error("Invalid encoding: " + val);
                    }
                    return val;
                };

                XMLStringifier.prototype.xmlStandalone = function(val) {
                    if (val) {
                        return "yes";
                    } else {
                        return "no";
                    }
                };

                XMLStringifier.prototype.dtdPubID = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.dtdSysID = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.dtdElementValue = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.dtdAttType = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.dtdAttDefault = function(val) {
                    if (val != null) {
                        return '' + val || '';
                    } else {
                        return val;
                    }
                };

                XMLStringifier.prototype.dtdEntityValue = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.dtdNData = function(val) {
                    return '' + val || '';
                };

                XMLStringifier.prototype.convertAttKey = '@';

                XMLStringifier.prototype.convertPIKey = '?';

                XMLStringifier.prototype.convertTextKey = '#text';

                XMLStringifier.prototype.convertCDataKey = '#cdata';

                XMLStringifier.prototype.convertCommentKey = '#comment';

                XMLStringifier.prototype.convertRawKey = '#raw';

                XMLStringifier.prototype.assertLegalChar = function(str) {
                    var res;
                    res = str.match(/[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/);
                    if (res) {
                        throw new Error("Invalid character in string: " + str + " at index " + res.index);
                    }
                    return str;
                };

                XMLStringifier.prototype.elEscape = function(str) {
                    var ampregex;
                    ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
                    return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\r/g, '&#xD;');
                };

                XMLStringifier.prototype.attEscape = function(str) {
                    var ampregex;
                    ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
                    return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;').replace(/\t/g, '&#x9;').replace(/\n/g, '&#xA;').replace(/\r/g, '&#xD;');
                };

                return XMLStringifier;

            })();

        }).call(this);

    },{}],146:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLNode, XMLText,
                extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
                hasProp = {}.hasOwnProperty;

            XMLNode = require('./XMLNode');

            module.exports = XMLText = (function(superClass) {
                extend(XMLText, superClass);

                function XMLText(parent, text) {
                    XMLText.__super__.constructor.call(this, parent);
                    if (text == null) {
                        throw new Error("Missing element text. " + this.debugInfo());
                    }
                    this.value = this.stringify.eleText(text);
                }

                XMLText.prototype.clone = function() {
                    return Object.create(this);
                };

                XMLText.prototype.toString = function(options) {
                    return this.options.writer.set(options).text(this);
                };

                return XMLText;

            })(XMLNode);

        }).call(this);

    },{"./XMLNode":140}],147:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLWriterBase,
                hasProp = {}.hasOwnProperty;

            module.exports = XMLWriterBase = (function() {
                function XMLWriterBase(options) {
                    var key, ref, ref1, ref2, ref3, ref4, ref5, ref6, value;
                    options || (options = {});
                    this.pretty = options.pretty || false;
                    this.allowEmpty = (ref = options.allowEmpty) != null ? ref : false;
                    if (this.pretty) {
                        this.indent = (ref1 = options.indent) != null ? ref1 : '  ';
                        this.newline = (ref2 = options.newline) != null ? ref2 : '\n';
                        this.offset = (ref3 = options.offset) != null ? ref3 : 0;
                        this.dontprettytextnodes = (ref4 = options.dontprettytextnodes) != null ? ref4 : 0;
                    } else {
                        this.indent = '';
                        this.newline = '';
                        this.offset = 0;
                        this.dontprettytextnodes = 0;
                    }
                    this.spacebeforeslash = (ref5 = options.spacebeforeslash) != null ? ref5 : '';
                    if (this.spacebeforeslash === true) {
                        this.spacebeforeslash = ' ';
                    }
                    this.newlinedefault = this.newline;
                    this.prettydefault = this.pretty;
                    ref6 = options.writer || {};
                    for (key in ref6) {
                        if (!hasProp.call(ref6, key)) continue;
                        value = ref6[key];
                        this[key] = value;
                    }
                }

                XMLWriterBase.prototype.set = function(options) {
                    var key, ref, value;
                    options || (options = {});
                    if ("pretty" in options) {
                        this.pretty = options.pretty;
                    }
                    if ("allowEmpty" in options) {
                        this.allowEmpty = options.allowEmpty;
                    }
                    if (this.pretty) {
                        this.indent = "indent" in options ? options.indent : '  ';
                        this.newline = "newline" in options ? options.newline : '\n';
                        this.offset = "offset" in options ? options.offset : 0;
                        this.dontprettytextnodes = "dontprettytextnodes" in options ? options.dontprettytextnodes : 0;
                    } else {
                        this.indent = '';
                        this.newline = '';
                        this.offset = 0;
                        this.dontprettytextnodes = 0;
                    }
                    this.spacebeforeslash = "spacebeforeslash" in options ? options.spacebeforeslash : '';
                    if (this.spacebeforeslash === true) {
                        this.spacebeforeslash = ' ';
                    }
                    this.newlinedefault = this.newline;
                    this.prettydefault = this.pretty;
                    ref = options.writer || {};
                    for (key in ref) {
                        if (!hasProp.call(ref, key)) continue;
                        value = ref[key];
                        this[key] = value;
                    }
                    return this;
                };

                XMLWriterBase.prototype.space = function(level) {
                    var indent;
                    if (this.pretty) {
                        indent = (level || 0) + this.offset + 1;
                        if (indent > 0) {
                            return new Array(indent).join(this.indent);
                        } else {
                            return '';
                        }
                    } else {
                        return '';
                    }
                };

                return XMLWriterBase;

            })();

        }).call(this);

    },{}],148:[function(require,module,exports){
// Generated by CoffeeScript 1.12.7
        (function() {
            var XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;

            ref = require('./Utility'), assign = ref.assign, isFunction = ref.isFunction;

            XMLDocument = require('./XMLDocument');

            XMLDocumentCB = require('./XMLDocumentCB');

            XMLStringWriter = require('./XMLStringWriter');

            XMLStreamWriter = require('./XMLStreamWriter');

            module.exports.create = function(name, xmldec, doctype, options) {
                var doc, root;
                if (name == null) {
                    throw new Error("Root element needs a name.");
                }
                options = assign({}, xmldec, doctype, options);
                doc = new XMLDocument(options);
                root = doc.element(name);
                if (!options.headless) {
                    doc.declaration(options);
                    if ((options.pubID != null) || (options.sysID != null)) {
                        doc.doctype(options);
                    }
                }
                return root;
            };

            module.exports.begin = function(options, onData, onEnd) {
                var ref1;
                if (isFunction(options)) {
                    ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
                    options = {};
                }
                if (onData) {
                    return new XMLDocumentCB(options, onData, onEnd);
                } else {
                    return new XMLDocument(options);
                }
            };

            module.exports.stringWriter = function(options) {
                return new XMLStringWriter(options);
            };

            module.exports.streamWriter = function(stream, options) {
                return new XMLStreamWriter(stream, options);
            };

        }).call(this);

    },{"./Utility":126,"./XMLDocument":136,"./XMLDocumentCB":137,"./XMLStreamWriter":143,"./XMLStringWriter":144}]},{},[21])(21)
});


/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(exports, definition) {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/global */
/******/ 	!function() {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(exports) {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/publicPath */
/******/ 	!function() {
/******/ 		__webpack_require__.p = "";
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
!function() {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "default": function() { return /* binding */ entry_lib; }
});

;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
/* eslint-disable no-var */
// This file is imported into lib/wc client bundles.

if (typeof window !== 'undefined') {
  var currentScript = window.document.currentScript
  if (false) { var getCurrentScript; }

  var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
  if (src) {
    __webpack_require__.p = src[1] // eslint-disable-line
  }
}

// Indicate to webpack that this file can be concatenated
/* harmony default export */ var setPublicPath = (null);

;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/docx/src/main.vue?vue&type=template&id=7b838386&scoped=true&
var render = function render(){var _vm=this,_c=_vm._self._c;return _c('div',{ref:"vue-office-docx",staticClass:"vue-office-docx"})
}
var staticRenderFns = []


;// CONCATENATED MODULE: ./packages/docx/src/docx.js
const mammoth = __webpack_require__(555)

function getHtmlFromDocx(src) {
    // eslint-disable-next-line
    return new Promise((async (resolve, reject) => {
        try{
            let arrayBuffer
            if (typeof src === 'string') {
                arrayBuffer = await fetchDocx(src)
            }else if (src instanceof ArrayBuffer){
                arrayBuffer = src
            }
            mammoth.convertToHtml({arrayBuffer})
                .then(function (result) {
                    resolve(result.value)
                });
        }catch(e){
            reject(e)
        }
    }))
}

function fetchDocx(src) {
    return fetch(src).then(res => {
        return res.arrayBuffer()
    })
}

/* harmony default export */ var docx = ({
    getHtmlFromDocx
});
;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./packages/docx/src/main.vue?vue&type=script&lang=js&



/* harmony default export */ var mainvue_type_script_lang_js_ = ({
  name: "VueOfficeDocx",
  props: {
    src: [String, ArrayBuffer]
  },
  data() {
    return {
      htmlData: ''
    }
  },
  watch: {
    src: {
      handler(val) {
        if (!val) {
          this.htmlData = ''
          this.insertHtml()
          return
        }
        docx.getHtmlFromDocx(val).then(html => {
          this.htmlData = html
          this.insertHtml()
        }).catch(e => {
          this.htmlData = ''
          this.insertHtml()
          throw new Error('vue-office-docx：\n' + JSON.stringify(e))
        })
      },
      immediate: true
    }
  },
  methods: {
    insertHtml() {
      this.$refs["vue-office-docx"].innerHTML = this.htmlData
    }
  }
});

;// CONCATENATED MODULE: ./packages/docx/src/main.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_mainvue_type_script_lang_js_ = (mainvue_type_script_lang_js_); 
;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/runtime/componentNormalizer.js
/* globals __VUE_SSR_CONTEXT__ */

// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
// This module is a runtime utility for cleaner component module output and will
// be included in the final webpack user bundle.

function normalizeComponent(
  scriptExports,
  render,
  staticRenderFns,
  functionalTemplate,
  injectStyles,
  scopeId,
  moduleIdentifier /* server only */,
  shadowMode /* vue-cli only */
) {
  // Vue.extend constructor export interop
  var options =
    typeof scriptExports === 'function' ? scriptExports.options : scriptExports

  // render functions
  if (render) {
    options.render = render
    options.staticRenderFns = staticRenderFns
    options._compiled = true
  }

  // functional template
  if (functionalTemplate) {
    options.functional = true
  }

  // scopedId
  if (scopeId) {
    options._scopeId = 'data-v-' + scopeId
  }

  var hook
  if (moduleIdentifier) {
    // server build
    hook = function (context) {
      // 2.3 injection
      context =
        context || // cached call
        (this.$vnode && this.$vnode.ssrContext) || // stateful
        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
      // 2.2 with runInNewContext: true
      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
        context = __VUE_SSR_CONTEXT__
      }
      // inject component styles
      if (injectStyles) {
        injectStyles.call(this, context)
      }
      // register component module identifier for async chunk inferrence
      if (context && context._registeredComponents) {
        context._registeredComponents.add(moduleIdentifier)
      }
    }
    // used by ssr in case component is cached and beforeCreate
    // never gets called
    options._ssrRegister = hook
  } else if (injectStyles) {
    hook = shadowMode
      ? function () {
          injectStyles.call(
            this,
            (options.functional ? this.parent : this).$root.$options.shadowRoot
          )
        }
      : injectStyles
  }

  if (hook) {
    if (options.functional) {
      // for template-only hot-reload because in that case the render fn doesn't
      // go through the normalizer
      options._injectStyles = hook
      // register for functional component in vue file
      var originalRender = options.render
      options.render = function renderWithStyleInjection(h, context) {
        hook.call(context)
        return originalRender(h, context)
      }
    } else {
      // inject component registration as beforeCreate hook
      var existing = options.beforeCreate
      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]
    }
  }

  return {
    exports: scriptExports,
    options: options
  }
}

;// CONCATENATED MODULE: ./packages/docx/src/main.vue





/* normalize component */
;
var component = normalizeComponent(
  src_mainvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  "7b838386",
  null
  
)

/* harmony default export */ var main = (component.exports);
;// CONCATENATED MODULE: ./packages/docx/index.js


main.install = function (Vue) {
    Vue.component(main.name, main)
}

/* harmony default export */ var packages_docx = (main);
;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib.js


/* harmony default export */ var entry_lib = (packages_docx);


}();
module.exports = __webpack_exports__;
/******/ })()
;
//# sourceMappingURL=vue-office-docx.common.js.map