armature/es5/test.js

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.armature = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
        r = Reflect.decorate(decorators, target, key, desc);
    else
        for (var i = decorators.length - 1; i >= 0; i--)
            if (d = decorators[i])
                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var UUID_1 = require("./UUID");
var Decorators_1 = require("./Decorators");
var ComponentStore_1 = require("./ComponentStore");
var assign = require("object-assign");
/**
 * The base for all Armature components.
 */
var Component = (function () {
    /**
     * Creates a new component with the given data.
     *
     * @param data The data to initialize the component with
     */
    function Component(data) {
        /**
         * The components this component contains.
         */
        this.$children = [];
        this.$data = data;
        this.$id = UUID_1.default.get();
    }
    /**
     * Creates or retrieves a component that is attached to another component.
     * Using the same parent and 'label' parameters will retrieve the same object.
     * Pass null to the data attribute to throw if a new component is created.
     *
     * @param parent The component to attach to
     * @param label The label to use when creating or retrieving the component
     * @param data The data to initialize the component with if it hasn't been created
     */
    Component.$for = function (parent, label, data) {
        var identifier = this.$getIdentifier(label);
        var existing = parent.$children.find(function (v) { return v.$getIdentifier() === identifier; });
        if (existing) {
            return existing;
        }
        if (data === null) {
            throw new Error("Subcomponent was created with no data!");
        }
        var inst = new this(data);
        inst.$label = label;
        inst.$parent = parent;
        parent.$children.push(inst);
        return inst;
    };
    /**
     * Serializes the component's data for potential recreation.
     */
    Component.prototype.$serializeData = function () {
        return assign({}, this.$data);
    };
    /**
     * Returns a way to uniquely identify this component type.
     */
    Component.$getTypeName = function () {
        var classString = this.$classNames.map(function (v) { return "." + v; }).join("");
        return this.$tagName + classString;
    };
    /**
     * Creates an object that can be used to recreate this component.
     */
    Component.prototype.$deflate = function () {
        var thisClass = this.constructor;
        return {
            type: thisClass.$getTypeName(),
            data: this.$serializeData(),
            id: this.$id,
            label: this.$label,
            children: this.$children.map(function (v) { return v.$deflate(); })
        };
    };
    /**
     * Creates an instance of a component from data generated by $deflate.
     *
     * @param deflated The deflated component data to use
     * @param inst An optional existing object to inflate
     */
    Component.$inflate = function (deflated, inst) {
        if (!inst) {
            inst = new this(deflated.data);
        }
        inst.$id = deflated.id;
        inst.$label = deflated.label;
        if (deflated.children) {
            for (var _i = 0, _a = deflated.children; _i < _a.length; _i++) {
                var child = _a[_i];
                var thatClass = ComponentStore_1.default.get(child.type);
                var childInst = thatClass.$for(inst, child.label, child.data);
                thatClass.$inflate(child, childInst);
            }
        }
        return inst;
    };
    /**
     * Returns an identifier that should be unique among a component's siblings.
     *
     * @param label The label of the component to create the label for
     */
    Component.$getIdentifier = function (label) {
        return this.$getTypeName() + "__" + label;
    };
    /**
     * Returns an identifier that should be unique among a component's siblings.
     */
    Component.prototype.$getIdentifier = function () {
        var thisClass = this.constructor;
        return thisClass.$getIdentifier(this.$label);
    };
    Component.prototype.toString = function () {
        return this.$getHTML();
    };
    /**
     * Builds the HTML associated with this component.
     */
    Component.prototype.$getHTML = function () {
        var thisClass = this.constructor;
        return "<" + thisClass.$tagName + "\n\t\t\tclass=\"" + thisClass.$classNames.join(" ") + "\"\n\t\t\tdata-armid=\"" + this.$id + "\"\n\t\t\t" + (this.$label ? "data-label=\"" + this.$label + "\"" : "") + "\n\t\t\t>" + this.$template(this) + "</" + thisClass.$tagName + ">";
    };
    /**
     * Creates an HTML element for this component if one does not exist.
     */
    Component.prototype.$ensureElement = function () {
        if (!this.$element) {
            var thisClass = this.constructor;
            var el = document.createElement(thisClass.$tagName);
            (_a = el.classList).add.apply(_a, thisClass.$classNames);
            this.$attachTo(el);
        }
        var _a;
    };
    /**
     * Attaches this component to an existing HTML element.
     *
     * @param element The element to attach to
     */
    Component.prototype.$attachTo = function (element) {
        this.$element = element;
        element.setAttribute("data-armid", this.$id.toString());
        if (this.$label) {
            element.setAttribute("data-label", this.$label);
        }
    };
    /**
     * Attempts to locate this component's element from a parent element.
     *
     * @param parent The element to search in
     */
    Component.prototype.$locate = function (parent) {
        if (parent === void 0) {
            parent = document.body;
        }
        var thisClass = this.constructor;
        var el = parent.querySelector(thisClass.$tagName + "[data-armid=\"" + this.$id + "\"]");
        if (el) {
            this.$element = el;
            this.$children.forEach(function (child) {
                child.$locate(el);
            });
            return el;
        }
    };
    /**
     * Evaluates the component's template and puts the result into the component's element
     */
    Component.prototype.$render = function () {
        this.$element.innerHTML = this.$template(this);
    };
    /**
     * Attaches event handlers for the component and its children.
     * Often used after $render, or as part of $reify.
     */
    Component.prototype.$hydrate = function () {
        for (var _i = 0, _a = this.$children; _i < _a.length; _i++) {
            var child = _a[_i];
            if (child.$locate(this.$element)) {
                child.$hydrate();
            }
        }
    };
    /**
     * Ensures this component's element exists, then renders and hydrates it.
     */
    Component.prototype.$reify = function () {
        this.$ensureElement();
        this.$render();
        this.$hydrate();
    };
    /**
     * A list of class names to apply to the component's root element.
     */
    Component.$classNames = [];
    Component = __decorate([
        Decorators_1.TagName("arm-component"),
        Decorators_1.Template(function () { return ""; })
    ], Component);
    return Component;
}());
exports.Component = Component;


},{"./ComponentStore":2,"./Decorators":3,"./UUID":5,"object-assign":42}],2:[function(require,module,exports){
"use strict";
var ComponentStore = {
    store: new Map(),
    register: function (componentType) {
        this.store.set(componentType.$getTypeName(), componentType);
    },
    get: function (typeName) {
        return this.store.get(typeName);
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = ComponentStore;


},{}],3:[function(require,module,exports){
"use strict";
/**
 * Attaches a template to a Component
 * @param template The template to attach
 */
function Template(template) {
    return function (target) {
        target.prototype.$template = template;
    };
}
exports.Template = Template;
/**
 * Sets the HTML tag name of a Component
 * @param name The tag name to attach
 */
function TagName(name) {
    return function (target) {
        target.$tagName = name;
    };
}
exports.TagName = TagName;
/**
 * Attaches HTML class names to a Component's element
 * @param names The names to attach
 */
function ClassNames() {
    var names = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        names[_i - 0] = arguments[_i];
    }
    return function (target) {
        (_a = target.$classNames).push.apply(_a, names);
        var _a;
    };
}
exports.ClassNames = ClassNames;


},{}],4:[function(require,module,exports){
"use strict";
var ComponentStore_1 = require("./ComponentStore");
function Properties(data) {
    return function (target) {
        target.prototype.$template = data.template;
        target.$tagName = data.tag;
        if (data.classes) {
            target.$classNames = target.$classNames.concat(data.classes);
        }
        ComponentStore_1.default.register(target);
    };
}
exports.Properties = Properties;


},{"./ComponentStore":2}],5:[function(require,module,exports){
"use strict";
var randomBuffer = new Uint16Array(1);
/**
 * Returns a random number on [0, 1)
 * Uses window.crypto if available
 */
function rand() {
    if (typeof crypto !== "undefined") {
        crypto.getRandomValues(randomBuffer);
        return randomBuffer[0] / Math.pow(2, 16);
    }
    else {
        return Math.random();
    }
}
var UUID = {
    /**
     * Generates a v4 UUID.
     */
    get: function () {
        var template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
        var value = template.replace(/[xy]/g, function (c) {
            var v = Math.floor(rand() * 16);
            if (c !== "x") {
                v = v & 0x3 | 0x8;
            }
            return v.toString(16);
        });
        return value;
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = UUID;


},{}],6:[function(require,module,exports){
"use strict";
function __export(m) {
    for (var p in m)
        if (!exports.hasOwnProperty(p))
            exports[p] = m[p];
}
__export(require("./Component"));
var ComponentStore_1 = require("./ComponentStore");
exports.ComponentStore = ComponentStore_1.default;
var UUID_1 = require("./UUID");
exports.UUID = UUID_1.default;
__export(require("./Decorators"));
__export(require("./Properties"));


},{"./Component":1,"./ComponentStore":2,"./Decorators":3,"./Properties":4,"./UUID":5}],7:[function(require,module,exports){
(function (process,__filename){
/** vim: et:ts=4:sw=4:sts=4
 * @license amdefine 1.0.0 Copyright (c) 2011-2015, The Dojo Foundation All Rights Reserved.
 * Available via the MIT or new BSD license.
 * see: http://github.com/jrburke/amdefine for details
 */

/*jslint node: true */
/*global module, process */
'use strict';

/**
 * Creates a define for node.
 * @param {Object} module the "module" object that is defined by Node for the
 * current module.
 * @param {Function} [requireFn]. Node's require function for the current module.
 * It only needs to be passed in Node versions before 0.5, when module.require
 * did not exist.
 * @returns {Function} a define function that is usable for the current node
 * module.
 */
function amdefine(module, requireFn) {
    'use strict';
    var defineCache = {},
        loaderCache = {},
        alreadyCalled = false,
        path = require('path'),
        makeRequire, stringRequire;

    /**
     * Trims the . and .. from an array of path segments.
     * It will keep a leading path segment if a .. will become
     * the first path segment, to help with module name lookups,
     * which act like paths, but can be remapped. But the end result,
     * all paths that use this function should look normalized.
     * NOTE: this method MODIFIES the input array.
     * @param {Array} ary the array of path segments.
     */
    function trimDots(ary) {
        var i, part;
        for (i = 0; ary[i]; i+= 1) {
            part = ary[i];
            if (part === '.') {
                ary.splice(i, 1);
                i -= 1;
            } else if (part === '..') {
                if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
                    //End of the line. Keep at least one non-dot
                    //path segment at the front so it can be mapped
                    //correctly to disk. Otherwise, there is likely
                    //no path mapping for a path starting with '..'.
                    //This can still fail, but catches the most reasonable
                    //uses of ..
                    break;
                } else if (i > 0) {
                    ary.splice(i - 1, 2);
                    i -= 2;
                }
            }
        }
    }

    function normalize(name, baseName) {
        var baseParts;

        //Adjust any relative paths.
        if (name && name.charAt(0) === '.') {
            //If have a base name, try to normalize against it,
            //otherwise, assume it is a top-level require that will
            //be relative to baseUrl in the end.
            if (baseName) {
                baseParts = baseName.split('/');
                baseParts = baseParts.slice(0, baseParts.length - 1);
                baseParts = baseParts.concat(name.split('/'));
                trimDots(baseParts);
                name = baseParts.join('/');
            }
        }

        return name;
    }

    /**
     * Create the normalize() function passed to a loader plugin's
     * normalize method.
     */
    function makeNormalize(relName) {
        return function (name) {
            return normalize(name, relName);
        };
    }

    function makeLoad(id) {
        function load(value) {
            loaderCache[id] = value;
        }

        load.fromText = function (id, text) {
            //This one is difficult because the text can/probably uses
            //define, and any relative paths and requires should be relative
            //to that id was it would be found on disk. But this would require
            //bootstrapping a module/require fairly deeply from node core.
            //Not sure how best to go about that yet.
            throw new Error('amdefine does not implement load.fromText');
        };

        return load;
    }

    makeRequire = function (systemRequire, exports, module, relId) {
        function amdRequire(deps, callback) {
            if (typeof deps === 'string') {
                //Synchronous, single module require('')
                return stringRequire(systemRequire, exports, module, deps, relId);
            } else {
                //Array of dependencies with a callback.

                //Convert the dependencies to modules.
                deps = deps.map(function (depName) {
                    return stringRequire(systemRequire, exports, module, depName, relId);
                });

                //Wait for next tick to call back the require call.
                if (callback) {
                    process.nextTick(function () {
                        callback.apply(null, deps);
                    });
                }
            }
        }

        amdRequire.toUrl = function (filePath) {
            if (filePath.indexOf('.') === 0) {
                return normalize(filePath, path.dirname(module.filename));
            } else {
                return filePath;
            }
        };

        return amdRequire;
    };

    //Favor explicit value, passed in if the module wants to support Node 0.4.
    requireFn = requireFn || function req() {
        return module.require.apply(module, arguments);
    };

    function runFactory(id, deps, factory) {
        var r, e, m, result;

        if (id) {
            e = loaderCache[id] = {};
            m = {
                id: id,
                uri: __filename,
                exports: e
            };
            r = makeRequire(requireFn, e, m, id);
        } else {
            //Only support one define call per file
            if (alreadyCalled) {
                throw new Error('amdefine with no module ID cannot be called more than once per file.');
            }
            alreadyCalled = true;

            //Use the real variables from node
            //Use module.exports for exports, since
            //the exports in here is amdefine exports.
            e = module.exports;
            m = module;
            r = makeRequire(requireFn, e, m, module.id);
        }

        //If there are dependencies, they are strings, so need
        //to convert them to dependency values.
        if (deps) {
            deps = deps.map(function (depName) {
                return r(depName);
            });
        }

        //Call the factory with the right dependencies.
        if (typeof factory === 'function') {
            result = factory.apply(m.exports, deps);
        } else {
            result = factory;
        }

        if (result !== undefined) {
            m.exports = result;
            if (id) {
                loaderCache[id] = m.exports;
            }
        }
    }

    stringRequire = function (systemRequire, exports, module, id, relId) {
        //Split the ID by a ! so that
        var index = id.indexOf('!'),
            originalId = id,
            prefix, plugin;

        if (index === -1) {
            id = normalize(id, relId);

            //Straight module lookup. If it is one of the special dependencies,
            //deal with it, otherwise, delegate to node.
            if (id === 'require') {
                return makeRequire(systemRequire, exports, module, relId);
            } else if (id === 'exports') {
                return exports;
            } else if (id === 'module') {
                return module;
            } else if (loaderCache.hasOwnProperty(id)) {
                return loaderCache[id];
            } else if (defineCache[id]) {
                runFactory.apply(null, defineCache[id]);
                return loaderCache[id];
            } else {
                if(systemRequire) {
                    return systemRequire(originalId);
                } else {
                    throw new Error('No module with ID: ' + id);
                }
            }
        } else {
            //There is a plugin in play.
            prefix = id.substring(0, index);
            id = id.substring(index + 1, id.length);

            plugin = stringRequire(systemRequire, exports, module, prefix, relId);

            if (plugin.normalize) {
                id = plugin.normalize(id, makeNormalize(relId));
            } else {
                //Normalize the ID normally.
                id = normalize(id, relId);
            }

            if (loaderCache[id]) {
                return loaderCache[id];
            } else {
                plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {});

                return loaderCache[id];
            }
        }
    };

    //Create a define function specific to the module asking for amdefine.
    function define(id, deps, factory) {
        if (Array.isArray(id)) {
            factory = deps;
            deps = id;
            id = undefined;
        } else if (typeof id !== 'string') {
            factory = id;
            id = deps = undefined;
        }

        if (deps && !Array.isArray(deps)) {
            factory = deps;
            deps = undefined;
        }

        if (!deps) {
            deps = ['require', 'exports', 'module'];
        }

        //Set up properties for this module. If an ID, then use
        //internal cache. If no ID, then use the external variables
        //for this node module.
        if (id) {
            //Put the module in deep freeze until there is a
            //require call for it.
            defineCache[id] = [id, deps, factory];
        } else {
            runFactory(id, deps, factory);
        }
    }

    //define.require, which has access to all the values in the
    //cache. Useful for AMD modules that all have IDs in the file,
    //but need to finally export a value to node based on one of those
    //IDs.
    define.require = function (id) {
        if (loaderCache[id]) {
            return loaderCache[id];
        }

        if (defineCache[id]) {
            runFactory.apply(null, defineCache[id]);
            return loaderCache[id];
        }
    };

    define.amd = {};

    return define;
}

module.exports = amdefine;

}).call(this,require('_process'),"/node_modules/amdefine/amdefine.js")

},{"_process":67,"path":66}],8:[function(require,module,exports){
/*!
 * assertion-error
 * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>
 * MIT Licensed
 */
/*!
 * Return a function that will copy properties from
 * one object to another excluding any originally
 * listed. Returned function will create a new `{}`.
 *
 * @param {String} excluded properties ...
 * @return {Function}
 */
function exclude() {
    var excludes = [].slice.call(arguments);
    function excludeProps(res, obj) {
        Object.keys(obj).forEach(function (key) {
            if (!~excludes.indexOf(key))
                res[key] = obj[key];
        });
    }
    return function extendExclude() {
        var args = [].slice.call(arguments), i = 0, res = {};
        for (; i < args.length; i++) {
            excludeProps(res, args[i]);
        }
        return res;
    };
}
;
/*!
 * Primary Exports
 */
module.exports = AssertionError;
/**
 * ### AssertionError
 *
 * An extension of the JavaScript `Error` constructor for
 * assertion and validation scenarios.
 *
 * @param {String} message
 * @param {Object} properties to include (optional)
 * @param {callee} start stack function (optional)
 */
function AssertionError(message, _props, ssf) {
    var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON'), props = extend(_props || {});
    // default values
    this.message = message || 'Unspecified AssertionError';
    this.showDiff = false;
    // copy from properties
    for (var key in props) {
        this[key] = props[key];
    }
    // capture stack trace
    ssf = ssf || arguments.callee;
    if (ssf && Error.captureStackTrace) {
        Error.captureStackTrace(this, ssf);
    }
    else {
        this.stack = new Error().stack;
    }
}
/*!
 * Inherit from Error.prototype
 */
AssertionError.prototype = Object.create(Error.prototype);
/*!
 * Statically set name
 */
AssertionError.prototype.name = 'AssertionError';
/*!
 * Ensure correct constructor
 */
AssertionError.prototype.constructor = AssertionError;
/**
 * Allow errors to be converted to JSON for static transfer.
 *
 * @param {Boolean} include stack (default: `true`)
 * @return {Object} object that can be `JSON.stringify`
 */
AssertionError.prototype.toJSON = function (stack) {
    var extend = exclude('constructor', 'toJSON', 'stack'), props = extend({ name: this.name }, this);
    // include stack if exists and not turned off
    if (false !== stack && this.stack) {
        props.stack = this.stack;
    }
    return props;
};

},{}],9:[function(require,module,exports){
module.exports = require('./lib/chai');

},{"./lib/chai":10}],10:[function(require,module,exports){
/*!
 * chai
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
var used = [], exports = module.exports = {};
/*!
 * Chai version
 */
exports.version = '3.5.0';
/*!
 * Assertion Error
 */
exports.AssertionError = require('assertion-error');
/*!
 * Utils for plugins (not exported)
 */
var util = require('./chai/utils');
/**
 * # .use(function)
 *
 * Provides a way to extend the internals of Chai
 *
 * @param {Function}
 * @returns {this} for chaining
 * @api public
 */
exports.use = function (fn) {
    if (!~used.indexOf(fn)) {
        fn(this, util);
        used.push(fn);
    }
    return this;
};
/*!
 * Utility Functions
 */
exports.util = util;
/*!
 * Configuration
 */
var config = require('./chai/config');
exports.config = config;
/*!
 * Primary `Assertion` prototype
 */
var assertion = require('./chai/assertion');
exports.use(assertion);
/*!
 * Core Assertions
 */
var core = require('./chai/core/assertions');
exports.use(core);
/*!
 * Expect interface
 */
var expect = require('./chai/interface/expect');
exports.use(expect);
/*!
 * Should interface
 */
var should = require('./chai/interface/should');
exports.use(should);
/*!
 * Assert interface
 */
var assert = require('./chai/interface/assert');
exports.use(assert);

},{"./chai/assertion":11,"./chai/config":12,"./chai/core/assertions":13,"./chai/interface/assert":14,"./chai/interface/expect":15,"./chai/interface/should":16,"./chai/utils":30,"assertion-error":8}],11:[function(require,module,exports){
/*!
 * chai
 * http://chaijs.com
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
var config = require('./config');
module.exports = function (_chai, util) {
    /*!
     * Module dependencies.
     */
    var AssertionError = _chai.AssertionError, flag = util.flag;
    /*!
     * Module export.
     */
    _chai.Assertion = Assertion;
    /*!
     * Assertion Constructor
     *
     * Creates object for chaining.
     *
     * @api private
     */
    function Assertion(obj, msg, stack) {
        flag(this, 'ssfi', stack || arguments.callee);
        flag(this, 'object', obj);
        flag(this, 'message', msg);
    }
    Object.defineProperty(Assertion, 'includeStack', {
        get: function () {
            console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');
            return config.includeStack;
        },
        set: function (value) {
            console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');
            config.includeStack = value;
        }
    });
    Object.defineProperty(Assertion, 'showDiff', {
        get: function () {
            console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');
            return config.showDiff;
        },
        set: function (value) {
            console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');
            config.showDiff = value;
        }
    });
    Assertion.addProperty = function (name, fn) {
        util.addProperty(this.prototype, name, fn);
    };
    Assertion.addMethod = function (name, fn) {
        util.addMethod(this.prototype, name, fn);
    };
    Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
        util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
    };
    Assertion.overwriteProperty = function (name, fn) {
        util.overwriteProperty(this.prototype, name, fn);
    };
    Assertion.overwriteMethod = function (name, fn) {
        util.overwriteMethod(this.prototype, name, fn);
    };
    Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
        util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
    };
    /**
     * ### .assert(expression, message, negateMessage, expected, actual, showDiff)
     *
     * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
     *
     * @name assert
     * @param {Philosophical} expression to be tested
     * @param {String|Function} message or function that returns message to display if expression fails
     * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails
     * @param {Mixed} expected value (remember to check for negation)
     * @param {Mixed} actual (optional) will default to `this.obj`
     * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
     * @api private
     */
    Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
        var ok = util.test(this, arguments);
        if (true !== showDiff)
            showDiff = false;
        if (true !== config.showDiff)
            showDiff = false;
        if (!ok) {
            var msg = util.getMessage(this, arguments), actual = util.getActual(this, arguments);
            throw new AssertionError(msg, {
                actual: actual,
                expected: expected,
                showDiff: showDiff
            }, (config.includeStack) ? this.assert : flag(this, 'ssfi'));
        }
    };
    /*!
     * ### ._obj
     *
     * Quick reference to stored `actual` value for plugin developers.
     *
     * @api private
     */
    Object.defineProperty(Assertion.prototype, '_obj', { get: function () {
            return flag(this, 'object');
        },
        set: function (val) {
            flag(this, 'object', val);
        }
    });
};

},{"./config":12}],12:[function(require,module,exports){
module.exports = {
    /**
     * ### config.includeStack
     *
     * User configurable property, influences whether stack trace
     * is included in Assertion error message. Default of false
     * suppresses stack trace in the error message.
     *
     *     chai.config.includeStack = true;  // enable stack on error
     *
     * @param {Boolean}
     * @api public
     */
    includeStack: false,
    /**
     * ### config.showDiff
     *
     * User configurable property, influences whether or not
     * the `showDiff` flag should be included in the thrown
     * AssertionErrors. `false` will always be `false`; `true`
     * will be true when the assertion has requested a diff
     * be shown.
     *
     * @param {Boolean}
     * @api public
     */
    showDiff: true,
    /**
     * ### config.truncateThreshold
     *
     * User configurable property, sets length threshold for actual and
     * expected values in assertion errors. If this threshold is exceeded, for
     * example for large data structures, the value is replaced with something
     * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.
     *
     * Set it to zero if you want to disable truncating altogether.
     *
     * This is especially userful when doing assertions on arrays: having this
     * set to a reasonable large value makes the failure messages readily
     * inspectable.
     *
     *     chai.config.truncateThreshold = 0;  // disable truncating
     *
     * @param {Number}
     * @api public
     */
    truncateThreshold: 40
};

},{}],13:[function(require,module,exports){
/*!
 * chai
 * http://chaijs.com
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
module.exports = function (chai, _) {
    var Assertion = chai.Assertion, toString = Object.prototype.toString, flag = _.flag;
    /**
     * ### Language Chains
     *
     * The following are provided as chainable getters to
     * improve the readability of your assertions. They
     * do not provide testing capabilities unless they
     * have been overwritten by a plugin.
     *
     * **Chains**
     *
     * - to
     * - be
     * - been
     * - is
     * - that
     * - which
     * - and
     * - has
     * - have
     * - with
     * - at
     * - of
     * - same
     *
     * @name language chains
     * @namespace BDD
     * @api public
     */
    ['to', 'be', 'been',
        'is', 'and', 'has', 'have',
        'with', 'that', 'which', 'at',
        'of', 'same'].forEach(function (chain) {
        Assertion.addProperty(chain, function () {
            return this;
        });
    });
    /**
     * ### .not
     *
     * Negates any of assertions following in the chain.
     *
     *     expect(foo).to.not.equal('bar');
     *     expect(goodFn).to.not.throw(Error);
     *     expect({ foo: 'baz' }).to.have.property('foo')
     *       .and.not.equal('bar');
     *
     * @name not
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('not', function () {
        flag(this, 'negate', true);
    });
    /**
     * ### .deep
     *
     * Sets the `deep` flag, later used by the `equal` and
     * `property` assertions.
     *
     *     expect(foo).to.deep.equal({ bar: 'baz' });
     *     expect({ foo: { bar: { baz: 'quux' } } })
     *       .to.have.deep.property('foo.bar.baz', 'quux');
     *
     * `.deep.property` special characters can be escaped
     * by adding two slashes before the `.` or `[]`.
     *
     *     var deepCss = { '.link': { '[target]': 42 }};
     *     expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42);
     *
     * @name deep
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('deep', function () {
        flag(this, 'deep', true);
    });
    /**
     * ### .any
     *
     * Sets the `any` flag, (opposite of the `all` flag)
     * later used in the `keys` assertion.
     *
     *     expect(foo).to.have.any.keys('bar', 'baz');
     *
     * @name any
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('any', function () {
        flag(this, 'any', true);
        flag(this, 'all', false);
    });
    /**
     * ### .all
     *
     * Sets the `all` flag (opposite of the `any` flag)
     * later used by the `keys` assertion.
     *
     *     expect(foo).to.have.all.keys('bar', 'baz');
     *
     * @name all
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('all', function () {
        flag(this, 'all', true);
        flag(this, 'any', false);
    });
    /**
     * ### .a(type)
     *
     * The `a` and `an` assertions are aliases that can be
     * used either as language chains or to assert a value's
     * type.
     *
     *     // typeof
     *     expect('test').to.be.a('string');
     *     expect({ foo: 'bar' }).to.be.an('object');
     *     expect(null).to.be.a('null');
     *     expect(undefined).to.be.an('undefined');
     *     expect(new Error).to.be.an('error');
     *     expect(new Promise).to.be.a('promise');
     *     expect(new Float32Array()).to.be.a('float32array');
     *     expect(Symbol()).to.be.a('symbol');
     *
     *     // es6 overrides
     *     expect({[Symbol.toStringTag]:()=>'foo'}).to.be.a('foo');
     *
     *     // language chain
     *     expect(foo).to.be.an.instanceof(Foo);
     *
     * @name a
     * @alias an
     * @param {String} type
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function an(type, msg) {
        if (msg)
            flag(this, 'message', msg);
        type = type.toLowerCase();
        var obj = flag(this, 'object'), article = ~['a', 'e', 'i', 'o', 'u'].indexOf(type.charAt(0)) ? 'an ' : 'a ';
        this.assert(type === _.type(obj), 'expected #{this} to be ' + article + type, 'expected #{this} not to be ' + article + type);
    }
    Assertion.addChainableMethod('an', an);
    Assertion.addChainableMethod('a', an);
    /**
     * ### .include(value)
     *
     * The `include` and `contain` assertions can be used as either property
     * based language chains or as methods to assert the inclusion of an object
     * in an array or a substring in a string. When used as language chains,
     * they toggle the `contains` flag for the `keys` assertion.
     *
     *     expect([1,2,3]).to.include(2);
     *     expect('foobar').to.contain('foo');
     *     expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');
     *
     * @name include
     * @alias contain
     * @alias includes
     * @alias contains
     * @param {Object|String|Number} obj
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function includeChainingBehavior() {
        flag(this, 'contains', true);
    }
    function include(val, msg) {
        _.expectTypes(this, ['array', 'object', 'string']);
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        var expected = false;
        if (_.type(obj) === 'array' && _.type(val) === 'object') {
            for (var i in obj) {
                if (_.eql(obj[i], val)) {
                    expected = true;
                    break;
                }
            }
        }
        else if (_.type(val) === 'object') {
            if (!flag(this, 'negate')) {
                for (var k in val)
                    new Assertion(obj).property(k, val[k]);
                return;
            }
            var subset = {};
            for (var k in val)
                subset[k] = obj[k];
            expected = _.eql(subset, val);
        }
        else {
            expected = (obj != undefined) && ~obj.indexOf(val);
        }
        this.assert(expected, 'expected #{this} to include ' + _.inspect(val), 'expected #{this} to not include ' + _.inspect(val));
    }
    Assertion.addChainableMethod('include', include, includeChainingBehavior);
    Assertion.addChainableMethod('contain', include, includeChainingBehavior);
    Assertion.addChainableMethod('contains', include, includeChainingBehavior);
    Assertion.addChainableMethod('includes', include, includeChainingBehavior);
    /**
     * ### .ok
     *
     * Asserts that the target is truthy.
     *
     *     expect('everything').to.be.ok;
     *     expect(1).to.be.ok;
     *     expect(false).to.not.be.ok;
     *     expect(undefined).to.not.be.ok;
     *     expect(null).to.not.be.ok;
     *
     * @name ok
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('ok', function () {
        this.assert(flag(this, 'object'), 'expected #{this} to be truthy', 'expected #{this} to be falsy');
    });
    /**
     * ### .true
     *
     * Asserts that the target is `true`.
     *
     *     expect(true).to.be.true;
     *     expect(1).to.not.be.true;
     *
     * @name true
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('true', function () {
        this.assert(true === flag(this, 'object'), 'expected #{this} to be true', 'expected #{this} to be false', this.negate ? false : true);
    });
    /**
     * ### .false
     *
     * Asserts that the target is `false`.
     *
     *     expect(false).to.be.false;
     *     expect(0).to.not.be.false;
     *
     * @name false
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('false', function () {
        this.assert(false === flag(this, 'object'), 'expected #{this} to be false', 'expected #{this} to be true', this.negate ? true : false);
    });
    /**
     * ### .null
     *
     * Asserts that the target is `null`.
     *
     *     expect(null).to.be.null;
     *     expect(undefined).to.not.be.null;
     *
     * @name null
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('null', function () {
        this.assert(null === flag(this, 'object'), 'expected #{this} to be null', 'expected #{this} not to be null');
    });
    /**
     * ### .undefined
     *
     * Asserts that the target is `undefined`.
     *
     *     expect(undefined).to.be.undefined;
     *     expect(null).to.not.be.undefined;
     *
     * @name undefined
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('undefined', function () {
        this.assert(undefined === flag(this, 'object'), 'expected #{this} to be undefined', 'expected #{this} not to be undefined');
    });
    /**
     * ### .NaN
     * Asserts that the target is `NaN`.
     *
     *     expect('foo').to.be.NaN;
     *     expect(4).not.to.be.NaN;
     *
     * @name NaN
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('NaN', function () {
        this.assert(isNaN(flag(this, 'object')), 'expected #{this} to be NaN', 'expected #{this} not to be NaN');
    });
    /**
     * ### .exist
     *
     * Asserts that the target is neither `null` nor `undefined`.
     *
     *     var foo = 'hi'
     *       , bar = null
     *       , baz;
     *
     *     expect(foo).to.exist;
     *     expect(bar).to.not.exist;
     *     expect(baz).to.not.exist;
     *
     * @name exist
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('exist', function () {
        this.assert(null != flag(this, 'object'), 'expected #{this} to exist', 'expected #{this} to not exist');
    });
    /**
     * ### .empty
     *
     * Asserts that the target's length is `0`. For arrays and strings, it checks
     * the `length` property. For objects, it gets the count of
     * enumerable keys.
     *
     *     expect([]).to.be.empty;
     *     expect('').to.be.empty;
     *     expect({}).to.be.empty;
     *
     * @name empty
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('empty', function () {
        var obj = flag(this, 'object'), expected = obj;
        if (Array.isArray(obj) || 'string' === typeof object) {
            expected = obj.length;
        }
        else if (typeof obj === 'object') {
            expected = Object.keys(obj).length;
        }
        this.assert(!expected, 'expected #{this} to be empty', 'expected #{this} not to be empty');
    });
    /**
     * ### .arguments
     *
     * Asserts that the target is an arguments object.
     *
     *     function test () {
     *       expect(arguments).to.be.arguments;
     *     }
     *
     * @name arguments
     * @alias Arguments
     * @namespace BDD
     * @api public
     */
    function checkArguments() {
        var obj = flag(this, 'object'), type = Object.prototype.toString.call(obj);
        this.assert('[object Arguments]' === type, 'expected #{this} to be arguments but got ' + type, 'expected #{this} to not be arguments');
    }
    Assertion.addProperty('arguments', checkArguments);
    Assertion.addProperty('Arguments', checkArguments);
    /**
     * ### .equal(value)
     *
     * Asserts that the target is strictly equal (`===`) to `value`.
     * Alternately, if the `deep` flag is set, asserts that
     * the target is deeply equal to `value`.
     *
     *     expect('hello').to.equal('hello');
     *     expect(42).to.equal(42);
     *     expect(1).to.not.equal(true);
     *     expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });
     *     expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });
     *
     * @name equal
     * @alias equals
     * @alias eq
     * @alias deep.equal
     * @param {Mixed} value
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertEqual(val, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'deep')) {
            return this.eql(val);
        }
        else {
            this.assert(val === obj, 'expected #{this} to equal #{exp}', 'expected #{this} to not equal #{exp}', val, this._obj, true);
        }
    }
    Assertion.addMethod('equal', assertEqual);
    Assertion.addMethod('equals', assertEqual);
    Assertion.addMethod('eq', assertEqual);
    /**
     * ### .eql(value)
     *
     * Asserts that the target is deeply equal to `value`.
     *
     *     expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
     *     expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);
     *
     * @name eql
     * @alias eqls
     * @param {Mixed} value
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertEql(obj, msg) {
        if (msg)
            flag(this, 'message', msg);
        this.assert(_.eql(obj, flag(this, 'object')), 'expected #{this} to deeply equal #{exp}', 'expected #{this} to not deeply equal #{exp}', obj, this._obj, true);
    }
    Assertion.addMethod('eql', assertEql);
    Assertion.addMethod('eqls', assertEql);
    /**
     * ### .above(value)
     *
     * Asserts that the target is greater than `value`.
     *
     *     expect(10).to.be.above(5);
     *
     * Can also be used in conjunction with `length` to
     * assert a minimum length. The benefit being a
     * more informative error message than if the length
     * was supplied directly.
     *
     *     expect('foo').to.have.length.above(2);
     *     expect([ 1, 2, 3 ]).to.have.length.above(2);
     *
     * @name above
     * @alias gt
     * @alias greaterThan
     * @param {Number} value
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertAbove(n, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
            new Assertion(obj, msg).to.have.property('length');
            var len = obj.length;
            this.assert(len > n, 'expected #{this} to have a length above #{exp} but got #{act}', 'expected #{this} to not have a length above #{exp}', n, len);
        }
        else {
            this.assert(obj > n, 'expected #{this} to be above ' + n, 'expected #{this} to be at most ' + n);
        }
    }
    Assertion.addMethod('above', assertAbove);
    Assertion.addMethod('gt', assertAbove);
    Assertion.addMethod('greaterThan', assertAbove);
    /**
     * ### .least(value)
     *
     * Asserts that the target is greater than or equal to `value`.
     *
     *     expect(10).to.be.at.least(10);
     *
     * Can also be used in conjunction with `length` to
     * assert a minimum length. The benefit being a
     * more informative error message than if the length
     * was supplied directly.
     *
     *     expect('foo').to.have.length.of.at.least(2);
     *     expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);
     *
     * @name least
     * @alias gte
     * @param {Number} value
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertLeast(n, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
            new Assertion(obj, msg).to.have.property('length');
            var len = obj.length;
            this.assert(len >= n, 'expected #{this} to have a length at least #{exp} but got #{act}', 'expected #{this} to have a length below #{exp}', n, len);
        }
        else {
            this.assert(obj >= n, 'expected #{this} to be at least ' + n, 'expected #{this} to be below ' + n);
        }
    }
    Assertion.addMethod('least', assertLeast);
    Assertion.addMethod('gte', assertLeast);
    /**
     * ### .below(value)
     *
     * Asserts that the target is less than `value`.
     *
     *     expect(5).to.be.below(10);
     *
     * Can also be used in conjunction with `length` to
     * assert a maximum length. The benefit being a
     * more informative error message than if the length
     * was supplied directly.
     *
     *     expect('foo').to.have.length.below(4);
     *     expect([ 1, 2, 3 ]).to.have.length.below(4);
     *
     * @name below
     * @alias lt
     * @alias lessThan
     * @param {Number} value
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertBelow(n, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
            new Assertion(obj, msg).to.have.property('length');
            var len = obj.length;
            this.assert(len < n, 'expected #{this} to have a length below #{exp} but got #{act}', 'expected #{this} to not have a length below #{exp}', n, len);
        }
        else {
            this.assert(obj < n, 'expected #{this} to be below ' + n, 'expected #{this} to be at least ' + n);
        }
    }
    Assertion.addMethod('below', assertBelow);
    Assertion.addMethod('lt', assertBelow);
    Assertion.addMethod('lessThan', assertBelow);
    /**
     * ### .most(value)
     *
     * Asserts that the target is less than or equal to `value`.
     *
     *     expect(5).to.be.at.most(5);
     *
     * Can also be used in conjunction with `length` to
     * assert a maximum length. The benefit being a
     * more informative error message than if the length
     * was supplied directly.
     *
     *     expect('foo').to.have.length.of.at.most(4);
     *     expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);
     *
     * @name most
     * @alias lte
     * @param {Number} value
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertMost(n, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
            new Assertion(obj, msg).to.have.property('length');
            var len = obj.length;
            this.assert(len <= n, 'expected #{this} to have a length at most #{exp} but got #{act}', 'expected #{this} to have a length above #{exp}', n, len);
        }
        else {
            this.assert(obj <= n, 'expected #{this} to be at most ' + n, 'expected #{this} to be above ' + n);
        }
    }
    Assertion.addMethod('most', assertMost);
    Assertion.addMethod('lte', assertMost);
    /**
     * ### .within(start, finish)
     *
     * Asserts that the target is within a range.
     *
     *     expect(7).to.be.within(5,10);
     *
     * Can also be used in conjunction with `length` to
     * assert a length range. The benefit being a
     * more informative error message than if the length
     * was supplied directly.
     *
     *     expect('foo').to.have.length.within(2,4);
     *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);
     *
     * @name within
     * @param {Number} start lowerbound inclusive
     * @param {Number} finish upperbound inclusive
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    Assertion.addMethod('within', function (start, finish, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object'), range = start + '..' + finish;
        if (flag(this, 'doLength')) {
            new Assertion(obj, msg).to.have.property('length');
            var len = obj.length;
            this.assert(len >= start && len <= finish, 'expected #{this} to have a length within ' + range, 'expected #{this} to not have a length within ' + range);
        }
        else {
            this.assert(obj >= start && obj <= finish, 'expected #{this} to be within ' + range, 'expected #{this} to not be within ' + range);
        }
    });
    /**
     * ### .instanceof(constructor)
     *
     * Asserts that the target is an instance of `constructor`.
     *
     *     var Tea = function (name) { this.name = name; }
     *       , Chai = new Tea('chai');
     *
     *     expect(Chai).to.be.an.instanceof(Tea);
     *     expect([ 1, 2, 3 ]).to.be.instanceof(Array);
     *
     * @name instanceof
     * @param {Constructor} constructor
     * @param {String} message _optional_
     * @alias instanceOf
     * @namespace BDD
     * @api public
     */
    function assertInstanceOf(constructor, msg) {
        if (msg)
            flag(this, 'message', msg);
        var name = _.getName(constructor);
        this.assert(flag(this, 'object') instanceof constructor, 'expected #{this} to be an instance of ' + name, 'expected #{this} to not be an instance of ' + name);
    }
    ;
    Assertion.addMethod('instanceof', assertInstanceOf);
    Assertion.addMethod('instanceOf', assertInstanceOf);
    /**
     * ### .property(name, [value])
     *
     * Asserts that the target has a property `name`, optionally asserting that
     * the value of that property is strictly equal to  `value`.
     * If the `deep` flag is set, you can use dot- and bracket-notation for deep
     * references into objects and arrays.
     *
     *     // simple referencing
     *     var obj = { foo: 'bar' };
     *     expect(obj).to.have.property('foo');
     *     expect(obj).to.have.property('foo', 'bar');
     *
     *     // deep referencing
     *     var deepObj = {
     *         green: { tea: 'matcha' }
     *       , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]
     *     };
     *
     *     expect(deepObj).to.have.deep.property('green.tea', 'matcha');
     *     expect(deepObj).to.have.deep.property('teas[1]', 'matcha');
     *     expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');
     *
     * You can also use an array as the starting point of a `deep.property`
     * assertion, or traverse nested arrays.
     *
     *     var arr = [
     *         [ 'chai', 'matcha', 'konacha' ]
     *       , [ { tea: 'chai' }
     *         , { tea: 'matcha' }
     *         , { tea: 'konacha' } ]
     *     ];
     *
     *     expect(arr).to.have.deep.property('[0][1]', 'matcha');
     *     expect(arr).to.have.deep.property('[1][2].tea', 'konacha');
     *
     * Furthermore, `property` changes the subject of the assertion
     * to be the value of that property from the original object. This
     * permits for further chainable assertions on that property.
     *
     *     expect(obj).to.have.property('foo')
     *       .that.is.a('string');
     *     expect(deepObj).to.have.property('green')
     *       .that.is.an('object')
     *       .that.deep.equals({ tea: 'matcha' });
     *     expect(deepObj).to.have.property('teas')
     *       .that.is.an('array')
     *       .with.deep.property('[2]')
     *         .that.deep.equals({ tea: 'konacha' });
     *
     * Note that dots and bracket in `name` must be backslash-escaped when
     * the `deep` flag is set, while they must NOT be escaped when the `deep`
     * flag is not set.
     *
     *     // simple referencing
     *     var css = { '.link[target]': 42 };
     *     expect(css).to.have.property('.link[target]', 42);
     *
     *     // deep referencing
     *     var deepCss = { '.link': { '[target]': 42 }};
     *     expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42);
     *
     * @name property
     * @alias deep.property
     * @param {String} name
     * @param {Mixed} value (optional)
     * @param {String} message _optional_
     * @returns value of property for chaining
     * @namespace BDD
     * @api public
     */
    Assertion.addMethod('property', function (name, val, msg) {
        if (msg)
            flag(this, 'message', msg);
        var isDeep = !!flag(this, 'deep'), descriptor = isDeep ? 'deep property ' : 'property ', negate = flag(this, 'negate'), obj = flag(this, 'object'), pathInfo = isDeep ? _.getPathInfo(name, obj) : null, hasProperty = isDeep
            ? pathInfo.exists
            : _.hasProperty(name, obj), value = isDeep
            ? pathInfo.value
            : obj[name];
        if (negate && arguments.length > 1) {
            if (undefined === value) {
                msg = (msg != null) ? msg + ': ' : '';
                throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));
            }
        }
        else {
            this.assert(hasProperty, 'expected #{this} to have a ' + descriptor + _.inspect(name), 'expected #{this} to not have ' + descriptor + _.inspect(name));
        }
        if (arguments.length > 1) {
            this.assert(val === value, 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}', 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}', val, value);
        }
        flag(this, 'object', value);
    });
    /**
     * ### .ownProperty(name)
     *
     * Asserts that the target has an own property `name`.
     *
     *     expect('test').to.have.ownProperty('length');
     *
     * @name ownProperty
     * @alias haveOwnProperty
     * @param {String} name
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertOwnProperty(name, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        this.assert(obj.hasOwnProperty(name), 'expected #{this} to have own property ' + _.inspect(name), 'expected #{this} to not have own property ' + _.inspect(name));
    }
    Assertion.addMethod('ownProperty', assertOwnProperty);
    Assertion.addMethod('haveOwnProperty', assertOwnProperty);
    /**
     * ### .ownPropertyDescriptor(name[, descriptor[, message]])
     *
     * Asserts that the target has an own property descriptor `name`, that optionally matches `descriptor`.
     *
     *     expect('test').to.have.ownPropertyDescriptor('length');
     *     expect('test').to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 });
     *     expect('test').not.to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 });
     *     expect('test').ownPropertyDescriptor('length').to.have.property('enumerable', false);
     *     expect('test').ownPropertyDescriptor('length').to.have.keys('value');
     *
     * @name ownPropertyDescriptor
     * @alias haveOwnPropertyDescriptor
     * @param {String} name
     * @param {Object} descriptor _optional_
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertOwnPropertyDescriptor(name, descriptor, msg) {
        if (typeof descriptor === 'string') {
            msg = descriptor;
            descriptor = null;
        }
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
        if (actualDescriptor && descriptor) {
            this.assert(_.eql(descriptor, actualDescriptor), 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to match ' + _.inspect(descriptor) + ', got ' + _.inspect(actualDescriptor), 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to not match ' + _.inspect(descriptor), descriptor, actualDescriptor, true);
        }
        else {
            this.assert(actualDescriptor, 'expected #{this} to have an own property descriptor for ' + _.inspect(name), 'expected #{this} to not have an own property descriptor for ' + _.inspect(name));
        }
        flag(this, 'object', actualDescriptor);
    }
    Assertion.addMethod('ownPropertyDescriptor', assertOwnPropertyDescriptor);
    Assertion.addMethod('haveOwnPropertyDescriptor', assertOwnPropertyDescriptor);
    /**
     * ### .length
     *
     * Sets the `doLength` flag later used as a chain precursor to a value
     * comparison for the `length` property.
     *
     *     expect('foo').to.have.length.above(2);
     *     expect([ 1, 2, 3 ]).to.have.length.above(2);
     *     expect('foo').to.have.length.below(4);
     *     expect([ 1, 2, 3 ]).to.have.length.below(4);
     *     expect('foo').to.have.length.within(2,4);
     *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);
     *
     * *Deprecation notice:* Using `length` as an assertion will be deprecated
     * in version 2.4.0 and removed in 3.0.0. Code using the old style of
     * asserting for `length` property value using `length(value)` should be
     * switched to use `lengthOf(value)` instead.
     *
     * @name length
     * @namespace BDD
     * @api public
     */
    /**
     * ### .lengthOf(value[, message])
     *
     * Asserts that the target's `length` property has
     * the expected value.
     *
     *     expect([ 1, 2, 3]).to.have.lengthOf(3);
     *     expect('foobar').to.have.lengthOf(6);
     *
     * @name lengthOf
     * @param {Number} length
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertLengthChain() {
        flag(this, 'doLength', true);
    }
    function assertLength(n, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).to.have.property('length');
        var len = obj.length;
        this.assert(len == n, 'expected #{this} to have a length of #{exp} but got #{act}', 'expected #{this} to not have a length of #{act}', n, len);
    }
    Assertion.addChainableMethod('length', assertLength, assertLengthChain);
    Assertion.addMethod('lengthOf', assertLength);
    /**
     * ### .match(regexp)
     *
     * Asserts that the target matches a regular expression.
     *
     *     expect('foobar').to.match(/^foo/);
     *
     * @name match
     * @alias matches
     * @param {RegExp} RegularExpression
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertMatch(re, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        this.assert(re.exec(obj), 'expected #{this} to match ' + re, 'expected #{this} not to match ' + re);
    }
    Assertion.addMethod('match', assertMatch);
    Assertion.addMethod('matches', assertMatch);
    /**
     * ### .string(string)
     *
     * Asserts that the string target contains another string.
     *
     *     expect('foobar').to.have.string('bar');
     *
     * @name string
     * @param {String} string
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    Assertion.addMethod('string', function (str, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).is.a('string');
        this.assert(~obj.indexOf(str), 'expected #{this} to contain ' + _.inspect(str), 'expected #{this} to not contain ' + _.inspect(str));
    });
    /**
     * ### .keys(key1, [key2], [...])
     *
     * Asserts that the target contains any or all of the passed-in keys.
     * Use in combination with `any`, `all`, `contains`, or `have` will affect
     * what will pass.
     *
     * When used in conjunction with `any`, at least one key that is passed
     * in must exist in the target object. This is regardless whether or not
     * the `have` or `contain` qualifiers are used. Note, either `any` or `all`
     * should be used in the assertion. If neither are used, the assertion is
     * defaulted to `all`.
     *
     * When both `all` and `contain` are used, the target object must have at
     * least all of the passed-in keys but may have more keys not listed.
     *
     * When both `all` and `have` are used, the target object must both contain
     * all of the passed-in keys AND the number of keys in the target object must
     * match the number of keys passed in (in other words, a target object must
     * have all and only all of the passed-in keys).
     *
     *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz');
     *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo');
     *     expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz');
     *     expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']);
     *     expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6});
     *     expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']);
     *     expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo': 7});
     *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']);
     *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys({'bar': 6});
     *
     *
     * @name keys
     * @alias key
     * @param {...String|Array|Object} keys
     * @namespace BDD
     * @api public
     */
    function assertKeys(keys) {
        var obj = flag(this, 'object'), str, ok = true, mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments';
        switch (_.type(keys)) {
            case "array":
                if (arguments.length > 1)
                    throw (new Error(mixedArgsMsg));
                break;
            case "object":
                if (arguments.length > 1)
                    throw (new Error(mixedArgsMsg));
                keys = Object.keys(keys);
                break;
            default:
                keys = Array.prototype.slice.call(arguments);
        }
        if (!keys.length)
            throw new Error('keys required');
        var actual = Object.keys(obj), expected = keys, len = keys.length, any = flag(this, 'any'), all = flag(this, 'all');
        if (!any && !all) {
            all = true;
        }
        // Has any
        if (any) {
            var intersection = expected.filter(function (key) {
                return ~actual.indexOf(key);
            });
            ok = intersection.length > 0;
        }
        // Has all
        if (all) {
            ok = keys.every(function (key) {
                return ~actual.indexOf(key);
            });
            if (!flag(this, 'negate') && !flag(this, 'contains')) {
                ok = ok && keys.length == actual.length;
            }
        }
        // Key string
        if (len > 1) {
            keys = keys.map(function (key) {
                return _.inspect(key);
            });
            var last = keys.pop();
            if (all) {
                str = keys.join(', ') + ', and ' + last;
            }
            if (any) {
                str = keys.join(', ') + ', or ' + last;
            }
        }
        else {
            str = _.inspect(keys[0]);
        }
        // Form
        str = (len > 1 ? 'keys ' : 'key ') + str;
        // Have / include
        str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;
        // Assertion
        this.assert(ok, 'expected #{this} to ' + str, 'expected #{this} to not ' + str, expected.slice(0).sort(), actual.sort(), true);
    }
    Assertion.addMethod('keys', assertKeys);
    Assertion.addMethod('key', assertKeys);
    /**
     * ### .throw(constructor)
     *
     * Asserts that the function target will throw a specific error, or specific type of error
     * (as determined using `instanceof`), optionally with a RegExp or string inclusion test
     * for the error's message.
     *
     *     var err = new ReferenceError('This is a bad function.');
     *     var fn = function () { throw err; }
     *     expect(fn).to.throw(ReferenceError);
     *     expect(fn).to.throw(Error);
     *     expect(fn).to.throw(/bad function/);
     *     expect(fn).to.not.throw('good function');
     *     expect(fn).to.throw(ReferenceError, /bad function/);
     *     expect(fn).to.throw(err);
     *
     * Please note that when a throw expectation is negated, it will check each
     * parameter independently, starting with error constructor type. The appropriate way
     * to check for the existence of a type of error but for a message that does not match
     * is to use `and`.
     *
     *     expect(fn).to.throw(ReferenceError)
     *        .and.not.throw(/good function/);
     *
     * @name throw
     * @alias throws
     * @alias Throw
     * @param {ErrorConstructor} constructor
     * @param {String|RegExp} expected error message
     * @param {String} message _optional_
     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
     * @returns error for chaining (null if no error)
     * @namespace BDD
     * @api public
     */
    function assertThrows(constructor, errMsg, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).is.a('function');
        var thrown = false, desiredError = null, name = null, thrownError = null;
        if (arguments.length === 0) {
            errMsg = null;
            constructor = null;
        }
        else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {
            errMsg = constructor;
            constructor = null;
        }
        else if (constructor && constructor instanceof Error) {
            desiredError = constructor;
            constructor = null;
            errMsg = null;
        }
        else if (typeof constructor === 'function') {
            name = constructor.prototype.name;
            if (!name || (name === 'Error' && constructor !== Error)) {
                name = constructor.name || (new constructor()).name;
            }
        }
        else {
            constructor = null;
        }
        try {
            obj();
        }
        catch (err) {
            // first, check desired error
            if (desiredError) {
                this.assert(err === desiredError, 'expected #{this} to throw #{exp} but #{act} was thrown', 'expected #{this} to not throw #{exp}', (desiredError instanceof Error ? desiredError.toString() : desiredError), (err instanceof Error ? err.toString() : err));
                flag(this, 'object', err);
                return this;
            }
            // next, check constructor
            if (constructor) {
                this.assert(err instanceof constructor, 'expected #{this} to throw #{exp} but #{act} was thrown', 'expected #{this} to not throw #{exp} but #{act} was thrown', name, (err instanceof Error ? err.toString() : err));
                if (!errMsg) {
                    flag(this, 'object', err);
                    return this;
                }
            }
            // next, check message
            var message = 'error' === _.type(err) && "message" in err
                ? err.message
                : '' + err;
            if ((message != null) && errMsg && errMsg instanceof RegExp) {
                this.assert(errMsg.exec(message), 'expected #{this} to throw error matching #{exp} but got #{act}', 'expected #{this} to throw error not matching #{exp}', errMsg, message);
                flag(this, 'object', err);
                return this;
            }
            else if ((message != null) && errMsg && 'string' === typeof errMsg) {
                this.assert(~message.indexOf(errMsg), 'expected #{this} to throw error including #{exp} but got #{act}', 'expected #{this} to throw error not including #{act}', errMsg, message);
                flag(this, 'object', err);
                return this;
            }
            else {
                thrown = true;
                thrownError = err;
            }
        }
        var actuallyGot = '', expectedThrown = name !== null
            ? name
            : desiredError
                ? '#{exp}' //_.inspect(desiredError)
                : 'an error';
        if (thrown) {
            actuallyGot = ' but #{act} was thrown';
        }
        this.assert(thrown === true, 'expected #{this} to throw ' + expectedThrown + actuallyGot, 'expected #{this} to not throw ' + expectedThrown + actuallyGot, (desiredError instanceof Error ? desiredError.toString() : desiredError), (thrownError instanceof Error ? thrownError.toString() : thrownError));
        flag(this, 'object', thrownError);
    }
    ;
    Assertion.addMethod('throw', assertThrows);
    Assertion.addMethod('throws', assertThrows);
    Assertion.addMethod('Throw', assertThrows);
    /**
     * ### .respondTo(method)
     *
     * Asserts that the object or class target will respond to a method.
     *
     *     Klass.prototype.bar = function(){};
     *     expect(Klass).to.respondTo('bar');
     *     expect(obj).to.respondTo('bar');
     *
     * To check if a constructor will respond to a static function,
     * set the `itself` flag.
     *
     *     Klass.baz = function(){};
     *     expect(Klass).itself.to.respondTo('baz');
     *
     * @name respondTo
     * @alias respondsTo
     * @param {String} method
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function respondTo(method, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object'), itself = flag(this, 'itself'), context = ('function' === _.type(obj) && !itself)
            ? obj.prototype[method]
            : obj[method];
        this.assert('function' === typeof context, 'expected #{this} to respond to ' + _.inspect(method), 'expected #{this} to not respond to ' + _.inspect(method));
    }
    Assertion.addMethod('respondTo', respondTo);
    Assertion.addMethod('respondsTo', respondTo);
    /**
     * ### .itself
     *
     * Sets the `itself` flag, later used by the `respondTo` assertion.
     *
     *     function Foo() {}
     *     Foo.bar = function() {}
     *     Foo.prototype.baz = function() {}
     *
     *     expect(Foo).itself.to.respondTo('bar');
     *     expect(Foo).itself.not.to.respondTo('baz');
     *
     * @name itself
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('itself', function () {
        flag(this, 'itself', true);
    });
    /**
     * ### .satisfy(method)
     *
     * Asserts that the target passes a given truth test.
     *
     *     expect(1).to.satisfy(function(num) { return num > 0; });
     *
     * @name satisfy
     * @alias satisfies
     * @param {Function} matcher
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function satisfy(matcher, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        var result = matcher(obj);
        this.assert(result, 'expected #{this} to satisfy ' + _.objDisplay(matcher), 'expected #{this} to not satisfy' + _.objDisplay(matcher), this.negate ? false : true, result);
    }
    Assertion.addMethod('satisfy', satisfy);
    Assertion.addMethod('satisfies', satisfy);
    /**
     * ### .closeTo(expected, delta)
     *
     * Asserts that the target is equal `expected`, to within a +/- `delta` range.
     *
     *     expect(1.5).to.be.closeTo(1, 0.5);
     *
     * @name closeTo
     * @alias approximately
     * @param {Number} expected
     * @param {Number} delta
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function closeTo(expected, delta, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).is.a('number');
        if (_.type(expected) !== 'number' || _.type(delta) !== 'number') {
            throw new Error('the arguments to closeTo or approximately must be numbers');
        }
        this.assert(Math.abs(obj - expected) <= delta, 'expected #{this} to be close to ' + expected + ' +/- ' + delta, 'expected #{this} not to be close to ' + expected + ' +/- ' + delta);
    }
    Assertion.addMethod('closeTo', closeTo);
    Assertion.addMethod('approximately', closeTo);
    function isSubsetOf(subset, superset, cmp) {
        return subset.every(function (elem) {
            if (!cmp)
                return superset.indexOf(elem) !== -1;
            return superset.some(function (elem2) {
                return cmp(elem, elem2);
            });
        });
    }
    /**
     * ### .members(set)
     *
     * Asserts that the target is a superset of `set`,
     * or that the target and `set` have the same strictly-equal (===) members.
     * Alternately, if the `deep` flag is set, set members are compared for deep
     * equality.
     *
     *     expect([1, 2, 3]).to.include.members([3, 2]);
     *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
     *
     *     expect([4, 2]).to.have.members([2, 4]);
     *     expect([5, 2]).to.not.have.members([5, 2, 1]);
     *
     *     expect([{ id: 1 }]).to.deep.include.members([{ id: 1 }]);
     *
     * @name members
     * @param {Array} set
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    Assertion.addMethod('members', function (subset, msg) {
        if (msg)
            flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj).to.be.an('array');
        new Assertion(subset).to.be.an('array');
        var cmp = flag(this, 'deep') ? _.eql : undefined;
        if (flag(this, 'contains')) {
            return this.assert(isSubsetOf(subset, obj, cmp), 'expected #{this} to be a superset of #{act}', 'expected #{this} to not be a superset of #{act}', obj, subset);
        }
        this.assert(isSubsetOf(obj, subset, cmp) && isSubsetOf(subset, obj, cmp), 'expected #{this} to have the same members as #{act}', 'expected #{this} to not have the same members as #{act}', obj, subset);
    });
    /**
     * ### .oneOf(list)
     *
     * Assert that a value appears somewhere in the top level of array `list`.
     *
     *     expect('a').to.be.oneOf(['a', 'b', 'c']);
     *     expect(9).to.not.be.oneOf(['z']);
     *     expect([3]).to.not.be.oneOf([1, 2, [3]]);
     *
     *     var three = [3];
     *     // for object-types, contents are not compared
     *     expect(three).to.not.be.oneOf([1, 2, [3]]);
     *     // comparing references works
     *     expect(three).to.be.oneOf([1, 2, three]);
     *
     * @name oneOf
     * @param {Array<*>} list
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function oneOf(list, msg) {
        if (msg)
            flag(this, 'message', msg);
        var expected = flag(this, 'object');
        new Assertion(list).to.be.an('array');
        this.assert(list.indexOf(expected) > -1, 'expected #{this} to be one of #{exp}', 'expected #{this} to not be one of #{exp}', list, expected);
    }
    Assertion.addMethod('oneOf', oneOf);
    /**
     * ### .change(function)
     *
     * Asserts that a function changes an object property
     *
     *     var obj = { val: 10 };
     *     var fn = function() { obj.val += 3 };
     *     var noChangeFn = function() { return 'foo' + 'bar'; }
     *     expect(fn).to.change(obj, 'val');
     *     expect(noChangeFn).to.not.change(obj, 'val')
     *
     * @name change
     * @alias changes
     * @alias Change
     * @param {String} object
     * @param {String} property name
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertChanges(object, prop, msg) {
        if (msg)
            flag(this, 'message', msg);
        var fn = flag(this, 'object');
        new Assertion(object, msg).to.have.property(prop);
        new Assertion(fn).is.a('function');
        var initial = object[prop];
        fn();
        this.assert(initial !== object[prop], 'expected .' + prop + ' to change', 'expected .' + prop + ' to not change');
    }
    Assertion.addChainableMethod('change', assertChanges);
    Assertion.addChainableMethod('changes', assertChanges);
    /**
     * ### .increase(function)
     *
     * Asserts that a function increases an object property
     *
     *     var obj = { val: 10 };
     *     var fn = function() { obj.val = 15 };
     *     expect(fn).to.increase(obj, 'val');
     *
     * @name increase
     * @alias increases
     * @alias Increase
     * @param {String} object
     * @param {String} property name
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertIncreases(object, prop, msg) {
        if (msg)
            flag(this, 'message', msg);
        var fn = flag(this, 'object');
        new Assertion(object, msg).to.have.property(prop);
        new Assertion(fn).is.a('function');
        var initial = object[prop];
        fn();
        this.assert(object[prop] - initial > 0, 'expected .' + prop + ' to increase', 'expected .' + prop + ' to not increase');
    }
    Assertion.addChainableMethod('increase', assertIncreases);
    Assertion.addChainableMethod('increases', assertIncreases);
    /**
     * ### .decrease(function)
     *
     * Asserts that a function decreases an object property
     *
     *     var obj = { val: 10 };
     *     var fn = function() { obj.val = 5 };
     *     expect(fn).to.decrease(obj, 'val');
     *
     * @name decrease
     * @alias decreases
     * @alias Decrease
     * @param {String} object
     * @param {String} property name
     * @param {String} message _optional_
     * @namespace BDD
     * @api public
     */
    function assertDecreases(object, prop, msg) {
        if (msg)
            flag(this, 'message', msg);
        var fn = flag(this, 'object');
        new Assertion(object, msg).to.have.property(prop);
        new Assertion(fn).is.a('function');
        var initial = object[prop];
        fn();
        this.assert(object[prop] - initial < 0, 'expected .' + prop + ' to decrease', 'expected .' + prop + ' to not decrease');
    }
    Assertion.addChainableMethod('decrease', assertDecreases);
    Assertion.addChainableMethod('decreases', assertDecreases);
    /**
     * ### .extensible
     *
     * Asserts that the target is extensible (can have new properties added to
     * it).
     *
     *     var nonExtensibleObject = Object.preventExtensions({});
     *     var sealedObject = Object.seal({});
     *     var frozenObject = Object.freeze({});
     *
     *     expect({}).to.be.extensible;
     *     expect(nonExtensibleObject).to.not.be.extensible;
     *     expect(sealedObject).to.not.be.extensible;
     *     expect(frozenObject).to.not.be.extensible;
     *
     * @name extensible
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('extensible', function () {
        var obj = flag(this, 'object');
        // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.
        // In ES6, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return false.
        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible
        // The following provides ES6 behavior when a TypeError is thrown under ES5.
        var isExtensible;
        try {
            isExtensible = Object.isExtensible(obj);
        }
        catch (err) {
            if (err instanceof TypeError)
                isExtensible = false;
            else
                throw err;
        }
        this.assert(isExtensible, 'expected #{this} to be extensible', 'expected #{this} to not be extensible');
    });
    /**
     * ### .sealed
     *
     * Asserts that the target is sealed (cannot have new properties added to it
     * and its existing properties cannot be removed).
     *
     *     var sealedObject = Object.seal({});
     *     var frozenObject = Object.freeze({});
     *
     *     expect(sealedObject).to.be.sealed;
     *     expect(frozenObject).to.be.sealed;
     *     expect({}).to.not.be.sealed;
     *
     * @name sealed
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('sealed', function () {
        var obj = flag(this, 'object');
        // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.
        // In ES6, a non-object argument will be treated as if it was a sealed ordinary object, simply return true.
        // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed
        // The following provides ES6 behavior when a TypeError is thrown under ES5.
        var isSealed;
        try {
            isSealed = Object.isSealed(obj);
        }
        catch (err) {
            if (err instanceof TypeError)
                isSealed = true;
            else
                throw err;
        }
        this.assert(isSealed, 'expected #{this} to be sealed', 'expected #{this} to not be sealed');
    });
    /**
     * ### .frozen
     *
     * Asserts that the target is frozen (cannot have new properties added to it
     * and its existing properties cannot be modified).
     *
     *     var frozenObject = Object.freeze({});
     *
     *     expect(frozenObject).to.be.frozen;
     *     expect({}).to.not.be.frozen;
     *
     * @name frozen
     * @namespace BDD
     * @api public
     */
    Assertion.addProperty('frozen', function () {
        var obj = flag(this, 'object');
        // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.
        // In ES6, a non-object argument will be treated as if it was a frozen ordinary object, simply return true.
        // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen
        // The following provides ES6 behavior when a TypeError is thrown under ES5.
        var isFrozen;
        try {
            isFrozen = Object.isFrozen(obj);
        }
        catch (err) {
            if (err instanceof TypeError)
                isFrozen = true;
            else
                throw err;
        }
        this.assert(isFrozen, 'expected #{this} to be frozen', 'expected #{this} to not be frozen');
    });
};

},{}],14:[function(require,module,exports){
/*!
 * chai
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
module.exports = function (chai, util) {
    /*!
     * Chai dependencies.
     */
    var Assertion = chai.Assertion, flag = util.flag;
    /*!
     * Module export.
     */
    /**
     * ### assert(expression, message)
     *
     * Write your own test expressions.
     *
     *     assert('foo' !== 'bar', 'foo is not bar');
     *     assert(Array.isArray([]), 'empty arrays are arrays');
     *
     * @param {Mixed} expression to test for truthiness
     * @param {String} message to display on error
     * @name assert
     * @namespace Assert
     * @api public
     */
    var assert = chai.assert = function (express, errmsg) {
        var test = new Assertion(null, null, chai.assert);
        test.assert(express, errmsg, '[ negation message unavailable ]');
    };
    /**
     * ### .fail(actual, expected, [message], [operator])
     *
     * Throw a failure. Node.js `assert` module-compatible.
     *
     * @name fail
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @param {String} operator
     * @namespace Assert
     * @api public
     */
    assert.fail = function (actual, expected, message, operator) {
        message = message || 'assert.fail()';
        throw new chai.AssertionError(message, {
            actual: actual,
            expected: expected,
            operator: operator
        }, assert.fail);
    };
    /**
     * ### .isOk(object, [message])
     *
     * Asserts that `object` is truthy.
     *
     *     assert.isOk('everything', 'everything is ok');
     *     assert.isOk(false, 'this will fail');
     *
     * @name isOk
     * @alias ok
     * @param {Mixed} object to test
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isOk = function (val, msg) {
        new Assertion(val, msg).is.ok;
    };
    /**
     * ### .isNotOk(object, [message])
     *
     * Asserts that `object` is falsy.
     *
     *     assert.isNotOk('everything', 'this will fail');
     *     assert.isNotOk(false, 'this will pass');
     *
     * @name isNotOk
     * @alias notOk
     * @param {Mixed} object to test
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotOk = function (val, msg) {
        new Assertion(val, msg).is.not.ok;
    };
    /**
     * ### .equal(actual, expected, [message])
     *
     * Asserts non-strict equality (`==`) of `actual` and `expected`.
     *
     *     assert.equal(3, '3', '== coerces values to strings');
     *
     * @name equal
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.equal = function (act, exp, msg) {
        var test = new Assertion(act, msg, assert.equal);
        test.assert(exp == flag(test, 'object'), 'expected #{this} to equal #{exp}', 'expected #{this} to not equal #{act}', exp, act);
    };
    /**
     * ### .notEqual(actual, expected, [message])
     *
     * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
     *
     *     assert.notEqual(3, 4, 'these numbers are not equal');
     *
     * @name notEqual
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notEqual = function (act, exp, msg) {
        var test = new Assertion(act, msg, assert.notEqual);
        test.assert(exp != flag(test, 'object'), 'expected #{this} to not equal #{exp}', 'expected #{this} to equal #{act}', exp, act);
    };
    /**
     * ### .strictEqual(actual, expected, [message])
     *
     * Asserts strict equality (`===`) of `actual` and `expected`.
     *
     *     assert.strictEqual(true, true, 'these booleans are strictly equal');
     *
     * @name strictEqual
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.strictEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.equal(exp);
    };
    /**
     * ### .notStrictEqual(actual, expected, [message])
     *
     * Asserts strict inequality (`!==`) of `actual` and `expected`.
     *
     *     assert.notStrictEqual(3, '3', 'no coercion for strict equality');
     *
     * @name notStrictEqual
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notStrictEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.not.equal(exp);
    };
    /**
     * ### .deepEqual(actual, expected, [message])
     *
     * Asserts that `actual` is deeply equal to `expected`.
     *
     *     assert.deepEqual({ tea: 'green' }, { tea: 'green' });
     *
     * @name deepEqual
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.deepEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.eql(exp);
    };
    /**
     * ### .notDeepEqual(actual, expected, [message])
     *
     * Assert that `actual` is not deeply equal to `expected`.
     *
     *     assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
     *
     * @name notDeepEqual
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notDeepEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.not.eql(exp);
    };
    /**
    * ### .isAbove(valueToCheck, valueToBeAbove, [message])
    *
    * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`
    *
    *     assert.isAbove(5, 2, '5 is strictly greater than 2');
    *
    * @name isAbove
    * @param {Mixed} valueToCheck
    * @param {Mixed} valueToBeAbove
    * @param {String} message
    * @namespace Assert
    * @api public
    */
    assert.isAbove = function (val, abv, msg) {
        new Assertion(val, msg).to.be.above(abv);
    };
    /**
    * ### .isAtLeast(valueToCheck, valueToBeAtLeast, [message])
    *
    * Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast`
    *
    *     assert.isAtLeast(5, 2, '5 is greater or equal to 2');
    *     assert.isAtLeast(3, 3, '3 is greater or equal to 3');
    *
    * @name isAtLeast
    * @param {Mixed} valueToCheck
    * @param {Mixed} valueToBeAtLeast
    * @param {String} message
    * @namespace Assert
    * @api public
    */
    assert.isAtLeast = function (val, atlst, msg) {
        new Assertion(val, msg).to.be.least(atlst);
    };
    /**
    * ### .isBelow(valueToCheck, valueToBeBelow, [message])
    *
    * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`
    *
    *     assert.isBelow(3, 6, '3 is strictly less than 6');
    *
    * @name isBelow
    * @param {Mixed} valueToCheck
    * @param {Mixed} valueToBeBelow
    * @param {String} message
    * @namespace Assert
    * @api public
    */
    assert.isBelow = function (val, blw, msg) {
        new Assertion(val, msg).to.be.below(blw);
    };
    /**
    * ### .isAtMost(valueToCheck, valueToBeAtMost, [message])
    *
    * Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost`
    *
    *     assert.isAtMost(3, 6, '3 is less than or equal to 6');
    *     assert.isAtMost(4, 4, '4 is less than or equal to 4');
    *
    * @name isAtMost
    * @param {Mixed} valueToCheck
    * @param {Mixed} valueToBeAtMost
    * @param {String} message
    * @namespace Assert
    * @api public
    */
    assert.isAtMost = function (val, atmst, msg) {
        new Assertion(val, msg).to.be.most(atmst);
    };
    /**
     * ### .isTrue(value, [message])
     *
     * Asserts that `value` is true.
     *
     *     var teaServed = true;
     *     assert.isTrue(teaServed, 'the tea has been served');
     *
     * @name isTrue
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isTrue = function (val, msg) {
        new Assertion(val, msg).is['true'];
    };
    /**
     * ### .isNotTrue(value, [message])
     *
     * Asserts that `value` is not true.
     *
     *     var tea = 'tasty chai';
     *     assert.isNotTrue(tea, 'great, time for tea!');
     *
     * @name isNotTrue
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotTrue = function (val, msg) {
        new Assertion(val, msg).to.not.equal(true);
    };
    /**
     * ### .isFalse(value, [message])
     *
     * Asserts that `value` is false.
     *
     *     var teaServed = false;
     *     assert.isFalse(teaServed, 'no tea yet? hmm...');
     *
     * @name isFalse
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isFalse = function (val, msg) {
        new Assertion(val, msg).is['false'];
    };
    /**
     * ### .isNotFalse(value, [message])
     *
     * Asserts that `value` is not false.
     *
     *     var tea = 'tasty chai';
     *     assert.isNotFalse(tea, 'great, time for tea!');
     *
     * @name isNotFalse
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotFalse = function (val, msg) {
        new Assertion(val, msg).to.not.equal(false);
    };
    /**
     * ### .isNull(value, [message])
     *
     * Asserts that `value` is null.
     *
     *     assert.isNull(err, 'there was no error');
     *
     * @name isNull
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNull = function (val, msg) {
        new Assertion(val, msg).to.equal(null);
    };
    /**
     * ### .isNotNull(value, [message])
     *
     * Asserts that `value` is not null.
     *
     *     var tea = 'tasty chai';
     *     assert.isNotNull(tea, 'great, time for tea!');
     *
     * @name isNotNull
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotNull = function (val, msg) {
        new Assertion(val, msg).to.not.equal(null);
    };
    /**
     * ### .isNaN
     * Asserts that value is NaN
     *
     *    assert.isNaN('foo', 'foo is NaN');
     *
     * @name isNaN
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNaN = function (val, msg) {
        new Assertion(val, msg).to.be.NaN;
    };
    /**
     * ### .isNotNaN
     * Asserts that value is not NaN
     *
     *    assert.isNotNaN(4, '4 is not NaN');
     *
     * @name isNotNaN
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotNaN = function (val, msg) {
        new Assertion(val, msg).not.to.be.NaN;
    };
    /**
     * ### .isUndefined(value, [message])
     *
     * Asserts that `value` is `undefined`.
     *
     *     var tea;
     *     assert.isUndefined(tea, 'no tea defined');
     *
     * @name isUndefined
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isUndefined = function (val, msg) {
        new Assertion(val, msg).to.equal(undefined);
    };
    /**
     * ### .isDefined(value, [message])
     *
     * Asserts that `value` is not `undefined`.
     *
     *     var tea = 'cup of chai';
     *     assert.isDefined(tea, 'tea has been defined');
     *
     * @name isDefined
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isDefined = function (val, msg) {
        new Assertion(val, msg).to.not.equal(undefined);
    };
    /**
     * ### .isFunction(value, [message])
     *
     * Asserts that `value` is a function.
     *
     *     function serveTea() { return 'cup of tea'; };
     *     assert.isFunction(serveTea, 'great, we can have tea now');
     *
     * @name isFunction
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isFunction = function (val, msg) {
        new Assertion(val, msg).to.be.a('function');
    };
    /**
     * ### .isNotFunction(value, [message])
     *
     * Asserts that `value` is _not_ a function.
     *
     *     var serveTea = [ 'heat', 'pour', 'sip' ];
     *     assert.isNotFunction(serveTea, 'great, we have listed the steps');
     *
     * @name isNotFunction
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotFunction = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('function');
    };
    /**
     * ### .isObject(value, [message])
     *
     * Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`).
     * _The assertion does not match subclassed objects._
     *
     *     var selection = { name: 'Chai', serve: 'with spices' };
     *     assert.isObject(selection, 'tea selection is an object');
     *
     * @name isObject
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isObject = function (val, msg) {
        new Assertion(val, msg).to.be.a('object');
    };
    /**
     * ### .isNotObject(value, [message])
     *
     * Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`).
     *
     *     var selection = 'chai'
     *     assert.isNotObject(selection, 'tea selection is not an object');
     *     assert.isNotObject(null, 'null is not an object');
     *
     * @name isNotObject
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotObject = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('object');
    };
    /**
     * ### .isArray(value, [message])
     *
     * Asserts that `value` is an array.
     *
     *     var menu = [ 'green', 'chai', 'oolong' ];
     *     assert.isArray(menu, 'what kind of tea do we want?');
     *
     * @name isArray
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isArray = function (val, msg) {
        new Assertion(val, msg).to.be.an('array');
    };
    /**
     * ### .isNotArray(value, [message])
     *
     * Asserts that `value` is _not_ an array.
     *
     *     var menu = 'green|chai|oolong';
     *     assert.isNotArray(menu, 'what kind of tea do we want?');
     *
     * @name isNotArray
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotArray = function (val, msg) {
        new Assertion(val, msg).to.not.be.an('array');
    };
    /**
     * ### .isString(value, [message])
     *
     * Asserts that `value` is a string.
     *
     *     var teaOrder = 'chai';
     *     assert.isString(teaOrder, 'order placed');
     *
     * @name isString
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isString = function (val, msg) {
        new Assertion(val, msg).to.be.a('string');
    };
    /**
     * ### .isNotString(value, [message])
     *
     * Asserts that `value` is _not_ a string.
     *
     *     var teaOrder = 4;
     *     assert.isNotString(teaOrder, 'order placed');
     *
     * @name isNotString
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotString = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('string');
    };
    /**
     * ### .isNumber(value, [message])
     *
     * Asserts that `value` is a number.
     *
     *     var cups = 2;
     *     assert.isNumber(cups, 'how many cups');
     *
     * @name isNumber
     * @param {Number} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNumber = function (val, msg) {
        new Assertion(val, msg).to.be.a('number');
    };
    /**
     * ### .isNotNumber(value, [message])
     *
     * Asserts that `value` is _not_ a number.
     *
     *     var cups = '2 cups please';
     *     assert.isNotNumber(cups, 'how many cups');
     *
     * @name isNotNumber
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotNumber = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('number');
    };
    /**
     * ### .isBoolean(value, [message])
     *
     * Asserts that `value` is a boolean.
     *
     *     var teaReady = true
     *       , teaServed = false;
     *
     *     assert.isBoolean(teaReady, 'is the tea ready');
     *     assert.isBoolean(teaServed, 'has tea been served');
     *
     * @name isBoolean
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isBoolean = function (val, msg) {
        new Assertion(val, msg).to.be.a('boolean');
    };
    /**
     * ### .isNotBoolean(value, [message])
     *
     * Asserts that `value` is _not_ a boolean.
     *
     *     var teaReady = 'yep'
     *       , teaServed = 'nope';
     *
     *     assert.isNotBoolean(teaReady, 'is the tea ready');
     *     assert.isNotBoolean(teaServed, 'has tea been served');
     *
     * @name isNotBoolean
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.isNotBoolean = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('boolean');
    };
    /**
     * ### .typeOf(value, name, [message])
     *
     * Asserts that `value`'s type is `name`, as determined by
     * `Object.prototype.toString`.
     *
     *     assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
     *     assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
     *     assert.typeOf('tea', 'string', 'we have a string');
     *     assert.typeOf(/tea/, 'regexp', 'we have a regular expression');
     *     assert.typeOf(null, 'null', 'we have a null');
     *     assert.typeOf(undefined, 'undefined', 'we have an undefined');
     *
     * @name typeOf
     * @param {Mixed} value
     * @param {String} name
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.typeOf = function (val, type, msg) {
        new Assertion(val, msg).to.be.a(type);
    };
    /**
     * ### .notTypeOf(value, name, [message])
     *
     * Asserts that `value`'s type is _not_ `name`, as determined by
     * `Object.prototype.toString`.
     *
     *     assert.notTypeOf('tea', 'number', 'strings are not numbers');
     *
     * @name notTypeOf
     * @param {Mixed} value
     * @param {String} typeof name
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notTypeOf = function (val, type, msg) {
        new Assertion(val, msg).to.not.be.a(type);
    };
    /**
     * ### .instanceOf(object, constructor, [message])
     *
     * Asserts that `value` is an instance of `constructor`.
     *
     *     var Tea = function (name) { this.name = name; }
     *       , chai = new Tea('chai');
     *
     *     assert.instanceOf(chai, Tea, 'chai is an instance of tea');
     *
     * @name instanceOf
     * @param {Object} object
     * @param {Constructor} constructor
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.instanceOf = function (val, type, msg) {
        new Assertion(val, msg).to.be.instanceOf(type);
    };
    /**
     * ### .notInstanceOf(object, constructor, [message])
     *
     * Asserts `value` is not an instance of `constructor`.
     *
     *     var Tea = function (name) { this.name = name; }
     *       , chai = new String('chai');
     *
     *     assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');
     *
     * @name notInstanceOf
     * @param {Object} object
     * @param {Constructor} constructor
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notInstanceOf = function (val, type, msg) {
        new Assertion(val, msg).to.not.be.instanceOf(type);
    };
    /**
     * ### .include(haystack, needle, [message])
     *
     * Asserts that `haystack` includes `needle`. Works
     * for strings and arrays.
     *
     *     assert.include('foobar', 'bar', 'foobar contains string "bar"');
     *     assert.include([ 1, 2, 3 ], 3, 'array contains value');
     *
     * @name include
     * @param {Array|String} haystack
     * @param {Mixed} needle
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.include = function (exp, inc, msg) {
        new Assertion(exp, msg, assert.include).include(inc);
    };
    /**
     * ### .notInclude(haystack, needle, [message])
     *
     * Asserts that `haystack` does not include `needle`. Works
     * for strings and arrays.
     *
     *     assert.notInclude('foobar', 'baz', 'string not include substring');
     *     assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value');
     *
     * @name notInclude
     * @param {Array|String} haystack
     * @param {Mixed} needle
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notInclude = function (exp, inc, msg) {
        new Assertion(exp, msg, assert.notInclude).not.include(inc);
    };
    /**
     * ### .match(value, regexp, [message])
     *
     * Asserts that `value` matches the regular expression `regexp`.
     *
     *     assert.match('foobar', /^foo/, 'regexp matches');
     *
     * @name match
     * @param {Mixed} value
     * @param {RegExp} regexp
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.match = function (exp, re, msg) {
        new Assertion(exp, msg).to.match(re);
    };
    /**
     * ### .notMatch(value, regexp, [message])
     *
     * Asserts that `value` does not match the regular expression `regexp`.
     *
     *     assert.notMatch('foobar', /^foo/, 'regexp does not match');
     *
     * @name notMatch
     * @param {Mixed} value
     * @param {RegExp} regexp
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notMatch = function (exp, re, msg) {
        new Assertion(exp, msg).to.not.match(re);
    };
    /**
     * ### .property(object, property, [message])
     *
     * Asserts that `object` has a property named by `property`.
     *
     *     assert.property({ tea: { green: 'matcha' }}, 'tea');
     *
     * @name property
     * @param {Object} object
     * @param {String} property
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.property = function (obj, prop, msg) {
        new Assertion(obj, msg).to.have.property(prop);
    };
    /**
     * ### .notProperty(object, property, [message])
     *
     * Asserts that `object` does _not_ have a property named by `property`.
     *
     *     assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');
     *
     * @name notProperty
     * @param {Object} object
     * @param {String} property
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notProperty = function (obj, prop, msg) {
        new Assertion(obj, msg).to.not.have.property(prop);
    };
    /**
     * ### .deepProperty(object, property, [message])
     *
     * Asserts that `object` has a property named by `property`, which can be a
     * string using dot- and bracket-notation for deep reference.
     *
     *     assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green');
     *
     * @name deepProperty
     * @param {Object} object
     * @param {String} property
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.deepProperty = function (obj, prop, msg) {
        new Assertion(obj, msg).to.have.deep.property(prop);
    };
    /**
     * ### .notDeepProperty(object, property, [message])
     *
     * Asserts that `object` does _not_ have a property named by `property`, which
     * can be a string using dot- and bracket-notation for deep reference.
     *
     *     assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
     *
     * @name notDeepProperty
     * @param {Object} object
     * @param {String} property
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.notDeepProperty = function (obj, prop, msg) {
        new Assertion(obj, msg).to.not.have.deep.property(prop);
    };
    /**
     * ### .propertyVal(object, property, value, [message])
     *
     * Asserts that `object` has a property named by `property` with value given
     * by `value`.
     *
     *     assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
     *
     * @name propertyVal
     * @param {Object} object
     * @param {String} property
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.propertyVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.have.property(prop, val);
    };
    /**
     * ### .propertyNotVal(object, property, value, [message])
     *
     * Asserts that `object` has a property named by `property`, but with a value
     * different from that given by `value`.
     *
     *     assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad');
     *
     * @name propertyNotVal
     * @param {Object} object
     * @param {String} property
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.propertyNotVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.not.have.property(prop, val);
    };
    /**
     * ### .deepPropertyVal(object, property, value, [message])
     *
     * Asserts that `object` has a property named by `property` with value given
     * by `value`. `property` can use dot- and bracket-notation for deep
     * reference.
     *
     *     assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
     *
     * @name deepPropertyVal
     * @param {Object} object
     * @param {String} property
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.deepPropertyVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.have.deep.property(prop, val);
    };
    /**
     * ### .deepPropertyNotVal(object, property, value, [message])
     *
     * Asserts that `object` has a property named by `property`, but with a value
     * different from that given by `value`. `property` can use dot- and
     * bracket-notation for deep reference.
     *
     *     assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
     *
     * @name deepPropertyNotVal
     * @param {Object} object
     * @param {String} property
     * @param {Mixed} value
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.deepPropertyNotVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.not.have.deep.property(prop, val);
    };
    /**
     * ### .lengthOf(object, length, [message])
     *
     * Asserts that `object` has a `length` property with the expected value.
     *
     *     assert.lengthOf([1,2,3], 3, 'array has length of 3');
     *     assert.lengthOf('foobar', 6, 'string has length of 6');
     *
     * @name lengthOf
     * @param {Mixed} object
     * @param {Number} length
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.lengthOf = function (exp, len, msg) {
        new Assertion(exp, msg).to.have.length(len);
    };
    /**
     * ### .throws(function, [constructor/string/regexp], [string/regexp], [message])
     *
     * Asserts that `function` will throw an error that is an instance of
     * `constructor`, or alternately that it will throw an error with message
     * matching `regexp`.
     *
     *     assert.throws(fn, 'function throws a reference error');
     *     assert.throws(fn, /function throws a reference error/);
     *     assert.throws(fn, ReferenceError);
     *     assert.throws(fn, ReferenceError, 'function throws a reference error');
     *     assert.throws(fn, ReferenceError, /function throws a reference error/);
     *
     * @name throws
     * @alias throw
     * @alias Throw
     * @param {Function} function
     * @param {ErrorConstructor} constructor
     * @param {RegExp} regexp
     * @param {String} message
     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
     * @namespace Assert
     * @api public
     */
    assert.throws = function (fn, errt, errs, msg) {
        if ('string' === typeof errt || errt instanceof RegExp) {
            errs = errt;
            errt = null;
        }
        var assertErr = new Assertion(fn, msg).to.throw(errt, errs);
        return flag(assertErr, 'object');
    };
    /**
     * ### .doesNotThrow(function, [constructor/regexp], [message])
     *
     * Asserts that `function` will _not_ throw an error that is an instance of
     * `constructor`, or alternately that it will not throw an error with message
     * matching `regexp`.
     *
     *     assert.doesNotThrow(fn, Error, 'function does not throw');
     *
     * @name doesNotThrow
     * @param {Function} function
     * @param {ErrorConstructor} constructor
     * @param {RegExp} regexp
     * @param {String} message
     * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
     * @namespace Assert
     * @api public
     */
    assert.doesNotThrow = function (fn, type, msg) {
        if ('string' === typeof type) {
            msg = type;
            type = null;
        }
        new Assertion(fn, msg).to.not.Throw(type);
    };
    /**
     * ### .operator(val1, operator, val2, [message])
     *
     * Compares two values using `operator`.
     *
     *     assert.operator(1, '<', 2, 'everything is ok');
     *     assert.operator(1, '>', 2, 'this will fail');
     *
     * @name operator
     * @param {Mixed} val1
     * @param {String} operator
     * @param {Mixed} val2
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.operator = function (val, operator, val2, msg) {
        var ok;
        switch (operator) {
            case '==':
                ok = val == val2;
                break;
            case '===':
                ok = val === val2;
                break;
            case '>':
                ok = val > val2;
                break;
            case '>=':
                ok = val >= val2;
                break;
            case '<':
                ok = val < val2;
                break;
            case '<=':
                ok = val <= val2;
                break;
            case '!=':
                ok = val != val2;
                break;
            case '!==':
                ok = val !== val2;
                break;
            default:
                throw new Error('Invalid operator "' + operator + '"');
        }
        var test = new Assertion(ok, msg);
        test.assert(true === flag(test, 'object'), 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2), 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2));
    };
    /**
     * ### .closeTo(actual, expected, delta, [message])
     *
     * Asserts that the target is equal `expected`, to within a +/- `delta` range.
     *
     *     assert.closeTo(1.5, 1, 0.5, 'numbers are close');
     *
     * @name closeTo
     * @param {Number} actual
     * @param {Number} expected
     * @param {Number} delta
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.closeTo = function (act, exp, delta, msg) {
        new Assertion(act, msg).to.be.closeTo(exp, delta);
    };
    /**
     * ### .approximately(actual, expected, delta, [message])
     *
     * Asserts that the target is equal `expected`, to within a +/- `delta` range.
     *
     *     assert.approximately(1.5, 1, 0.5, 'numbers are close');
     *
     * @name approximately
     * @param {Number} actual
     * @param {Number} expected
     * @param {Number} delta
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.approximately = function (act, exp, delta, msg) {
        new Assertion(act, msg).to.be.approximately(exp, delta);
    };
    /**
     * ### .sameMembers(set1, set2, [message])
     *
     * Asserts that `set1` and `set2` have the same members.
     * Order is not taken into account.
     *
     *     assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
     *
     * @name sameMembers
     * @param {Array} set1
     * @param {Array} set2
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.sameMembers = function (set1, set2, msg) {
        new Assertion(set1, msg).to.have.same.members(set2);
    };
    /**
     * ### .sameDeepMembers(set1, set2, [message])
     *
     * Asserts that `set1` and `set2` have the same members - using a deep equality checking.
     * Order is not taken into account.
     *
     *     assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members');
     *
     * @name sameDeepMembers
     * @param {Array} set1
     * @param {Array} set2
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.sameDeepMembers = function (set1, set2, msg) {
        new Assertion(set1, msg).to.have.same.deep.members(set2);
    };
    /**
     * ### .includeMembers(superset, subset, [message])
     *
     * Asserts that `subset` is included in `superset`.
     * Order is not taken into account.
     *
     *     assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members');
     *
     * @name includeMembers
     * @param {Array} superset
     * @param {Array} subset
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.includeMembers = function (superset, subset, msg) {
        new Assertion(superset, msg).to.include.members(subset);
    };
    /**
     * ### .includeDeepMembers(superset, subset, [message])
     *
     * Asserts that `subset` is included in `superset` - using deep equality checking.
     * Order is not taken into account.
     * Duplicates are ignored.
     *
     *     assert.includeDeepMembers([ {a: 1}, {b: 2}, {c: 3} ], [ {b: 2}, {a: 1}, {b: 2} ], 'include deep members');
     *
     * @name includeDeepMembers
     * @param {Array} superset
     * @param {Array} subset
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.includeDeepMembers = function (superset, subset, msg) {
        new Assertion(superset, msg).to.include.deep.members(subset);
    };
    /**
     * ### .oneOf(inList, list, [message])
     *
     * Asserts that non-object, non-array value `inList` appears in the flat array `list`.
     *
     *     assert.oneOf(1, [ 2, 1 ], 'Not found in list');
     *
     * @name oneOf
     * @param {*} inList
     * @param {Array<*>} list
     * @param {String} message
     * @namespace Assert
     * @api public
     */
    assert.oneOf = function (inList, list, msg) {
        new Assertion(inList, msg).to.be.oneOf(list);
    };
    /**
    * ### .changes(function, object, property)
    *
    * Asserts that a function changes the value of a property
    *
    *     var obj = { val: 10 };
    *     var fn = function() { obj.val = 22 };
    *     assert.changes(fn, obj, 'val');
    *
    * @name changes
    * @param {Function} modifier function
    * @param {Object} object
    * @param {String} property name
    * @param {String} message _optional_
    * @namespace Assert
    * @api public
    */
    assert.changes = function (fn, obj, prop) {
        new Assertion(fn).to.change(obj, prop);
    };
    /**
    * ### .doesNotChange(function, object, property)
    *
    * Asserts that a function does not changes the value of a property
    *
    *     var obj = { val: 10 };
    *     var fn = function() { console.log('foo'); };
    *     assert.doesNotChange(fn, obj, 'val');
    *
    * @name doesNotChange
    * @param {Function} modifier function
    * @param {Object} object
    * @param {String} property name
    * @param {String} message _optional_
    * @namespace Assert
    * @api public
    */
    assert.doesNotChange = function (fn, obj, prop) {
        new Assertion(fn).to.not.change(obj, prop);
    };
    /**
    * ### .increases(function, object, property)
    *
    * Asserts that a function increases an object property
    *
    *     var obj = { val: 10 };
    *     var fn = function() { obj.val = 13 };
    *     assert.increases(fn, obj, 'val');
    *
    * @name increases
    * @param {Function} modifier function
    * @param {Object} object
    * @param {String} property name
    * @param {String} message _optional_
    * @namespace Assert
    * @api public
    */
    assert.increases = function (fn, obj, prop) {
        new Assertion(fn).to.increase(obj, prop);
    };
    /**
    * ### .doesNotIncrease(function, object, property)
    *
    * Asserts that a function does not increase object property
    *
    *     var obj = { val: 10 };
    *     var fn = function() { obj.val = 8 };
    *     assert.doesNotIncrease(fn, obj, 'val');
    *
    * @name doesNotIncrease
    * @param {Function} modifier function
    * @param {Object} object
    * @param {String} property name
    * @param {String} message _optional_
    * @namespace Assert
    * @api public
    */
    assert.doesNotIncrease = function (fn, obj, prop) {
        new Assertion(fn).to.not.increase(obj, prop);
    };
    /**
    * ### .decreases(function, object, property)
    *
    * Asserts that a function decreases an object property
    *
    *     var obj = { val: 10 };
    *     var fn = function() { obj.val = 5 };
    *     assert.decreases(fn, obj, 'val');
    *
    * @name decreases
    * @param {Function} modifier function
    * @param {Object} object
    * @param {String} property name
    * @param {String} message _optional_
    * @namespace Assert
    * @api public
    */
    assert.decreases = function (fn, obj, prop) {
        new Assertion(fn).to.decrease(obj, prop);
    };
    /**
    * ### .doesNotDecrease(function, object, property)
    *
    * Asserts that a function does not decreases an object property
    *
    *     var obj = { val: 10 };
    *     var fn = function() { obj.val = 15 };
    *     assert.doesNotDecrease(fn, obj, 'val');
    *
    * @name doesNotDecrease
    * @param {Function} modifier function
    * @param {Object} object
    * @param {String} property name
    * @param {String} message _optional_
    * @namespace Assert
    * @api public
    */
    assert.doesNotDecrease = function (fn, obj, prop) {
        new Assertion(fn).to.not.decrease(obj, prop);
    };
    /*!
     * ### .ifError(object)
     *
     * Asserts if value is not a false value, and throws if it is a true value.
     * This is added to allow for chai to be a drop-in replacement for Node's
     * assert class.
     *
     *     var err = new Error('I am a custom error');
     *     assert.ifError(err); // Rethrows err!
     *
     * @name ifError
     * @param {Object} object
     * @namespace Assert
     * @api public
     */
    assert.ifError = function (val) {
        if (val) {
            throw (val);
        }
    };
    /**
     * ### .isExtensible(object)
     *
     * Asserts that `object` is extensible (can have new properties added to it).
     *
     *     assert.isExtensible({});
     *
     * @name isExtensible
     * @alias extensible
     * @param {Object} object
     * @param {String} message _optional_
     * @namespace Assert
     * @api public
     */
    assert.isExtensible = function (obj, msg) {
        new Assertion(obj, msg).to.be.extensible;
    };
    /**
     * ### .isNotExtensible(object)
     *
     * Asserts that `object` is _not_ extensible.
     *
     *     var nonExtensibleObject = Object.preventExtensions({});
     *     var sealedObject = Object.seal({});
     *     var frozenObject = Object.freese({});
     *
     *     assert.isNotExtensible(nonExtensibleObject);
     *     assert.isNotExtensible(sealedObject);
     *     assert.isNotExtensible(frozenObject);
     *
     * @name isNotExtensible
     * @alias notExtensible
     * @param {Object} object
     * @param {String} message _optional_
     * @namespace Assert
     * @api public
     */
    assert.isNotExtensible = function (obj, msg) {
        new Assertion(obj, msg).to.not.be.extensible;
    };
    /**
     * ### .isSealed(object)
     *
     * Asserts that `object` is sealed (cannot have new properties added to it
     * and its existing properties cannot be removed).
     *
     *     var sealedObject = Object.seal({});
     *     var frozenObject = Object.seal({});
     *
     *     assert.isSealed(sealedObject);
     *     assert.isSealed(frozenObject);
     *
     * @name isSealed
     * @alias sealed
     * @param {Object} object
     * @param {String} message _optional_
     * @namespace Assert
     * @api public
     */
    assert.isSealed = function (obj, msg) {
        new Assertion(obj, msg).to.be.sealed;
    };
    /**
     * ### .isNotSealed(object)
     *
     * Asserts that `object` is _not_ sealed.
     *
     *     assert.isNotSealed({});
     *
     * @name isNotSealed
     * @alias notSealed
     * @param {Object} object
     * @param {String} message _optional_
     * @namespace Assert
     * @api public
     */
    assert.isNotSealed = function (obj, msg) {
        new Assertion(obj, msg).to.not.be.sealed;
    };
    /**
     * ### .isFrozen(object)
     *
     * Asserts that `object` is frozen (cannot have new properties added to it
     * and its existing properties cannot be modified).
     *
     *     var frozenObject = Object.freeze({});
     *     assert.frozen(frozenObject);
     *
     * @name isFrozen
     * @alias frozen
     * @param {Object} object
     * @param {String} message _optional_
     * @namespace Assert
     * @api public
     */
    assert.isFrozen = function (obj, msg) {
        new Assertion(obj, msg).to.be.frozen;
    };
    /**
     * ### .isNotFrozen(object)
     *
     * Asserts that `object` is _not_ frozen.
     *
     *     assert.isNotFrozen({});
     *
     * @name isNotFrozen
     * @alias notFrozen
     * @param {Object} object
     * @param {String} message _optional_
     * @namespace Assert
     * @api public
     */
    assert.isNotFrozen = function (obj, msg) {
        new Assertion(obj, msg).to.not.be.frozen;
    };
    /*!
     * Aliases.
     */
    (function alias(name, as) {
        assert[as] = assert[name];
        return alias;
    })('isOk', 'ok')('isNotOk', 'notOk')('throws', 'throw')('throws', 'Throw')('isExtensible', 'extensible')('isNotExtensible', 'notExtensible')('isSealed', 'sealed')('isNotSealed', 'notSealed')('isFrozen', 'frozen')('isNotFrozen', 'notFrozen');
};

},{}],15:[function(require,module,exports){
/*!
 * chai
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
module.exports = function (chai, util) {
    chai.expect = function (val, message) {
        return new chai.Assertion(val, message);
    };
    /**
     * ### .fail(actual, expected, [message], [operator])
     *
     * Throw a failure.
     *
     * @name fail
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @param {String} operator
     * @namespace Expect
     * @api public
     */
    chai.expect.fail = function (actual, expected, message, operator) {
        message = message || 'expect.fail()';
        throw new chai.AssertionError(message, {
            actual: actual,
            expected: expected,
            operator: operator
        }, chai.expect.fail);
    };
};

},{}],16:[function(require,module,exports){
/*!
 * chai
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
module.exports = function (chai, util) {
    var Assertion = chai.Assertion;
    function loadShould() {
        // explicitly define this method as function as to have it's name to include as `ssfi`
        function shouldGetter() {
            if (this instanceof String || this instanceof Number || this instanceof Boolean) {
                return new Assertion(this.valueOf(), null, shouldGetter);
            }
            return new Assertion(this, null, shouldGetter);
        }
        function shouldSetter(value) {
            // See https://github.com/chaijs/chai/issues/86: this makes
            // `whatever.should = someValue` actually set `someValue`, which is
            // especially useful for `global.should = require('chai').should()`.
            //
            // Note that we have to use [[DefineProperty]] instead of [[Put]]
            // since otherwise we would trigger this very setter!
            Object.defineProperty(this, 'should', {
                value: value,
                enumerable: true,
                configurable: true,
                writable: true
            });
        }
        // modify Object.prototype to have `should`
        Object.defineProperty(Object.prototype, 'should', {
            set: shouldSetter,
            get: shouldGetter,
            configurable: true
        });
        var should = {};
        /**
         * ### .fail(actual, expected, [message], [operator])
         *
         * Throw a failure.
         *
         * @name fail
         * @param {Mixed} actual
         * @param {Mixed} expected
         * @param {String} message
         * @param {String} operator
         * @namespace Should
         * @api public
         */
        should.fail = function (actual, expected, message, operator) {
            message = message || 'should.fail()';
            throw new chai.AssertionError(message, {
                actual: actual,
                expected: expected,
                operator: operator
            }, should.fail);
        };
        /**
         * ### .equal(actual, expected, [message])
         *
         * Asserts non-strict equality (`==`) of `actual` and `expected`.
         *
         *     should.equal(3, '3', '== coerces values to strings');
         *
         * @name equal
         * @param {Mixed} actual
         * @param {Mixed} expected
         * @param {String} message
         * @namespace Should
         * @api public
         */
        should.equal = function (val1, val2, msg) {
            new Assertion(val1, msg).to.equal(val2);
        };
        /**
         * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
         *
         * Asserts that `function` will throw an error that is an instance of
         * `constructor`, or alternately that it will throw an error with message
         * matching `regexp`.
         *
         *     should.throw(fn, 'function throws a reference error');
         *     should.throw(fn, /function throws a reference error/);
         *     should.throw(fn, ReferenceError);
         *     should.throw(fn, ReferenceError, 'function throws a reference error');
         *     should.throw(fn, ReferenceError, /function throws a reference error/);
         *
         * @name throw
         * @alias Throw
         * @param {Function} function
         * @param {ErrorConstructor} constructor
         * @param {RegExp} regexp
         * @param {String} message
         * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
         * @namespace Should
         * @api public
         */
        should.Throw = function (fn, errt, errs, msg) {
            new Assertion(fn, msg).to.Throw(errt, errs);
        };
        /**
         * ### .exist
         *
         * Asserts that the target is neither `null` nor `undefined`.
         *
         *     var foo = 'hi';
         *
         *     should.exist(foo, 'foo exists');
         *
         * @name exist
         * @namespace Should
         * @api public
         */
        should.exist = function (val, msg) {
            new Assertion(val, msg).to.exist;
        };
        // negation
        should.not = {};
        /**
         * ### .not.equal(actual, expected, [message])
         *
         * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
         *
         *     should.not.equal(3, 4, 'these numbers are not equal');
         *
         * @name not.equal
         * @param {Mixed} actual
         * @param {Mixed} expected
         * @param {String} message
         * @namespace Should
         * @api public
         */
        should.not.equal = function (val1, val2, msg) {
            new Assertion(val1, msg).to.not.equal(val2);
        };
        /**
         * ### .throw(function, [constructor/regexp], [message])
         *
         * Asserts that `function` will _not_ throw an error that is an instance of
         * `constructor`, or alternately that it will not throw an error with message
         * matching `regexp`.
         *
         *     should.not.throw(fn, Error, 'function does not throw');
         *
         * @name not.throw
         * @alias not.Throw
         * @param {Function} function
         * @param {ErrorConstructor} constructor
         * @param {RegExp} regexp
         * @param {String} message
         * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
         * @namespace Should
         * @api public
         */
        should.not.Throw = function (fn, errt, errs, msg) {
            new Assertion(fn, msg).to.not.Throw(errt, errs);
        };
        /**
         * ### .not.exist
         *
         * Asserts that the target is neither `null` nor `undefined`.
         *
         *     var bar = null;
         *
         *     should.not.exist(bar, 'bar does not exist');
         *
         * @name not.exist
         * @namespace Should
         * @api public
         */
        should.not.exist = function (val, msg) {
            new Assertion(val, msg).to.not.exist;
        };
        should['throw'] = should['Throw'];
        should.not['throw'] = should.not['Throw'];
        return should;
    }
    ;
    chai.should = loadShould;
    chai.Should = loadShould;
};

},{}],17:[function(require,module,exports){
/*!
 * Chai - addChainingMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Module dependencies
 */
var transferFlags = require('./transferFlags');
var flag = require('./flag');
var config = require('../config');
/*!
 * Module variables
 */
// Check whether `__proto__` is supported
var hasProtoSupport = '__proto__' in Object;
// Without `__proto__` support, this module will need to add properties to a function.
// However, some Function.prototype methods cannot be overwritten,
// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).
var excludeNames = /^(?:length|name|arguments|caller)$/;
// Cache `Function` properties
var call = Function.prototype.call, apply = Function.prototype.apply;
/**
 * ### addChainableMethod (ctx, name, method, chainingBehavior)
 *
 * Adds a method to an object, such that the method can also be chained.
 *
 *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {
 *       var obj = utils.flag(this, 'object');
 *       new chai.Assertion(obj).to.be.equal(str);
 *     });
 *
 * Can also be accessed directly from `chai.Assertion`.
 *
 *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);
 *
 * The result can then be used as both a method assertion, executing both `method` and
 * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
 *
 *     expect(fooStr).to.be.foo('bar');
 *     expect(fooStr).to.be.foo.equal('foo');
 *
 * @param {Object} ctx object to which the method is added
 * @param {String} name of method to add
 * @param {Function} method function to be used for `name`, when called
 * @param {Function} chainingBehavior function to be called every time the property is accessed
 * @namespace Utils
 * @name addChainableMethod
 * @api public
 */
module.exports = function (ctx, name, method, chainingBehavior) {
    if (typeof chainingBehavior !== 'function') {
        chainingBehavior = function () { };
    }
    var chainableBehavior = {
        method: method,
        chainingBehavior: chainingBehavior
    };
    // save the methods so we can overwrite them later, if we need to.
    if (!ctx.__methods) {
        ctx.__methods = {};
    }
    ctx.__methods[name] = chainableBehavior;
    Object.defineProperty(ctx, name, { get: function () {
            chainableBehavior.chainingBehavior.call(this);
            var assert = function assert() {
                var old_ssfi = flag(this, 'ssfi');
                if (old_ssfi && config.includeStack === false)
                    flag(this, 'ssfi', assert);
                var result = chainableBehavior.method.apply(this, arguments);
                return result === undefined ? this : result;
            };
            // Use `__proto__` if available
            if (hasProtoSupport) {
                // Inherit all properties from the object by replacing the `Function` prototype
                var prototype = assert.__proto__ = Object.create(this);
                // Restore the `call` and `apply` methods from `Function`
                prototype.call = call;
                prototype.apply = apply;
            }
            else {
                var asserterNames = Object.getOwnPropertyNames(ctx);
                asserterNames.forEach(function (asserterName) {
                    if (!excludeNames.test(asserterName)) {
                        var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
                        Object.defineProperty(assert, asserterName, pd);
                    }
                });
            }
            transferFlags(this, assert);
            return assert;
        },
        configurable: true
    });
};

},{"../config":12,"./flag":21,"./transferFlags":37}],18:[function(require,module,exports){
/*!
 * Chai - addMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
var config = require('../config');
/**
 * ### .addMethod (ctx, name, method)
 *
 * Adds a method to the prototype of an object.
 *
 *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {
 *       var obj = utils.flag(this, 'object');
 *       new chai.Assertion(obj).to.be.equal(str);
 *     });
 *
 * Can also be accessed directly from `chai.Assertion`.
 *
 *     chai.Assertion.addMethod('foo', fn);
 *
 * Then can be used as any other assertion.
 *
 *     expect(fooStr).to.be.foo('bar');
 *
 * @param {Object} ctx object to which the method is added
 * @param {String} name of method to add
 * @param {Function} method function to be used for name
 * @namespace Utils
 * @name addMethod
 * @api public
 */
var flag = require('./flag');
module.exports = function (ctx, name, method) {
    ctx[name] = function () {
        var old_ssfi = flag(this, 'ssfi');
        if (old_ssfi && config.includeStack === false)
            flag(this, 'ssfi', ctx[name]);
        var result = method.apply(this, arguments);
        return result === undefined ? this : result;
    };
};

},{"../config":12,"./flag":21}],19:[function(require,module,exports){
/*!
 * Chai - addProperty utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
var config = require('../config');
var flag = require('./flag');
/**
 * ### addProperty (ctx, name, getter)
 *
 * Adds a property to the prototype of an object.
 *
 *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {
 *       var obj = utils.flag(this, 'object');
 *       new chai.Assertion(obj).to.be.instanceof(Foo);
 *     });
 *
 * Can also be accessed directly from `chai.Assertion`.
 *
 *     chai.Assertion.addProperty('foo', fn);
 *
 * Then can be used as any other assertion.
 *
 *     expect(myFoo).to.be.foo;
 *
 * @param {Object} ctx object to which the property is added
 * @param {String} name of property to add
 * @param {Function} getter function to be used for name
 * @namespace Utils
 * @name addProperty
 * @api public
 */
module.exports = function (ctx, name, getter) {
    Object.defineProperty(ctx, name, { get: function addProperty() {
            var old_ssfi = flag(this, 'ssfi');
            if (old_ssfi && config.includeStack === false)
                flag(this, 'ssfi', addProperty);
            var result = getter.call(this);
            return result === undefined ? this : result;
        },
        configurable: true
    });
};

},{"../config":12,"./flag":21}],20:[function(require,module,exports){
/*!
 * Chai - expectTypes utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### expectTypes(obj, types)
 *
 * Ensures that the object being tested against is of a valid type.
 *
 *     utils.expectTypes(this, ['array', 'object', 'string']);
 *
 * @param {Mixed} obj constructed Assertion
 * @param {Array} type A list of allowed types for this assertion
 * @namespace Utils
 * @name expectTypes
 * @api public
 */
var AssertionError = require('assertion-error');
var flag = require('./flag');
var type = require('type-detect');
module.exports = function (obj, types) {
    var obj = flag(obj, 'object');
    types = types.map(function (t) { return t.toLowerCase(); });
    types.sort();
    // Transforms ['lorem', 'ipsum'] into 'a lirum, or an ipsum'
    var str = types.map(function (t, index) {
        var art = ~['a', 'e', 'i', 'o', 'u'].indexOf(t.charAt(0)) ? 'an' : 'a';
        var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
        return or + art + ' ' + t;
    }).join(', ');
    if (!types.some(function (expected) { return type(obj) === expected; })) {
        throw new AssertionError('object tested must be ' + str + ', but ' + type(obj) + ' given');
    }
};

},{"./flag":21,"assertion-error":8,"type-detect":53}],21:[function(require,module,exports){
/*!
 * Chai - flag utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### flag(object, key, [value])
 *
 * Get or set a flag value on an object. If a
 * value is provided it will be set, else it will
 * return the currently set value or `undefined` if
 * the value is not set.
 *
 *     utils.flag(this, 'foo', 'bar'); // setter
 *     utils.flag(this, 'foo'); // getter, returns `bar`
 *
 * @param {Object} object constructed Assertion
 * @param {String} key
 * @param {Mixed} value (optional)
 * @namespace Utils
 * @name flag
 * @api private
 */
module.exports = function (obj, key, value) {
    var flags = obj.__flags || (obj.__flags = Object.create(null));
    if (arguments.length === 3) {
        flags[key] = value;
    }
    else {
        return flags[key];
    }
};

},{}],22:[function(require,module,exports){
/*!
 * Chai - getActual utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * # getActual(object, [actual])
 *
 * Returns the `actual` value for an Assertion
 *
 * @param {Object} object (constructed Assertion)
 * @param {Arguments} chai.Assertion.prototype.assert arguments
 * @namespace Utils
 * @name getActual
 */
module.exports = function (obj, args) {
    return args.length > 4 ? args[4] : obj._obj;
};

},{}],23:[function(require,module,exports){
/*!
 * Chai - getEnumerableProperties utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### .getEnumerableProperties(object)
 *
 * This allows the retrieval of enumerable property names of an object,
 * inherited or not.
 *
 * @param {Object} object
 * @returns {Array}
 * @namespace Utils
 * @name getEnumerableProperties
 * @api public
 */
module.exports = function getEnumerableProperties(object) {
    var result = [];
    for (var name in object) {
        result.push(name);
    }
    return result;
};

},{}],24:[function(require,module,exports){
/*!
 * Chai - message composition utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Module dependancies
 */
var flag = require('./flag'), getActual = require('./getActual'), inspect = require('./inspect'), objDisplay = require('./objDisplay');
/**
 * ### .getMessage(object, message, negateMessage)
 *
 * Construct the error message based on flags
 * and template tags. Template tags will return
 * a stringified inspection of the object referenced.
 *
 * Message template tags:
 * - `#{this}` current asserted object
 * - `#{act}` actual value
 * - `#{exp}` expected value
 *
 * @param {Object} object (constructed Assertion)
 * @param {Arguments} chai.Assertion.prototype.assert arguments
 * @namespace Utils
 * @name getMessage
 * @api public
 */
module.exports = function (obj, args) {
    var negate = flag(obj, 'negate'), val = flag(obj, 'object'), expected = args[3], actual = getActual(obj, args), msg = negate ? args[2] : args[1], flagMsg = flag(obj, 'message');
    if (typeof msg === "function")
        msg = msg();
    msg = msg || '';
    msg = msg
        .replace(/#\{this\}/g, function () { return objDisplay(val); })
        .replace(/#\{act\}/g, function () { return objDisplay(actual); })
        .replace(/#\{exp\}/g, function () { return objDisplay(expected); });
    return flagMsg ? flagMsg + ': ' + msg : msg;
};

},{"./flag":21,"./getActual":22,"./inspect":31,"./objDisplay":32}],25:[function(require,module,exports){
/*!
 * Chai - getName utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * # getName(func)
 *
 * Gets the name of a function, in a cross-browser way.
 *
 * @param {Function} a function (usually a constructor)
 * @namespace Utils
 * @name getName
 */
module.exports = function (func) {
    if (func.name)
        return func.name;
    var match = /^\s?function ([^(]*)\(/.exec(func);
    return match && match[1] ? match[1] : "";
};

},{}],26:[function(require,module,exports){
/*!
 * Chai - getPathInfo utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
var hasProperty = require('./hasProperty');
/**
 * ### .getPathInfo(path, object)
 *
 * This allows the retrieval of property info in an
 * object given a string path.
 *
 * The path info consists of an object with the
 * following properties:
 *
 * * parent - The parent object of the property referenced by `path`
 * * name - The name of the final property, a number if it was an array indexer
 * * value - The value of the property, if it exists, otherwise `undefined`
 * * exists - Whether the property exists or not
 *
 * @param {String} path
 * @param {Object} object
 * @returns {Object} info
 * @namespace Utils
 * @name getPathInfo
 * @api public
 */
module.exports = function getPathInfo(path, obj) {
    var parsed = parsePath(path), last = parsed[parsed.length - 1];
    var info = {
        parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj,
        name: last.p || last.i,
        value: _getPathValue(parsed, obj)
    };
    info.exists = hasProperty(info.name, info.parent);
    return info;
};
/*!
 * ## parsePath(path)
 *
 * Helper function used to parse string object
 * paths. Use in conjunction with `_getPathValue`.
 *
 *      var parsed = parsePath('myobject.property.subprop');
 *
 * ### Paths:
 *
 * * Can be as near infinitely deep and nested
 * * Arrays are also valid using the formal `myobject.document[3].property`.
 * * Literal dots and brackets (not delimiter) must be backslash-escaped.
 *
 * @param {String} path
 * @returns {Object} parsed
 * @api private
 */
function parsePath(path) {
    var str = path.replace(/([^\\])\[/g, '$1.['), parts = str.match(/(\\\.|[^.]+?)+/g);
    return parts.map(function (value) {
        var re = /^\[(\d+)\]$/, mArr = re.exec(value);
        if (mArr)
            return { i: parseFloat(mArr[1]) };
        else
            return { p: value.replace(/\\([.\[\]])/g, '$1') };
    });
}
/*!
 * ## _getPathValue(parsed, obj)
 *
 * Helper companion function for `.parsePath` that returns
 * the value located at the parsed address.
 *
 *      var value = getPathValue(parsed, obj);
 *
 * @param {Object} parsed definition from `parsePath`.
 * @param {Object} object to search against
 * @param {Number} object to search against
 * @returns {Object|Undefined} value
 * @api private
 */
function _getPathValue(parsed, obj, index) {
    var tmp = obj, res;
    index = (index === undefined ? parsed.length : index);
    for (var i = 0, l = index; i < l; i++) {
        var part = parsed[i];
        if (tmp) {
            if ('undefined' !== typeof part.p)
                tmp = tmp[part.p];
            else if ('undefined' !== typeof part.i)
                tmp = tmp[part.i];
            if (i == (l - 1))
                res = tmp;
        }
        else {
            res = undefined;
        }
    }
    return res;
}

},{"./hasProperty":29}],27:[function(require,module,exports){
/*!
 * Chai - getPathValue utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * @see https://github.com/logicalparadox/filtr
 * MIT Licensed
 */
var getPathInfo = require('./getPathInfo');
/**
 * ### .getPathValue(path, object)
 *
 * This allows the retrieval of values in an
 * object given a string path.
 *
 *     var obj = {
 *         prop1: {
 *             arr: ['a', 'b', 'c']
 *           , str: 'Hello'
 *         }
 *       , prop2: {
 *             arr: [ { nested: 'Universe' } ]
 *           , str: 'Hello again!'
 *         }
 *     }
 *
 * The following would be the results.
 *
 *     getPathValue('prop1.str', obj); // Hello
 *     getPathValue('prop1.att[2]', obj); // b
 *     getPathValue('prop2.arr[0].nested', obj); // Universe
 *
 * @param {String} path
 * @param {Object} object
 * @returns {Object} value or `undefined`
 * @namespace Utils
 * @name getPathValue
 * @api public
 */
module.exports = function (path, obj) {
    var info = getPathInfo(path, obj);
    return info.value;
};

},{"./getPathInfo":26}],28:[function(require,module,exports){
/*!
 * Chai - getProperties utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### .getProperties(object)
 *
 * This allows the retrieval of property names of an object, enumerable or not,
 * inherited or not.
 *
 * @param {Object} object
 * @returns {Array}
 * @namespace Utils
 * @name getProperties
 * @api public
 */
module.exports = function getProperties(object) {
    var result = Object.getOwnPropertyNames(object);
    function addProperty(property) {
        if (result.indexOf(property) === -1) {
            result.push(property);
        }
    }
    var proto = Object.getPrototypeOf(object);
    while (proto !== null) {
        Object.getOwnPropertyNames(proto).forEach(addProperty);
        proto = Object.getPrototypeOf(proto);
    }
    return result;
};

},{}],29:[function(require,module,exports){
/*!
 * Chai - hasProperty utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
var type = require('type-detect');
/**
 * ### .hasProperty(object, name)
 *
 * This allows checking whether an object has
 * named property or numeric array index.
 *
 * Basically does the same thing as the `in`
 * operator but works properly with natives
 * and null/undefined values.
 *
 *     var obj = {
 *         arr: ['a', 'b', 'c']
 *       , str: 'Hello'
 *     }
 *
 * The following would be the results.
 *
 *     hasProperty('str', obj);  // true
 *     hasProperty('constructor', obj);  // true
 *     hasProperty('bar', obj);  // false
 *
 *     hasProperty('length', obj.str); // true
 *     hasProperty(1, obj.str);  // true
 *     hasProperty(5, obj.str);  // false
 *
 *     hasProperty('length', obj.arr);  // true
 *     hasProperty(2, obj.arr);  // true
 *     hasProperty(3, obj.arr);  // false
 *
 * @param {Objuect} object
 * @param {String|Number} name
 * @returns {Boolean} whether it exists
 * @namespace Utils
 * @name getPathInfo
 * @api public
 */
var literals = {
    'number': Number,
    'string': String
};
module.exports = function hasProperty(name, obj) {
    var ot = type(obj);
    // Bad Object, obviously no props at all
    if (ot === 'null' || ot === 'undefined')
        return false;
    // The `in` operator does not work with certain literals
    // box these before the check
    if (literals[ot] && typeof obj !== 'object')
        obj = new literals[ot](obj);
    return name in obj;
};

},{"type-detect":53}],30:[function(require,module,exports){
/*!
 * chai
 * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Main exports
 */
var exports = module.exports = {};
/*!
 * test utility
 */
exports.test = require('./test');
/*!
 * type utility
 */
exports.type = require('type-detect');
/*!
 * expectTypes utility
 */
exports.expectTypes = require('./expectTypes');
/*!
 * message utility
 */
exports.getMessage = require('./getMessage');
/*!
 * actual utility
 */
exports.getActual = require('./getActual');
/*!
 * Inspect util
 */
exports.inspect = require('./inspect');
/*!
 * Object Display util
 */
exports.objDisplay = require('./objDisplay');
/*!
 * Flag utility
 */
exports.flag = require('./flag');
/*!
 * Flag transferring utility
 */
exports.transferFlags = require('./transferFlags');
/*!
 * Deep equal utility
 */
exports.eql = require('deep-eql');
/*!
 * Deep path value
 */
exports.getPathValue = require('./getPathValue');
/*!
 * Deep path info
 */
exports.getPathInfo = require('./getPathInfo');
/*!
 * Check if a property exists
 */
exports.hasProperty = require('./hasProperty');
/*!
 * Function name
 */
exports.getName = require('./getName');
/*!
 * add Property
 */
exports.addProperty = require('./addProperty');
/*!
 * add Method
 */
exports.addMethod = require('./addMethod');
/*!
 * overwrite Property
 */
exports.overwriteProperty = require('./overwriteProperty');
/*!
 * overwrite Method
 */
exports.overwriteMethod = require('./overwriteMethod');
/*!
 * Add a chainable method
 */
exports.addChainableMethod = require('./addChainableMethod');
/*!
 * Overwrite chainable method
 */
exports.overwriteChainableMethod = require('./overwriteChainableMethod');

},{"./addChainableMethod":17,"./addMethod":18,"./addProperty":19,"./expectTypes":20,"./flag":21,"./getActual":22,"./getMessage":24,"./getName":25,"./getPathInfo":26,"./getPathValue":27,"./hasProperty":29,"./inspect":31,"./objDisplay":32,"./overwriteChainableMethod":33,"./overwriteMethod":34,"./overwriteProperty":35,"./test":36,"./transferFlags":37,"deep-eql":38,"type-detect":53}],31:[function(require,module,exports){
// This is (almost) directly from Node.js utils
// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
var getName = require('./getName');
var getProperties = require('./getProperties');
var getEnumerableProperties = require('./getEnumerableProperties');
module.exports = inspect;
/**
 * 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 {Boolean} showHidden Flag that shows hidden (not enumerable)
 *    properties of objects.
 * @param {Number} depth Depth in which to descend in object. Default is 2.
 * @param {Boolean} colors Flag to turn on ANSI escape codes to color the
 *    output. Default is false (no coloring).
 * @namespace Utils
 * @name inspect
 */
function inspect(obj, showHidden, depth, colors) {
    var ctx = {
        showHidden: showHidden,
        seen: [],
        stylize: function (str) { return str; }
    };
    return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));
}
// Returns true if object is a DOM element.
var isDOMElement = function (object) {
    if (typeof HTMLElement === 'object') {
        return object instanceof HTMLElement;
    }
    else {
        return object &&
            typeof object === 'object' &&
            object.nodeType === 1 &&
            typeof object.nodeName === 'string';
    }
};
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 (value && typeof value.inspect === 'function' &&
        // 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);
        if (typeof ret !== 'string') {
            ret = formatValue(ctx, ret, recurseTimes);
        }
        return ret;
    }
    // Primitive types cannot have properties
    var primitive = formatPrimitive(ctx, value);
    if (primitive) {
        return primitive;
    }
    // If this is a DOM element, try to get the outer HTML.
    if (isDOMElement(value)) {
        if ('outerHTML' in value) {
            return value.outerHTML;
        }
        else {
            // Attempt to serialize it
            try {
                if (document.xmlVersion) {
                    var xmlSerializer = new XMLSerializer();
                    return xmlSerializer.serializeToString(value);
                }
                else {
                    // Firefox 11- do not support outerHTML
                    //   It does, however, support innerHTML
                    //   Use the following to render the element
                    var ns = "http://www.w3.org/1999/xhtml";
                    var container = document.createElementNS(ns, '_');
                    container.appendChild(value.cloneNode(false));
                    html = container.innerHTML
                        .replace('><', '>' + value.innerHTML + '<');
                    container.innerHTML = '';
                    return html;
                }
            }
            catch (err) {
            }
        }
    }
    // Look up the keys of the object.
    var visibleKeys = getEnumerableProperties(value);
    var keys = ctx.showHidden ? getProperties(value) : visibleKeys;
    // Some type of object without properties can be shortcutted.
    // In IE, errors have a single `stack` property, or if they are vanilla `Error`,
    // a `stack` plus `description` property; ignore those for consistency.
    if (keys.length === 0 || (isError(value) && ((keys.length === 1 && keys[0] === 'stack') ||
        (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')))) {
        if (typeof value === 'function') {
            var name = getName(value);
            var nameSuffix = name ? ': ' + name : '';
            return ctx.stylize('[Function' + nameSuffix + ']', 'special');
        }
        if (isRegExp(value)) {
            return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        }
        if (isDate(value)) {
            return ctx.stylize(Date.prototype.toUTCString.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 (typeof value === 'function') {
        var name = getName(value);
        var nameSuffix = name ? ': ' + name : '';
        base = ' [Function' + nameSuffix + ']';
    }
    // 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)) {
        return 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) {
    switch (typeof value) {
        case 'undefined':
            return ctx.stylize('undefined', 'undefined');
        case 'string':
            var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                .replace(/'/g, "\\'")
                .replace(/\\"/g, '"') + '\'';
            return ctx.stylize(simple, 'string');
        case 'number':
            if (value === 0 && (1 / value) === -Infinity) {
                return ctx.stylize('-0', 'number');
            }
            return ctx.stylize('' + value, 'number');
        case 'boolean':
            return ctx.stylize('' + value, 'boolean');
    }
    // For some reason typeof null is "object", so special case here.
    if (value === null) {
        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 (Object.prototype.hasOwnProperty.call(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;
    if (value.__lookupGetter__) {
        if (value.__lookupGetter__(key)) {
            if (value.__lookupSetter__(key)) {
                str = ctx.stylize('[Getter/Setter]', 'special');
            }
            else {
                str = ctx.stylize('[Getter]', 'special');
            }
        }
        else {
            if (value.__lookupSetter__(key)) {
                str = ctx.stylize('[Setter]', 'special');
            }
        }
    }
    if (visibleKeys.indexOf(key) < 0) {
        name = '[' + key + ']';
    }
    if (!str) {
        if (ctx.seen.indexOf(value[key]) < 0) {
            if (recurseTimes === null) {
                str = formatValue(ctx, value[key], null);
            }
            else {
                str = formatValue(ctx, value[key], 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 (typeof name === 'undefined') {
        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.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];
}
function isArray(ar) {
    return Array.isArray(ar) ||
        (typeof ar === 'object' && objectToString(ar) === '[object Array]');
}
function isRegExp(re) {
    return typeof re === 'object' && objectToString(re) === '[object RegExp]';
}
function isDate(d) {
    return typeof d === 'object' && objectToString(d) === '[object Date]';
}
function isError(e) {
    return typeof e === 'object' && objectToString(e) === '[object Error]';
}
function objectToString(o) {
    return Object.prototype.toString.call(o);
}

},{"./getEnumerableProperties":23,"./getName":25,"./getProperties":28}],32:[function(require,module,exports){
/*!
 * Chai - flag utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Module dependancies
 */
var inspect = require('./inspect');
var config = require('../config');
/**
 * ### .objDisplay (object)
 *
 * Determines if an object or an array matches
 * criteria to be inspected in-line for error
 * messages or should be truncated.
 *
 * @param {Mixed} javascript object to inspect
 * @name objDisplay
 * @namespace Utils
 * @api public
 */
module.exports = function (obj) {
    var str = inspect(obj), type = Object.prototype.toString.call(obj);
    if (config.truncateThreshold && str.length >= config.truncateThreshold) {
        if (type === '[object Function]') {
            return !obj.name || obj.name === ''
                ? '[Function]'
                : '[Function: ' + obj.name + ']';
        }
        else if (type === '[object Array]') {
            return '[ Array(' + obj.length + ') ]';
        }
        else if (type === '[object Object]') {
            var keys = Object.keys(obj), kstr = keys.length > 2
                ? keys.splice(0, 2).join(', ') + ', ...'
                : keys.join(', ');
            return '{ Object (' + kstr + ') }';
        }
        else {
            return str;
        }
    }
    else {
        return str;
    }
};

},{"../config":12,"./inspect":31}],33:[function(require,module,exports){
/*!
 * Chai - overwriteChainableMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### overwriteChainableMethod (ctx, name, method, chainingBehavior)
 *
 * Overwites an already existing chainable method
 * and provides access to the previous function or
 * property.  Must return functions to be used for
 * name.
 *
 *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',
 *       function (_super) {
 *       }
 *     , function (_super) {
 *       }
 *     );
 *
 * Can also be accessed directly from `chai.Assertion`.
 *
 *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);
 *
 * Then can be used as any other assertion.
 *
 *     expect(myFoo).to.have.length(3);
 *     expect(myFoo).to.have.length.above(3);
 *
 * @param {Object} ctx object whose method / property is to be overwritten
 * @param {String} name of method / property to overwrite
 * @param {Function} method function that returns a function to be used for name
 * @param {Function} chainingBehavior function that returns a function to be used for property
 * @namespace Utils
 * @name overwriteChainableMethod
 * @api public
 */
module.exports = function (ctx, name, method, chainingBehavior) {
    var chainableBehavior = ctx.__methods[name];
    var _chainingBehavior = chainableBehavior.chainingBehavior;
    chainableBehavior.chainingBehavior = function () {
        var result = chainingBehavior(_chainingBehavior).call(this);
        return result === undefined ? this : result;
    };
    var _method = chainableBehavior.method;
    chainableBehavior.method = function () {
        var result = method(_method).apply(this, arguments);
        return result === undefined ? this : result;
    };
};

},{}],34:[function(require,module,exports){
/*!
 * Chai - overwriteMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### overwriteMethod (ctx, name, fn)
 *
 * Overwites an already existing method and provides
 * access to previous function. Must return function
 * to be used for name.
 *
 *     utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {
 *       return function (str) {
 *         var obj = utils.flag(this, 'object');
 *         if (obj instanceof Foo) {
 *           new chai.Assertion(obj.value).to.equal(str);
 *         } else {
 *           _super.apply(this, arguments);
 *         }
 *       }
 *     });
 *
 * Can also be accessed directly from `chai.Assertion`.
 *
 *     chai.Assertion.overwriteMethod('foo', fn);
 *
 * Then can be used as any other assertion.
 *
 *     expect(myFoo).to.equal('bar');
 *
 * @param {Object} ctx object whose method is to be overwritten
 * @param {String} name of method to overwrite
 * @param {Function} method function that returns a function to be used for name
 * @namespace Utils
 * @name overwriteMethod
 * @api public
 */
module.exports = function (ctx, name, method) {
    var _method = ctx[name], _super = function () { return this; };
    if (_method && 'function' === typeof _method)
        _super = _method;
    ctx[name] = function () {
        var result = method(_super).apply(this, arguments);
        return result === undefined ? this : result;
    };
};

},{}],35:[function(require,module,exports){
/*!
 * Chai - overwriteProperty utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### overwriteProperty (ctx, name, fn)
 *
 * Overwites an already existing property getter and provides
 * access to previous value. Must return function to use as getter.
 *
 *     utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {
 *       return function () {
 *         var obj = utils.flag(this, 'object');
 *         if (obj instanceof Foo) {
 *           new chai.Assertion(obj.name).to.equal('bar');
 *         } else {
 *           _super.call(this);
 *         }
 *       }
 *     });
 *
 *
 * Can also be accessed directly from `chai.Assertion`.
 *
 *     chai.Assertion.overwriteProperty('foo', fn);
 *
 * Then can be used as any other assertion.
 *
 *     expect(myFoo).to.be.ok;
 *
 * @param {Object} ctx object whose property is to be overwritten
 * @param {String} name of property to overwrite
 * @param {Function} getter function that returns a getter function to be used for name
 * @namespace Utils
 * @name overwriteProperty
 * @api public
 */
module.exports = function (ctx, name, getter) {
    var _get = Object.getOwnPropertyDescriptor(ctx, name), _super = function () { };
    if (_get && 'function' === typeof _get.get)
        _super = _get.get;
    Object.defineProperty(ctx, name, { get: function () {
            var result = getter(_super).call(this);
            return result === undefined ? this : result;
        },
        configurable: true
    });
};

},{}],36:[function(require,module,exports){
/*!
 * Chai - test utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Module dependancies
 */
var flag = require('./flag');
/**
 * # test(object, expression)
 *
 * Test and object for expression.
 *
 * @param {Object} object (constructed Assertion)
 * @param {Arguments} chai.Assertion.prototype.assert arguments
 * @namespace Utils
 * @name test
 */
module.exports = function (obj, args) {
    var negate = flag(obj, 'negate'), expr = args[0];
    return negate ? !expr : expr;
};

},{"./flag":21}],37:[function(require,module,exports){
/*!
 * Chai - transferFlags utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/**
 * ### transferFlags(assertion, object, includeAll = true)
 *
 * Transfer all the flags for `assertion` to `object`. If
 * `includeAll` is set to `false`, then the base Chai
 * assertion flags (namely `object`, `ssfi`, and `message`)
 * will not be transferred.
 *
 *
 *     var newAssertion = new Assertion();
 *     utils.transferFlags(assertion, newAssertion);
 *
 *     var anotherAsseriton = new Assertion(myObj);
 *     utils.transferFlags(assertion, anotherAssertion, false);
 *
 * @param {Assertion} assertion the assertion to transfer the flags from
 * @param {Object} object the object to transfer the flags to; usually a new assertion
 * @param {Boolean} includeAll
 * @namespace Utils
 * @name transferFlags
 * @api private
 */
module.exports = function (assertion, object, includeAll) {
    var flags = assertion.__flags || (assertion.__flags = Object.create(null));
    if (!object.__flags) {
        object.__flags = Object.create(null);
    }
    includeAll = arguments.length === 3 ? includeAll : true;
    for (var flag in flags) {
        if (includeAll ||
            (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {
            object.__flags[flag] = flags[flag];
        }
    }
};

},{}],38:[function(require,module,exports){
module.exports = require('./lib/eql');

},{"./lib/eql":39}],39:[function(require,module,exports){
/*!
 * deep-eql
 * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Module dependencies
 */
var type = require('type-detect');
/*!
 * Buffer.isBuffer browser shim
 */
var Buffer;
try {
    Buffer = require('buffer').Buffer;
}
catch (ex) {
    Buffer = {};
    Buffer.isBuffer = function () { return false; };
}
/*!
 * Primary Export
 */
module.exports = deepEqual;
/**
 * Assert super-strict (egal) equality between
 * two objects of any type.
 *
 * @param {Mixed} a
 * @param {Mixed} b
 * @param {Array} memoised (optional)
 * @return {Boolean} equal match
 */
function deepEqual(a, b, m) {
    if (sameValue(a, b)) {
        return true;
    }
    else if ('date' === type(a)) {
        return dateEqual(a, b);
    }
    else if ('regexp' === type(a)) {
        return regexpEqual(a, b);
    }
    else if (Buffer.isBuffer(a)) {
        return bufferEqual(a, b);
    }
    else if ('arguments' === type(a)) {
        return argumentsEqual(a, b, m);
    }
    else if (!typeEqual(a, b)) {
        return false;
    }
    else if (('object' !== type(a) && 'object' !== type(b))
        && ('array' !== type(a) && 'array' !== type(b))) {
        return sameValue(a, b);
    }
    else {
        return objectEqual(a, b, m);
    }
}
/*!
 * Strict (egal) equality test. Ensures that NaN always
 * equals NaN and `-0` does not equal `+0`.
 *
 * @param {Mixed} a
 * @param {Mixed} b
 * @return {Boolean} equal match
 */
function sameValue(a, b) {
    if (a === b)
        return a !== 0 || 1 / a === 1 / b;
    return a !== a && b !== b;
}
/*!
 * Compare the types of two given objects and
 * return if they are equal. Note that an Array
 * has a type of `array` (not `object`) and arguments
 * have a type of `arguments` (not `array`/`object`).
 *
 * @param {Mixed} a
 * @param {Mixed} b
 * @return {Boolean} result
 */
function typeEqual(a, b) {
    return type(a) === type(b);
}
/*!
 * Compare two Date objects by asserting that
 * the time values are equal using `saveValue`.
 *
 * @param {Date} a
 * @param {Date} b
 * @return {Boolean} result
 */
function dateEqual(a, b) {
    if ('date' !== type(b))
        return false;
    return sameValue(a.getTime(), b.getTime());
}
/*!
 * Compare two regular expressions by converting them
 * to string and checking for `sameValue`.
 *
 * @param {RegExp} a
 * @param {RegExp} b
 * @return {Boolean} result
 */
function regexpEqual(a, b) {
    if ('regexp' !== type(b))
        return false;
    return sameValue(a.toString(), b.toString());
}
/*!
 * Assert deep equality of two `arguments` objects.
 * Unfortunately, these must be sliced to arrays
 * prior to test to ensure no bad behavior.
 *
 * @param {Arguments} a
 * @param {Arguments} b
 * @param {Array} memoize (optional)
 * @return {Boolean} result
 */
function argumentsEqual(a, b, m) {
    if ('arguments' !== type(b))
        return false;
    a = [].slice.call(a);
    b = [].slice.call(b);
    return deepEqual(a, b, m);
}
/*!
 * Get enumerable properties of a given object.
 *
 * @param {Object} a
 * @return {Array} property names
 */
function enumerable(a) {
    var res = [];
    for (var key in a)
        res.push(key);
    return res;
}
/*!
 * Simple equality for flat iterable objects
 * such as Arrays or Node.js buffers.
 *
 * @param {Iterable} a
 * @param {Iterable} b
 * @return {Boolean} result
 */
function iterableEqual(a, b) {
    if (a.length !== b.length)
        return false;
    var i = 0;
    var match = true;
    for (; i < a.length; i++) {
        if (a[i] !== b[i]) {
            match = false;
            break;
        }
    }
    return match;
}
/*!
 * Extension to `iterableEqual` specifically
 * for Node.js Buffers.
 *
 * @param {Buffer} a
 * @param {Mixed} b
 * @return {Boolean} result
 */
function bufferEqual(a, b) {
    if (!Buffer.isBuffer(b))
        return false;
    return iterableEqual(a, b);
}
/*!
 * Block for `objectEqual` ensuring non-existing
 * values don't get in.
 *
 * @param {Mixed} object
 * @return {Boolean} result
 */
function isValue(a) {
    return a !== null && a !== undefined;
}
/*!
 * Recursively check the equality of two objects.
 * Once basic sameness has been established it will
 * defer to `deepEqual` for each enumerable key
 * in the object.
 *
 * @param {Mixed} a
 * @param {Mixed} b
 * @return {Boolean} result
 */
function objectEqual(a, b, m) {
    if (!isValue(a) || !isValue(b)) {
        return false;
    }
    if (a.prototype !== b.prototype) {
        return false;
    }
    var i;
    if (m) {
        for (i = 0; i < m.length; i++) {
            if ((m[i][0] === a && m[i][1] === b)
                || (m[i][0] === b && m[i][1] === a)) {
                return true;
            }
        }
    }
    else {
        m = [];
    }
    try {
        var ka = enumerable(a);
        var kb = enumerable(b);
    }
    catch (ex) {
        return false;
    }
    ka.sort();
    kb.sort();
    if (!iterableEqual(ka, kb)) {
        return false;
    }
    m.push([a, b]);
    var key;
    for (i = ka.length - 1; i >= 0; i--) {
        key = ka[i];
        if (!deepEqual(a[key], b[key], m)) {
            return false;
        }
    }
    return true;
}

},{"buffer":63,"type-detect":40}],40:[function(require,module,exports){
module.exports = require('./lib/type');

},{"./lib/type":41}],41:[function(require,module,exports){
/*!
 * type-detect
 * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

/*!
 * Primary Exports
 */

var exports = module.exports = getType;

/*!
 * Detectable javascript natives
 */

var natives = {
    '[object Array]': 'array'
  , '[object RegExp]': 'regexp'
  , '[object Function]': 'function'
  , '[object Arguments]': 'arguments'
  , '[object Date]': 'date'
};

/**
 * ### typeOf (obj)
 *
 * Use several different techniques to determine
 * the type of object being tested.
 *
 *
 * @param {Mixed} object
 * @return {String} object type
 * @api public
 */

function getType (obj) {
  var str = Object.prototype.toString.call(obj);
  if (natives[str]) return natives[str];
  if (obj === null) return 'null';
  if (obj === undefined) return 'undefined';
  if (obj === Object(obj)) return 'object';
  return typeof obj;
}

exports.Library = Library;

/**
 * ### Library
 *
 * Create a repository for custom type detection.
 *
 * ```js
 * var lib = new type.Library;
 * ```
 *
 */

function Library () {
  this.tests = {};
}

/**
 * #### .of (obj)
 *
 * Expose replacement `typeof` detection to the library.
 *
 * ```js
 * if ('string' === lib.of('hello world')) {
 *   // ...
 * }
 * ```
 *
 * @param {Mixed} object to test
 * @return {String} type
 */

Library.prototype.of = getType;

/**
 * #### .define (type, test)
 *
 * Add a test to for the `.test()` assertion.
 *
 * Can be defined as a regular expression:
 *
 * ```js
 * lib.define('int', /^[0-9]+$/);
 * ```
 *
 * ... or as a function:
 *
 * ```js
 * lib.define('bln', function (obj) {
 *   if ('boolean' === lib.of(obj)) return true;
 *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
 *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
 *   return !! ~blns.indexOf(obj);
 * });
 * ```
 *
 * @param {String} type
 * @param {RegExp|Function} test
 * @api public
 */

Library.prototype.define = function (type, test) {
  if (arguments.length === 1) return this.tests[type];
  this.tests[type] = test;
  return this;
};

/**
 * #### .test (obj, test)
 *
 * Assert that an object is of type. Will first
 * check natives, and if that does not pass it will
 * use the user defined custom tests.
 *
 * ```js
 * assert(lib.test('1', 'int'));
 * assert(lib.test('yes', 'bln'));
 * ```
 *
 * @param {Mixed} object
 * @param {String} type
 * @return {Boolean} result
 * @api public
 */

Library.prototype.test = function (obj, type) {
  if (type === getType(obj)) return true;
  var test = this.tests[type];

  if (test && 'regexp' === getType(test)) {
    return test.test(obj);
  } else if (test && 'function' === getType(test)) {
    return test(obj);
  } else {
    throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
  }
};

},{}],42:[function(require,module,exports){
'use strict';
/* eslint-disable no-unused-vars */
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
    if (val === null || val === undefined) {
        throw new TypeError('Object.assign cannot be called with null or undefined');
    }
    return Object(val);
}
function shouldUseNative() {
    try {
        if (!Object.assign) {
            return false;
        }
        // Detect buggy property enumeration order in older V8 versions.
        // https://bugs.chromium.org/p/v8/issues/detail?id=4118
        var test1 = new String('abc'); // eslint-disable-line
        test1[5] = 'de';
        if (Object.getOwnPropertyNames(test1)[0] === '5') {
            return false;
        }
        // https://bugs.chromium.org/p/v8/issues/detail?id=3056
        var test2 = {};
        for (var i = 0; i < 10; i++) {
            test2['_' + String.fromCharCode(i)] = i;
        }
        var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
            return test2[n];
        });
        if (order2.join('') !== '0123456789') {
            return false;
        }
        // https://bugs.chromium.org/p/v8/issues/detail?id=3056
        var test3 = {};
        'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
            test3[letter] = letter;
        });
        if (Object.keys(Object.assign({}, test3)).join('') !==
            'abcdefghijklmnopqrst') {
            return false;
        }
        return true;
    }
    catch (e) {
        // We don't expect any of the above to throw, but better to be safe.
        return false;
    }
}
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
    var from;
    var to = toObject(target);
    var symbols;
    for (var s = 1; s < arguments.length; s++) {
        from = Object(arguments[s]);
        for (var key in from) {
            if (hasOwnProperty.call(from, key)) {
                to[key] = from[key];
            }
        }
        if (Object.getOwnPropertySymbols) {
            symbols = Object.getOwnPropertySymbols(from);
            for (var i = 0; i < symbols.length; i++) {
                if (propIsEnumerable.call(from, symbols[i])) {
                    to[symbols[i]] = from[symbols[i]];
                }
            }
        }
    }
    return to;
};

},{}],43:[function(require,module,exports){
/*
 * Copyright 2009-2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE.txt or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
exports.SourceNode = require('./source-map/source-node').SourceNode;

},{"./source-map/source-map-consumer":48,"./source-map/source-map-generator":49,"./source-map/source-node":50}],44:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  var util = require('./util');

  /**
   * A data structure which is a combination of an array and a set. Adding a new
   * member is O(1), testing for membership is O(1), and finding the index of an
   * element is O(1). Removing elements from the set is not supported. Only
   * strings are supported for membership.
   */
  function ArraySet() {
    this._array = [];
    this._set = {};
  }

  /**
   * Static method for creating ArraySet instances from an existing array.
   */
  ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
    var set = new ArraySet();
    for (var i = 0, len = aArray.length; i < len; i++) {
      set.add(aArray[i], aAllowDuplicates);
    }
    return set;
  };

  /**
   * Add the given string to this set.
   *
   * @param String aStr
   */
  ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
    var isDuplicate = this.has(aStr);
    var idx = this._array.length;
    if (!isDuplicate || aAllowDuplicates) {
      this._array.push(aStr);
    }
    if (!isDuplicate) {
      this._set[util.toSetString(aStr)] = idx;
    }
  };

  /**
   * Is the given string a member of this set?
   *
   * @param String aStr
   */
  ArraySet.prototype.has = function ArraySet_has(aStr) {
    return Object.prototype.hasOwnProperty.call(this._set,
                                                util.toSetString(aStr));
  };

  /**
   * What is the index of the given string in the array?
   *
   * @param String aStr
   */
  ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
    if (this.has(aStr)) {
      return this._set[util.toSetString(aStr)];
    }
    throw new Error('"' + aStr + '" is not in the set.');
  };

  /**
   * What is the element at the given index?
   *
   * @param Number aIdx
   */
  ArraySet.prototype.at = function ArraySet_at(aIdx) {
    if (aIdx >= 0 && aIdx < this._array.length) {
      return this._array[aIdx];
    }
    throw new Error('No element indexed by ' + aIdx);
  };

  /**
   * Returns the array representation of this set (which has the proper indices
   * indicated by indexOf). Note that this is a copy of the internal array used
   * for storing the members so that no one can mess with internal state.
   */
  ArraySet.prototype.toArray = function ArraySet_toArray() {
    return this._array.slice();
  };

  exports.ArraySet = ArraySet;

});

},{"./util":51,"amdefine":7}],45:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 *
 * Based on the Base 64 VLQ implementation in Closure Compiler:
 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
 *
 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of Google Inc. nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  var base64 = require('./base64');

  // A single base 64 digit can contain 6 bits of data. For the base 64 variable
  // length quantities we use in the source map spec, the first bit is the sign,
  // the next four bits are the actual value, and the 6th bit is the
  // continuation bit. The continuation bit tells us whether there are more
  // digits in this value following this digit.
  //
  //   Continuation
  //   |    Sign
  //   |    |
  //   V    V
  //   101011

  var VLQ_BASE_SHIFT = 5;

  // binary: 100000
  var VLQ_BASE = 1 << VLQ_BASE_SHIFT;

  // binary: 011111
  var VLQ_BASE_MASK = VLQ_BASE - 1;

  // binary: 100000
  var VLQ_CONTINUATION_BIT = VLQ_BASE;

  /**
   * Converts from a two-complement value to a value where the sign bit is
   * is placed in the least significant bit.  For example, as decimals:
   *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
   *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
   */
  function toVLQSigned(aValue) {
    return aValue < 0
      ? ((-aValue) << 1) + 1
      : (aValue << 1) + 0;
  }

  /**
   * Converts to a two-complement value from a value where the sign bit is
   * is placed in the least significant bit.  For example, as decimals:
   *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
   *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
   */
  function fromVLQSigned(aValue) {
    var isNegative = (aValue & 1) === 1;
    var shifted = aValue >> 1;
    return isNegative
      ? -shifted
      : shifted;
  }

  /**
   * Returns the base 64 VLQ encoded value.
   */
  exports.encode = function base64VLQ_encode(aValue) {
    var encoded = "";
    var digit;

    var vlq = toVLQSigned(aValue);

    do {
      digit = vlq & VLQ_BASE_MASK;
      vlq >>>= VLQ_BASE_SHIFT;
      if (vlq > 0) {
        // There are still more digits in this value, so we must make sure the
        // continuation bit is marked.
        digit |= VLQ_CONTINUATION_BIT;
      }
      encoded += base64.encode(digit);
    } while (vlq > 0);

    return encoded;
  };

  /**
   * Decodes the next base 64 VLQ value from the given string and returns the
   * value and the rest of the string.
   */
  exports.decode = function base64VLQ_decode(aStr) {
    var i = 0;
    var strLen = aStr.length;
    var result = 0;
    var shift = 0;
    var continuation, digit;

    do {
      if (i >= strLen) {
        throw new Error("Expected more digits in base 64 VLQ value.");
      }
      digit = base64.decode(aStr.charAt(i++));
      continuation = !!(digit & VLQ_CONTINUATION_BIT);
      digit &= VLQ_BASE_MASK;
      result = result + (digit << shift);
      shift += VLQ_BASE_SHIFT;
    } while (continuation);

    return {
      value: fromVLQSigned(result),
      rest: aStr.slice(i)
    };
  };

});

},{"./base64":46,"amdefine":7}],46:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  var charToIntMap = {};
  var intToCharMap = {};

  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    .split('')
    .forEach(function (ch, index) {
      charToIntMap[ch] = index;
      intToCharMap[index] = ch;
    });

  /**
   * Encode an integer in the range of 0 to 63 to a single base 64 digit.
   */
  exports.encode = function base64_encode(aNumber) {
    if (aNumber in intToCharMap) {
      return intToCharMap[aNumber];
    }
    throw new TypeError("Must be between 0 and 63: " + aNumber);
  };

  /**
   * Decode a single base 64 digit to an integer.
   */
  exports.decode = function base64_decode(aChar) {
    if (aChar in charToIntMap) {
      return charToIntMap[aChar];
    }
    throw new TypeError("Not a valid base 64 digit: " + aChar);
  };

});

},{"amdefine":7}],47:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  /**
   * Recursive implementation of binary search.
   *
   * @param aLow Indices here and lower do not contain the needle.
   * @param aHigh Indices here and higher do not contain the needle.
   * @param aNeedle The element being searched for.
   * @param aHaystack The non-empty array being searched.
   * @param aCompare Function which takes two elements and returns -1, 0, or 1.
   */
  function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
    // This function terminates when one of the following is true:
    //
    //   1. We find the exact element we are looking for.
    //
    //   2. We did not find the exact element, but we can return the next
    //      closest element that is less than that element.
    //
    //   3. We did not find the exact element, and there is no next-closest
    //      element which is less than the one we are searching for, so we
    //      return null.
    var mid = Math.floor((aHigh - aLow) / 2) + aLow;
    var cmp = aCompare(aNeedle, aHaystack[mid], true);
    if (cmp === 0) {
      // Found the element we are looking for.
      return aHaystack[mid];
    }
    else if (cmp > 0) {
      // aHaystack[mid] is greater than our needle.
      if (aHigh - mid > 1) {
        // The element is in the upper half.
        return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
      }
      // We did not find an exact match, return the next closest one
      // (termination case 2).
      return aHaystack[mid];
    }
    else {
      // aHaystack[mid] is less than our needle.
      if (mid - aLow > 1) {
        // The element is in the lower half.
        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
      }
      // The exact needle element was not found in this haystack. Determine if
      // we are in termination case (2) or (3) and return the appropriate thing.
      return aLow < 0
        ? null
        : aHaystack[aLow];
    }
  }

  /**
   * This is an implementation of binary search which will always try and return
   * the next lowest value checked if there is no exact hit. This is because
   * mappings between original and generated line/col pairs are single points,
   * and there is an implicit region between each of them, so a miss just means
   * that you aren't on the very start of a region.
   *
   * @param aNeedle The element you are looking for.
   * @param aHaystack The array that is being searched.
   * @param aCompare A function which takes the needle and an element in the
   *     array and returns -1, 0, or 1 depending on whether the needle is less
   *     than, equal to, or greater than the element, respectively.
   */
  exports.search = function search(aNeedle, aHaystack, aCompare) {
    return aHaystack.length > 0
      ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
      : null;
  };

});

},{"amdefine":7}],48:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  var util = require('./util');
  var binarySearch = require('./binary-search');
  var ArraySet = require('./array-set').ArraySet;
  var base64VLQ = require('./base64-vlq');

  /**
   * A SourceMapConsumer instance represents a parsed source map which we can
   * query for information about the original file positions by giving it a file
   * position in the generated source.
   *
   * The only parameter is the raw source map (either as a JSON string, or
   * already parsed to an object). According to the spec, source maps have the
   * following attributes:
   *
   *   - version: Which version of the source map spec this map is following.
   *   - sources: An array of URLs to the original source files.
   *   - names: An array of identifiers which can be referrenced by individual mappings.
   *   - sourceRoot: Optional. The URL root from which all sources are relative.
   *   - sourcesContent: Optional. An array of contents of the original source files.
   *   - mappings: A string of base64 VLQs which contain the actual mappings.
   *   - file: The generated file this source map is associated with.
   *
   * Here is an example source map, taken from the source map spec[0]:
   *
   *     {
   *       version : 3,
   *       file: "out.js",
   *       sourceRoot : "",
   *       sources: ["foo.js", "bar.js"],
   *       names: ["src", "maps", "are", "fun"],
   *       mappings: "AA,AB;;ABCDE;"
   *     }
   *
   * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
   */
  function SourceMapConsumer(aSourceMap) {
    var sourceMap = aSourceMap;
    if (typeof aSourceMap === 'string') {
      sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
    }

    var version = util.getArg(sourceMap, 'version');
    var sources = util.getArg(sourceMap, 'sources');
    // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
    // requires the array) to play nice here.
    var names = util.getArg(sourceMap, 'names', []);
    var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
    var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
    var mappings = util.getArg(sourceMap, 'mappings');
    var file = util.getArg(sourceMap, 'file', null);

    // Once again, Sass deviates from the spec and supplies the version as a
    // string rather than a number, so we use loose equality checking here.
    if (version != this._version) {
      throw new Error('Unsupported version: ' + version);
    }

    // Pass `true` below to allow duplicate names and sources. While source maps
    // are intended to be compressed and deduplicated, the TypeScript compiler
    // sometimes generates source maps with duplicates in them. See Github issue
    // #72 and bugzil.la/889492.
    this._names = ArraySet.fromArray(names, true);
    this._sources = ArraySet.fromArray(sources, true);

    this.sourceRoot = sourceRoot;
    this.sourcesContent = sourcesContent;
    this._mappings = mappings;
    this.file = file;
  }

  /**
   * Create a SourceMapConsumer from a SourceMapGenerator.
   *
   * @param SourceMapGenerator aSourceMap
   *        The source map that will be consumed.
   * @returns SourceMapConsumer
   */
  SourceMapConsumer.fromSourceMap =
    function SourceMapConsumer_fromSourceMap(aSourceMap) {
      var smc = Object.create(SourceMapConsumer.prototype);

      smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
      smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
      smc.sourceRoot = aSourceMap._sourceRoot;
      smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
                                                              smc.sourceRoot);
      smc.file = aSourceMap._file;

      smc.__generatedMappings = aSourceMap._mappings.slice()
        .sort(util.compareByGeneratedPositions);
      smc.__originalMappings = aSourceMap._mappings.slice()
        .sort(util.compareByOriginalPositions);

      return smc;
    };

  /**
   * The version of the source mapping spec that we are consuming.
   */
  SourceMapConsumer.prototype._version = 3;

  /**
   * The list of original sources.
   */
  Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
    get: function () {
      return this._sources.toArray().map(function (s) {
        return this.sourceRoot ? util.join(this.sourceRoot, s) : s;
      }, this);
    }
  });

  // `__generatedMappings` and `__originalMappings` are arrays that hold the
  // parsed mapping coordinates from the source map's "mappings" attribute. They
  // are lazily instantiated, accessed via the `_generatedMappings` and
  // `_originalMappings` getters respectively, and we only parse the mappings
  // and create these arrays once queried for a source location. We jump through
  // these hoops because there can be many thousands of mappings, and parsing
  // them is expensive, so we only want to do it if we must.
  //
  // Each object in the arrays is of the form:
  //
  //     {
  //       generatedLine: The line number in the generated code,
  //       generatedColumn: The column number in the generated code,
  //       source: The path to the original source file that generated this
  //               chunk of code,
  //       originalLine: The line number in the original source that
  //                     corresponds to this chunk of generated code,
  //       originalColumn: The column number in the original source that
  //                       corresponds to this chunk of generated code,
  //       name: The name of the original symbol which generated this chunk of
  //             code.
  //     }
  //
  // All properties except for `generatedLine` and `generatedColumn` can be
  // `null`.
  //
  // `_generatedMappings` is ordered by the generated positions.
  //
  // `_originalMappings` is ordered by the original positions.

  SourceMapConsumer.prototype.__generatedMappings = null;
  Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
    get: function () {
      if (!this.__generatedMappings) {
        this.__generatedMappings = [];
        this.__originalMappings = [];
        this._parseMappings(this._mappings, this.sourceRoot);
      }

      return this.__generatedMappings;
    }
  });

  SourceMapConsumer.prototype.__originalMappings = null;
  Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
    get: function () {
      if (!this.__originalMappings) {
        this.__generatedMappings = [];
        this.__originalMappings = [];
        this._parseMappings(this._mappings, this.sourceRoot);
      }

      return this.__originalMappings;
    }
  });

  /**
   * Parse the mappings in a string in to a data structure which we can easily
   * query (the ordered arrays in the `this.__generatedMappings` and
   * `this.__originalMappings` properties).
   */
  SourceMapConsumer.prototype._parseMappings =
    function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
      var generatedLine = 1;
      var previousGeneratedColumn = 0;
      var previousOriginalLine = 0;
      var previousOriginalColumn = 0;
      var previousSource = 0;
      var previousName = 0;
      var mappingSeparator = /^[,;]/;
      var str = aStr;
      var mapping;
      var temp;

      while (str.length > 0) {
        if (str.charAt(0) === ';') {
          generatedLine++;
          str = str.slice(1);
          previousGeneratedColumn = 0;
        }
        else if (str.charAt(0) === ',') {
          str = str.slice(1);
        }
        else {
          mapping = {};
          mapping.generatedLine = generatedLine;

          // Generated column.
          temp = base64VLQ.decode(str);
          mapping.generatedColumn = previousGeneratedColumn + temp.value;
          previousGeneratedColumn = mapping.generatedColumn;
          str = temp.rest;

          if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
            // Original source.
            temp = base64VLQ.decode(str);
            mapping.source = this._sources.at(previousSource + temp.value);
            previousSource += temp.value;
            str = temp.rest;
            if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
              throw new Error('Found a source, but no line and column');
            }

            // Original line.
            temp = base64VLQ.decode(str);
            mapping.originalLine = previousOriginalLine + temp.value;
            previousOriginalLine = mapping.originalLine;
            // Lines are stored 0-based
            mapping.originalLine += 1;
            str = temp.rest;
            if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
              throw new Error('Found a source and line, but no column');
            }

            // Original column.
            temp = base64VLQ.decode(str);
            mapping.originalColumn = previousOriginalColumn + temp.value;
            previousOriginalColumn = mapping.originalColumn;
            str = temp.rest;

            if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
              // Original name.
              temp = base64VLQ.decode(str);
              mapping.name = this._names.at(previousName + temp.value);
              previousName += temp.value;
              str = temp.rest;
            }
          }

          this.__generatedMappings.push(mapping);
          if (typeof mapping.originalLine === 'number') {
            this.__originalMappings.push(mapping);
          }
        }
      }

      this.__generatedMappings.sort(util.compareByGeneratedPositions);
      this.__originalMappings.sort(util.compareByOriginalPositions);
    };

  /**
   * Find the mapping that best matches the hypothetical "needle" mapping that
   * we are searching for in the given "haystack" of mappings.
   */
  SourceMapConsumer.prototype._findMapping =
    function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
                                           aColumnName, aComparator) {
      // To return the position we are searching for, we must first find the
      // mapping for the given position and then return the opposite position it
      // points to. Because the mappings are sorted, we can use binary search to
      // find the best mapping.

      if (aNeedle[aLineName] <= 0) {
        throw new TypeError('Line must be greater than or equal to 1, got '
                            + aNeedle[aLineName]);
      }
      if (aNeedle[aColumnName] < 0) {
        throw new TypeError('Column must be greater than or equal to 0, got '
                            + aNeedle[aColumnName]);
      }

      return binarySearch.search(aNeedle, aMappings, aComparator);
    };

  /**
   * Returns the original source, line, and column information for the generated
   * source's line and column positions provided. The only argument is an object
   * with the following properties:
   *
   *   - line: The line number in the generated source.
   *   - column: The column number in the generated source.
   *
   * and an object is returned with the following properties:
   *
   *   - source: The original source file, or null.
   *   - line: The line number in the original source, or null.
   *   - column: The column number in the original source, or null.
   *   - name: The original identifier, or null.
   */
  SourceMapConsumer.prototype.originalPositionFor =
    function SourceMapConsumer_originalPositionFor(aArgs) {
      var needle = {
        generatedLine: util.getArg(aArgs, 'line'),
        generatedColumn: util.getArg(aArgs, 'column')
      };

      var mapping = this._findMapping(needle,
                                      this._generatedMappings,
                                      "generatedLine",
                                      "generatedColumn",
                                      util.compareByGeneratedPositions);

      if (mapping) {
        var source = util.getArg(mapping, 'source', null);
        if (source && this.sourceRoot) {
          source = util.join(this.sourceRoot, source);
        }
        return {
          source: source,
          line: util.getArg(mapping, 'originalLine', null),
          column: util.getArg(mapping, 'originalColumn', null),
          name: util.getArg(mapping, 'name', null)
        };
      }

      return {
        source: null,
        line: null,
        column: null,
        name: null
      };
    };

  /**
   * Returns the original source content. The only argument is the url of the
   * original source file. Returns null if no original source content is
   * availible.
   */
  SourceMapConsumer.prototype.sourceContentFor =
    function SourceMapConsumer_sourceContentFor(aSource) {
      if (!this.sourcesContent) {
        return null;
      }

      if (this.sourceRoot) {
        aSource = util.relative(this.sourceRoot, aSource);
      }

      if (this._sources.has(aSource)) {
        return this.sourcesContent[this._sources.indexOf(aSource)];
      }

      var url;
      if (this.sourceRoot
          && (url = util.urlParse(this.sourceRoot))) {
        // XXX: file:// URIs and absolute paths lead to unexpected behavior for
        // many users. We can help them out when they expect file:// URIs to
        // behave like it would if they were running a local HTTP server. See
        // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
        var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
        if (url.scheme == "file"
            && this._sources.has(fileUriAbsPath)) {
          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
        }

        if ((!url.path || url.path == "/")
            && this._sources.has("/" + aSource)) {
          return this.sourcesContent[this._sources.indexOf("/" + aSource)];
        }
      }

      throw new Error('"' + aSource + '" is not in the SourceMap.');
    };

  /**
   * Returns the generated line and column information for the original source,
   * line, and column positions provided. The only argument is an object with
   * the following properties:
   *
   *   - source: The filename of the original source.
   *   - line: The line number in the original source.
   *   - column: The column number in the original source.
   *
   * and an object is returned with the following properties:
   *
   *   - line: The line number in the generated source, or null.
   *   - column: The column number in the generated source, or null.
   */
  SourceMapConsumer.prototype.generatedPositionFor =
    function SourceMapConsumer_generatedPositionFor(aArgs) {
      var needle = {
        source: util.getArg(aArgs, 'source'),
        originalLine: util.getArg(aArgs, 'line'),
        originalColumn: util.getArg(aArgs, 'column')
      };

      if (this.sourceRoot) {
        needle.source = util.relative(this.sourceRoot, needle.source);
      }

      var mapping = this._findMapping(needle,
                                      this._originalMappings,
                                      "originalLine",
                                      "originalColumn",
                                      util.compareByOriginalPositions);

      if (mapping) {
        return {
          line: util.getArg(mapping, 'generatedLine', null),
          column: util.getArg(mapping, 'generatedColumn', null)
        };
      }

      return {
        line: null,
        column: null
      };
    };

  SourceMapConsumer.GENERATED_ORDER = 1;
  SourceMapConsumer.ORIGINAL_ORDER = 2;

  /**
   * Iterate over each mapping between an original source/line/column and a
   * generated line/column in this source map.
   *
   * @param Function aCallback
   *        The function that is called with each mapping.
   * @param Object aContext
   *        Optional. If specified, this object will be the value of `this` every
   *        time that `aCallback` is called.
   * @param aOrder
   *        Either `SourceMapConsumer.GENERATED_ORDER` or
   *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
   *        iterate over the mappings sorted by the generated file's line/column
   *        order or the original's source/line/column order, respectively. Defaults to
   *        `SourceMapConsumer.GENERATED_ORDER`.
   */
  SourceMapConsumer.prototype.eachMapping =
    function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
      var context = aContext || null;
      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;

      var mappings;
      switch (order) {
      case SourceMapConsumer.GENERATED_ORDER:
        mappings = this._generatedMappings;
        break;
      case SourceMapConsumer.ORIGINAL_ORDER:
        mappings = this._originalMappings;
        break;
      default:
        throw new Error("Unknown order of iteration.");
      }

      var sourceRoot = this.sourceRoot;
      mappings.map(function (mapping) {
        var source = mapping.source;
        if (source && sourceRoot) {
          source = util.join(sourceRoot, source);
        }
        return {
          source: source,
          generatedLine: mapping.generatedLine,
          generatedColumn: mapping.generatedColumn,
          originalLine: mapping.originalLine,
          originalColumn: mapping.originalColumn,
          name: mapping.name
        };
      }).forEach(aCallback, context);
    };

  exports.SourceMapConsumer = SourceMapConsumer;

});

},{"./array-set":44,"./base64-vlq":45,"./binary-search":47,"./util":51,"amdefine":7}],49:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  var base64VLQ = require('./base64-vlq');
  var util = require('./util');
  var ArraySet = require('./array-set').ArraySet;

  /**
   * An instance of the SourceMapGenerator represents a source map which is
   * being built incrementally. To create a new one, you must pass an object
   * with the following properties:
   *
   *   - file: The filename of the generated source.
   *   - sourceRoot: An optional root for all URLs in this source map.
   */
  function SourceMapGenerator(aArgs) {
    this._file = util.getArg(aArgs, 'file');
    this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
    this._sources = new ArraySet();
    this._names = new ArraySet();
    this._mappings = [];
    this._sourcesContents = null;
  }

  SourceMapGenerator.prototype._version = 3;

  /**
   * Creates a new SourceMapGenerator based on a SourceMapConsumer
   *
   * @param aSourceMapConsumer The SourceMap.
   */
  SourceMapGenerator.fromSourceMap =
    function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
      var sourceRoot = aSourceMapConsumer.sourceRoot;
      var generator = new SourceMapGenerator({
        file: aSourceMapConsumer.file,
        sourceRoot: sourceRoot
      });
      aSourceMapConsumer.eachMapping(function (mapping) {
        var newMapping = {
          generated: {
            line: mapping.generatedLine,
            column: mapping.generatedColumn
          }
        };

        if (mapping.source) {
          newMapping.source = mapping.source;
          if (sourceRoot) {
            newMapping.source = util.relative(sourceRoot, newMapping.source);
          }

          newMapping.original = {
            line: mapping.originalLine,
            column: mapping.originalColumn
          };

          if (mapping.name) {
            newMapping.name = mapping.name;
          }
        }

        generator.addMapping(newMapping);
      });
      aSourceMapConsumer.sources.forEach(function (sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content) {
          generator.setSourceContent(sourceFile, content);
        }
      });
      return generator;
    };

  /**
   * Add a single mapping from original source line and column to the generated
   * source's line and column for this source map being created. The mapping
   * object should have the following properties:
   *
   *   - generated: An object with the generated line and column positions.
   *   - original: An object with the original line and column positions.
   *   - source: The original source file (relative to the sourceRoot).
   *   - name: An optional original token name for this mapping.
   */
  SourceMapGenerator.prototype.addMapping =
    function SourceMapGenerator_addMapping(aArgs) {
      var generated = util.getArg(aArgs, 'generated');
      var original = util.getArg(aArgs, 'original', null);
      var source = util.getArg(aArgs, 'source', null);
      var name = util.getArg(aArgs, 'name', null);

      this._validateMapping(generated, original, source, name);

      if (source && !this._sources.has(source)) {
        this._sources.add(source);
      }

      if (name && !this._names.has(name)) {
        this._names.add(name);
      }

      this._mappings.push({
        generatedLine: generated.line,
        generatedColumn: generated.column,
        originalLine: original != null && original.line,
        originalColumn: original != null && original.column,
        source: source,
        name: name
      });
    };

  /**
   * Set the source content for a source file.
   */
  SourceMapGenerator.prototype.setSourceContent =
    function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
      var source = aSourceFile;
      if (this._sourceRoot) {
        source = util.relative(this._sourceRoot, source);
      }

      if (aSourceContent !== null) {
        // Add the source content to the _sourcesContents map.
        // Create a new _sourcesContents map if the property is null.
        if (!this._sourcesContents) {
          this._sourcesContents = {};
        }
        this._sourcesContents[util.toSetString(source)] = aSourceContent;
      } else {
        // Remove the source file from the _sourcesContents map.
        // If the _sourcesContents map is empty, set the property to null.
        delete this._sourcesContents[util.toSetString(source)];
        if (Object.keys(this._sourcesContents).length === 0) {
          this._sourcesContents = null;
        }
      }
    };

  /**
   * Applies the mappings of a sub-source-map for a specific source file to the
   * source map being generated. Each mapping to the supplied source file is
   * rewritten using the supplied source map. Note: The resolution for the
   * resulting mappings is the minimium of this map and the supplied map.
   *
   * @param aSourceMapConsumer The source map to be applied.
   * @param aSourceFile Optional. The filename of the source file.
   *        If omitted, SourceMapConsumer's file property will be used.
   */
  SourceMapGenerator.prototype.applySourceMap =
    function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile) {
      // If aSourceFile is omitted, we will use the file property of the SourceMap
      if (!aSourceFile) {
        aSourceFile = aSourceMapConsumer.file;
      }
      var sourceRoot = this._sourceRoot;
      // Make "aSourceFile" relative if an absolute Url is passed.
      if (sourceRoot) {
        aSourceFile = util.relative(sourceRoot, aSourceFile);
      }
      // Applying the SourceMap can add and remove items from the sources and
      // the names array.
      var newSources = new ArraySet();
      var newNames = new ArraySet();

      // Find mappings for the "aSourceFile"
      this._mappings.forEach(function (mapping) {
        if (mapping.source === aSourceFile && mapping.originalLine) {
          // Check if it can be mapped by the source map, then update the mapping.
          var original = aSourceMapConsumer.originalPositionFor({
            line: mapping.originalLine,
            column: mapping.originalColumn
          });
          if (original.source !== null) {
            // Copy mapping
            if (sourceRoot) {
              mapping.source = util.relative(sourceRoot, original.source);
            } else {
              mapping.source = original.source;
            }
            mapping.originalLine = original.line;
            mapping.originalColumn = original.column;
            if (original.name !== null && mapping.name !== null) {
              // Only use the identifier name if it's an identifier
              // in both SourceMaps
              mapping.name = original.name;
            }
          }
        }

        var source = mapping.source;
        if (source && !newSources.has(source)) {
          newSources.add(source);
        }

        var name = mapping.name;
        if (name && !newNames.has(name)) {
          newNames.add(name);
        }

      }, this);
      this._sources = newSources;
      this._names = newNames;

      // Copy sourcesContents of applied map.
      aSourceMapConsumer.sources.forEach(function (sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content) {
          if (sourceRoot) {
            sourceFile = util.relative(sourceRoot, sourceFile);
          }
          this.setSourceContent(sourceFile, content);
        }
      }, this);
    };

  /**
   * A mapping can have one of the three levels of data:
   *
   *   1. Just the generated position.
   *   2. The Generated position, original position, and original source.
   *   3. Generated and original position, original source, as well as a name
   *      token.
   *
   * To maintain consistency, we validate that any new mapping being added falls
   * in to one of these categories.
   */
  SourceMapGenerator.prototype._validateMapping =
    function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
                                                aName) {
      if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
          && aGenerated.line > 0 && aGenerated.column >= 0
          && !aOriginal && !aSource && !aName) {
        // Case 1.
        return;
      }
      else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
               && aOriginal && 'line' in aOriginal && 'column' in aOriginal
               && aGenerated.line > 0 && aGenerated.column >= 0
               && aOriginal.line > 0 && aOriginal.column >= 0
               && aSource) {
        // Cases 2 and 3.
        return;
      }
      else {
        throw new Error('Invalid mapping: ' + JSON.stringify({
          generated: aGenerated,
          source: aSource,
          original: aOriginal,
          name: aName
        }));
      }
    };

  /**
   * Serialize the accumulated mappings in to the stream of base 64 VLQs
   * specified by the source map format.
   */
  SourceMapGenerator.prototype._serializeMappings =
    function SourceMapGenerator_serializeMappings() {
      var previousGeneratedColumn = 0;
      var previousGeneratedLine = 1;
      var previousOriginalColumn = 0;
      var previousOriginalLine = 0;
      var previousName = 0;
      var previousSource = 0;
      var result = '';
      var mapping;

      // The mappings must be guaranteed to be in sorted order before we start
      // serializing them or else the generated line numbers (which are defined
      // via the ';' separators) will be all messed up. Note: it might be more
      // performant to maintain the sorting as we insert them, rather than as we
      // serialize them, but the big O is the same either way.
      this._mappings.sort(util.compareByGeneratedPositions);

      for (var i = 0, len = this._mappings.length; i < len; i++) {
        mapping = this._mappings[i];

        if (mapping.generatedLine !== previousGeneratedLine) {
          previousGeneratedColumn = 0;
          while (mapping.generatedLine !== previousGeneratedLine) {
            result += ';';
            previousGeneratedLine++;
          }
        }
        else {
          if (i > 0) {
            if (!util.compareByGeneratedPositions(mapping, this._mappings[i - 1])) {
              continue;
            }
            result += ',';
          }
        }

        result += base64VLQ.encode(mapping.generatedColumn
                                   - previousGeneratedColumn);
        previousGeneratedColumn = mapping.generatedColumn;

        if (mapping.source) {
          result += base64VLQ.encode(this._sources.indexOf(mapping.source)
                                     - previousSource);
          previousSource = this._sources.indexOf(mapping.source);

          // lines are stored 0-based in SourceMap spec version 3
          result += base64VLQ.encode(mapping.originalLine - 1
                                     - previousOriginalLine);
          previousOriginalLine = mapping.originalLine - 1;

          result += base64VLQ.encode(mapping.originalColumn
                                     - previousOriginalColumn);
          previousOriginalColumn = mapping.originalColumn;

          if (mapping.name) {
            result += base64VLQ.encode(this._names.indexOf(mapping.name)
                                       - previousName);
            previousName = this._names.indexOf(mapping.name);
          }
        }
      }

      return result;
    };

  SourceMapGenerator.prototype._generateSourcesContent =
    function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
      return aSources.map(function (source) {
        if (!this._sourcesContents) {
          return null;
        }
        if (aSourceRoot) {
          source = util.relative(aSourceRoot, source);
        }
        var key = util.toSetString(source);
        return Object.prototype.hasOwnProperty.call(this._sourcesContents,
                                                    key)
          ? this._sourcesContents[key]
          : null;
      }, this);
    };

  /**
   * Externalize the source map.
   */
  SourceMapGenerator.prototype.toJSON =
    function SourceMapGenerator_toJSON() {
      var map = {
        version: this._version,
        file: this._file,
        sources: this._sources.toArray(),
        names: this._names.toArray(),
        mappings: this._serializeMappings()
      };
      if (this._sourceRoot) {
        map.sourceRoot = this._sourceRoot;
      }
      if (this._sourcesContents) {
        map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
      }

      return map;
    };

  /**
   * Render the source map being generated to a string.
   */
  SourceMapGenerator.prototype.toString =
    function SourceMapGenerator_toString() {
      return JSON.stringify(this);
    };

  exports.SourceMapGenerator = SourceMapGenerator;

});

},{"./array-set":44,"./base64-vlq":45,"./util":51,"amdefine":7}],50:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
  var util = require('./util');

  /**
   * SourceNodes provide a way to abstract over interpolating/concatenating
   * snippets of generated JavaScript source code while maintaining the line and
   * column information associated with the original source code.
   *
   * @param aLine The original line number.
   * @param aColumn The original column number.
   * @param aSource The original source's filename.
   * @param aChunks Optional. An array of strings which are snippets of
   *        generated JS, or other SourceNodes.
   * @param aName The original identifier.
   */
  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
    this.children = [];
    this.sourceContents = {};
    this.line = aLine === undefined ? null : aLine;
    this.column = aColumn === undefined ? null : aColumn;
    this.source = aSource === undefined ? null : aSource;
    this.name = aName === undefined ? null : aName;
    if (aChunks != null) this.add(aChunks);
  }

  /**
   * Creates a SourceNode from generated code and a SourceMapConsumer.
   *
   * @param aGeneratedCode The generated code
   * @param aSourceMapConsumer The SourceMap for the generated code
   */
  SourceNode.fromStringWithSourceMap =
    function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) {
      // The SourceNode we want to fill with the generated code
      // and the SourceMap
      var node = new SourceNode();

      // The generated code
      // Processed fragments are removed from this array.
      var remainingLines = aGeneratedCode.split('\n');

      // We need to remember the position of "remainingLines"
      var lastGeneratedLine = 1, lastGeneratedColumn = 0;

      // The generate SourceNodes we need a code range.
      // To extract it current and last mapping is used.
      // Here we store the last mapping.
      var lastMapping = null;

      aSourceMapConsumer.eachMapping(function (mapping) {
        if (lastMapping === null) {
          // We add the generated code until the first mapping
          // to the SourceNode without any mapping.
          // Each line is added as separate string.
          while (lastGeneratedLine < mapping.generatedLine) {
            node.add(remainingLines.shift() + "\n");
            lastGeneratedLine++;
          }
          if (lastGeneratedColumn < mapping.generatedColumn) {
            var nextLine = remainingLines[0];
            node.add(nextLine.substr(0, mapping.generatedColumn));
            remainingLines[0] = nextLine.substr(mapping.generatedColumn);
            lastGeneratedColumn = mapping.generatedColumn;
          }
        } else {
          // We add the code from "lastMapping" to "mapping":
          // First check if there is a new line in between.
          if (lastGeneratedLine < mapping.generatedLine) {
            var code = "";
            // Associate full lines with "lastMapping"
            do {
              code += remainingLines.shift() + "\n";
              lastGeneratedLine++;
              lastGeneratedColumn = 0;
            } while (lastGeneratedLine < mapping.generatedLine);
            // When we reached the correct line, we add code until we
            // reach the correct column too.
            if (lastGeneratedColumn < mapping.generatedColumn) {
              var nextLine = remainingLines[0];
              code += nextLine.substr(0, mapping.generatedColumn);
              remainingLines[0] = nextLine.substr(mapping.generatedColumn);
              lastGeneratedColumn = mapping.generatedColumn;
            }
            // Create the SourceNode.
            addMappingWithCode(lastMapping, code);
          } else {
            // There is no new line in between.
            // Associate the code between "lastGeneratedColumn" and
            // "mapping.generatedColumn" with "lastMapping"
            var nextLine = remainingLines[0];
            var code = nextLine.substr(0, mapping.generatedColumn -
                                          lastGeneratedColumn);
            remainingLines[0] = nextLine.substr(mapping.generatedColumn -
                                                lastGeneratedColumn);
            lastGeneratedColumn = mapping.generatedColumn;
            addMappingWithCode(lastMapping, code);
          }
        }
        lastMapping = mapping;
      }, this);
      // We have processed all mappings.
      // Associate the remaining code in the current line with "lastMapping"
      // and add the remaining lines without any mapping
      addMappingWithCode(lastMapping, remainingLines.join("\n"));

      // Copy sourcesContent into SourceNode
      aSourceMapConsumer.sources.forEach(function (sourceFile) {
        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
        if (content) {
          node.setSourceContent(sourceFile, content);
        }
      });

      return node;

      function addMappingWithCode(mapping, code) {
        if (mapping === null || mapping.source === undefined) {
          node.add(code);
        } else {
          node.add(new SourceNode(mapping.originalLine,
                                  mapping.originalColumn,
                                  mapping.source,
                                  code,
                                  mapping.name));
        }
      }
    };

  /**
   * Add a chunk of generated JS to this source node.
   *
   * @param aChunk A string snippet of generated JS code, another instance of
   *        SourceNode, or an array where each member is one of those things.
   */
  SourceNode.prototype.add = function SourceNode_add(aChunk) {
    if (Array.isArray(aChunk)) {
      aChunk.forEach(function (chunk) {
        this.add(chunk);
      }, this);
    }
    else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
      if (aChunk) {
        this.children.push(aChunk);
      }
    }
    else {
      throw new TypeError(
        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
      );
    }
    return this;
  };

  /**
   * Add a chunk of generated JS to the beginning of this source node.
   *
   * @param aChunk A string snippet of generated JS code, another instance of
   *        SourceNode, or an array where each member is one of those things.
   */
  SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
    if (Array.isArray(aChunk)) {
      for (var i = aChunk.length-1; i >= 0; i--) {
        this.prepend(aChunk[i]);
      }
    }
    else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
      this.children.unshift(aChunk);
    }
    else {
      throw new TypeError(
        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
      );
    }
    return this;
  };

  /**
   * Walk over the tree of JS snippets in this node and its children. The
   * walking function is called once for each snippet of JS and is passed that
   * snippet and the its original associated source's line/column location.
   *
   * @param aFn The traversal function.
   */
  SourceNode.prototype.walk = function SourceNode_walk(aFn) {
    var chunk;
    for (var i = 0, len = this.children.length; i < len; i++) {
      chunk = this.children[i];
      if (chunk instanceof SourceNode) {
        chunk.walk(aFn);
      }
      else {
        if (chunk !== '') {
          aFn(chunk, { source: this.source,
                       line: this.line,
                       column: this.column,
                       name: this.name });
        }
      }
    }
  };

  /**
   * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
   * each of `this.children`.
   *
   * @param aSep The separator.
   */
  SourceNode.prototype.join = function SourceNode_join(aSep) {
    var newChildren;
    var i;
    var len = this.children.length;
    if (len > 0) {
      newChildren = [];
      for (i = 0; i < len-1; i++) {
        newChildren.push(this.children[i]);
        newChildren.push(aSep);
      }
      newChildren.push(this.children[i]);
      this.children = newChildren;
    }
    return this;
  };

  /**
   * Call String.prototype.replace on the very right-most source snippet. Useful
   * for trimming whitespace from the end of a source node, etc.
   *
   * @param aPattern The pattern to replace.
   * @param aReplacement The thing to replace the pattern with.
   */
  SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
    var lastChild = this.children[this.children.length - 1];
    if (lastChild instanceof SourceNode) {
      lastChild.replaceRight(aPattern, aReplacement);
    }
    else if (typeof lastChild === 'string') {
      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
    }
    else {
      this.children.push(''.replace(aPattern, aReplacement));
    }
    return this;
  };

  /**
   * Set the source content for a source file. This will be added to the SourceMapGenerator
   * in the sourcesContent field.
   *
   * @param aSourceFile The filename of the source file
   * @param aSourceContent The content of the source file
   */
  SourceNode.prototype.setSourceContent =
    function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
      this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
    };

  /**
   * Walk over the tree of SourceNodes. The walking function is called for each
   * source file content and is passed the filename and source content.
   *
   * @param aFn The traversal function.
   */
  SourceNode.prototype.walkSourceContents =
    function SourceNode_walkSourceContents(aFn) {
      for (var i = 0, len = this.children.length; i < len; i++) {
        if (this.children[i] instanceof SourceNode) {
          this.children[i].walkSourceContents(aFn);
        }
      }

      var sources = Object.keys(this.sourceContents);
      for (var i = 0, len = sources.length; i < len; i++) {
        aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
      }
    };

  /**
   * Return the string representation of this source node. Walks over the tree
   * and concatenates all the various snippets together to one string.
   */
  SourceNode.prototype.toString = function SourceNode_toString() {
    var str = "";
    this.walk(function (chunk) {
      str += chunk;
    });
    return str;
  };

  /**
   * Returns the string representation of this source node along with a source
   * map.
   */
  SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
    var generated = {
      code: "",
      line: 1,
      column: 0
    };
    var map = new SourceMapGenerator(aArgs);
    var sourceMappingActive = false;
    var lastOriginalSource = null;
    var lastOriginalLine = null;
    var lastOriginalColumn = null;
    var lastOriginalName = null;
    this.walk(function (chunk, original) {
      generated.code += chunk;
      if (original.source !== null
          && original.line !== null
          && original.column !== null) {
        if(lastOriginalSource !== original.source
           || lastOriginalLine !== original.line
           || lastOriginalColumn !== original.column
           || lastOriginalName !== original.name) {
          map.addMapping({
            source: original.source,
            original: {
              line: original.line,
              column: original.column
            },
            generated: {
              line: generated.line,
              column: generated.column
            },
            name: original.name
          });
        }
        lastOriginalSource = original.source;
        lastOriginalLine = original.line;
        lastOriginalColumn = original.column;
        lastOriginalName = original.name;
        sourceMappingActive = true;
      } else if (sourceMappingActive) {
        map.addMapping({
          generated: {
            line: generated.line,
            column: generated.column
          }
        });
        lastOriginalSource = null;
        sourceMappingActive = false;
      }
      chunk.split('').forEach(function (ch) {
        if (ch === '\n') {
          generated.line++;
          generated.column = 0;
        } else {
          generated.column++;
        }
      });
    });
    this.walkSourceContents(function (sourceFile, sourceContent) {
      map.setSourceContent(sourceFile, sourceContent);
    });

    return { code: generated.code, map: map };
  };

  exports.SourceNode = SourceNode;

});

},{"./source-map-generator":49,"./util":51,"amdefine":7}],51:[function(require,module,exports){
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
if (typeof define !== 'function') {
    var define = require('amdefine')(module, require);
}
define(function (require, exports, module) {

  /**
   * This is a helper function for getting values from parameter/options
   * objects.
   *
   * @param args The object we are extracting values from
   * @param name The name of the property we are getting.
   * @param defaultValue An optional value to return if the property is missing
   * from the object. If this is not specified and the property is missing, an
   * error will be thrown.
   */
  function getArg(aArgs, aName, aDefaultValue) {
    if (aName in aArgs) {
      return aArgs[aName];
    } else if (arguments.length === 3) {
      return aDefaultValue;
    } else {
      throw new Error('"' + aName + '" is a required argument.');
    }
  }
  exports.getArg = getArg;

  var urlRegexp = /([\w+\-.]+):\/\/((\w+:\w+)@)?([\w.]+)?(:(\d+))?(\S+)?/;
  var dataUrlRegexp = /^data:.+\,.+/;

  function urlParse(aUrl) {
    var match = aUrl.match(urlRegexp);
    if (!match) {
      return null;
    }
    return {
      scheme: match[1],
      auth: match[3],
      host: match[4],
      port: match[6],
      path: match[7]
    };
  }
  exports.urlParse = urlParse;

  function urlGenerate(aParsedUrl) {
    var url = aParsedUrl.scheme + "://";
    if (aParsedUrl.auth) {
      url += aParsedUrl.auth + "@"
    }
    if (aParsedUrl.host) {
      url += aParsedUrl.host;
    }
    if (aParsedUrl.port) {
      url += ":" + aParsedUrl.port
    }
    if (aParsedUrl.path) {
      url += aParsedUrl.path;
    }
    return url;
  }
  exports.urlGenerate = urlGenerate;

  function join(aRoot, aPath) {
    var url;

    if (aPath.match(urlRegexp) || aPath.match(dataUrlRegexp)) {
      return aPath;
    }

    if (aPath.charAt(0) === '/' && (url = urlParse(aRoot))) {
      url.path = aPath;
      return urlGenerate(url);
    }

    return aRoot.replace(/\/$/, '') + '/' + aPath;
  }
  exports.join = join;

  /**
   * Because behavior goes wacky when you set `__proto__` on objects, we
   * have to prefix all the strings in our set with an arbitrary character.
   *
   * See https://github.com/mozilla/source-map/pull/31 and
   * https://github.com/mozilla/source-map/issues/30
   *
   * @param String aStr
   */
  function toSetString(aStr) {
    return '$' + aStr;
  }
  exports.toSetString = toSetString;

  function fromSetString(aStr) {
    return aStr.substr(1);
  }
  exports.fromSetString = fromSetString;

  function relative(aRoot, aPath) {
    aRoot = aRoot.replace(/\/$/, '');

    var url = urlParse(aRoot);
    if (aPath.charAt(0) == "/" && url && url.path == "/") {
      return aPath.slice(1);
    }

    return aPath.indexOf(aRoot + '/') === 0
      ? aPath.substr(aRoot.length + 1)
      : aPath;
  }
  exports.relative = relative;

  function strcmp(aStr1, aStr2) {
    var s1 = aStr1 || "";
    var s2 = aStr2 || "";
    return (s1 > s2) - (s1 < s2);
  }

  /**
   * Comparator between two mappings where the original positions are compared.
   *
   * Optionally pass in `true` as `onlyCompareGenerated` to consider two
   * mappings with the same original source/line/column, but different generated
   * line and column the same. Useful when searching for a mapping with a
   * stubbed out mapping.
   */
  function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
    var cmp;

    cmp = strcmp(mappingA.source, mappingB.source);
    if (cmp) {
      return cmp;
    }

    cmp = mappingA.originalLine - mappingB.originalLine;
    if (cmp) {
      return cmp;
    }

    cmp = mappingA.originalColumn - mappingB.originalColumn;
    if (cmp || onlyCompareOriginal) {
      return cmp;
    }

    cmp = strcmp(mappingA.name, mappingB.name);
    if (cmp) {
      return cmp;
    }

    cmp = mappingA.generatedLine - mappingB.generatedLine;
    if (cmp) {
      return cmp;
    }

    return mappingA.generatedColumn - mappingB.generatedColumn;
  };
  exports.compareByOriginalPositions = compareByOriginalPositions;

  /**
   * Comparator between two mappings where the generated positions are
   * compared.
   *
   * Optionally pass in `true` as `onlyCompareGenerated` to consider two
   * mappings with the same generated line and column, but different
   * source/name/original line and column the same. Useful when searching for a
   * mapping with a stubbed out mapping.
   */
  function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
    var cmp;

    cmp = mappingA.generatedLine - mappingB.generatedLine;
    if (cmp) {
      return cmp;
    }

    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
    if (cmp || onlyCompareGenerated) {
      return cmp;
    }

    cmp = strcmp(mappingA.source, mappingB.source);
    if (cmp) {
      return cmp;
    }

    cmp = mappingA.originalLine - mappingB.originalLine;
    if (cmp) {
      return cmp;
    }

    cmp = mappingA.originalColumn - mappingB.originalColumn;
    if (cmp) {
      return cmp;
    }

    return strcmp(mappingA.name, mappingB.name);
  };
  exports.compareByGeneratedPositions = compareByGeneratedPositions;

});

},{"amdefine":7}],52:[function(require,module,exports){
(function (process,Buffer){
var SourceMapConsumer = require('source-map').SourceMapConsumer;
var path = require('path');
var fs = require('fs');
// Only install once if called multiple times
var errorFormatterInstalled = false;
var uncaughtShimInstalled = false;
// If true, the caches are reset before a stack trace formatting operation
var emptyCacheBetweenOperations = false;
// Supports {browser, node, auto}
var environment = "auto";
// Maps a file path to a string containing the file contents
var fileContentsCache = {};
// Maps a file path to a source map for that file
var sourceMapCache = {};
// Regex for detecting source maps
var reSourceMap = /^data:application\/json[^,]+base64,/;
// Priority list of retrieve handlers
var retrieveFileHandlers = [];
var retrieveMapHandlers = [];
function isInBrowser() {
    if (environment === "browser")
        return true;
    if (environment === "node")
        return false;
    return ((typeof window !== 'undefined') && (typeof XMLHttpRequest === 'function'));
}
function hasGlobalProcessEventEmitter() {
    return ((typeof process === 'object') && (process !== null) && (typeof process.on === 'function'));
}
function handlerExec(list) {
    return function (arg) {
        for (var i = 0; i < list.length; i++) {
            var ret = list[i](arg);
            if (ret) {
                return ret;
            }
        }
        return null;
    };
}
var retrieveFile = handlerExec(retrieveFileHandlers);
retrieveFileHandlers.push(function (path) {
    // Trim the path to make sure there is no extra whitespace.
    path = path.trim();
    if (path in fileContentsCache) {
        return fileContentsCache[path];
    }
    try {
        // Use SJAX if we are in the browser
        if (isInBrowser()) {
            var xhr = new XMLHttpRequest();
            xhr.open('GET', path, false);
            xhr.send(null);
            var contents = null;
            if (xhr.readyState === 4 && xhr.status === 200) {
                contents = xhr.responseText;
            }
        }
        else {
            var contents = fs.readFileSync(path, 'utf8');
        }
    }
    catch (e) {
        var contents = null;
    }
    return fileContentsCache[path] = contents;
});
// Support URLs relative to a directory, but be careful about a protocol prefix
// in case we are in the browser (i.e. directories may start with "http://")
function supportRelativeURL(file, url) {
    if (!file)
        return url;
    var dir = path.dirname(file);
    var match = /^\w+:\/\/[^\/]*/.exec(dir);
    var protocol = match ? match[0] : '';
    return protocol + path.resolve(dir.slice(protocol.length), url);
}
function retrieveSourceMapURL(source) {
    var fileData;
    if (isInBrowser()) {
        var xhr = new XMLHttpRequest();
        xhr.open('GET', source, false);
        xhr.send(null);
        fileData = xhr.readyState === 4 ? xhr.responseText : null;
        // Support providing a sourceMappingURL via the SourceMap header
        var sourceMapHeader = xhr.getResponseHeader("SourceMap") ||
            xhr.getResponseHeader("X-SourceMap");
        if (sourceMapHeader) {
            return sourceMapHeader;
        }
    }
    // Get the URL of the source map
    fileData = retrieveFile(source);
    //        
    var re = /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^\*]+?)[ \t]*(?:\*\/)[ \t]*$)/mg;
    // Keep executing the search to find the *last* sourceMappingURL to avoid
    // picking up sourceMappingURLs from comments, strings, etc.
    var lastMatch, match;
    while (match = re.exec(fileData))
        lastMatch = match;
    if (!lastMatch)
        return null;
    return lastMatch[1];
}
;
// Can be overridden by the retrieveSourceMap option to install. Takes a
// generated source filename; returns a {map, optional url} object, or null if
// there is no source map.  The map field may be either a string or the parsed
// JSON object (ie, it must be a valid argument to the SourceMapConsumer
// constructor).
var retrieveSourceMap = handlerExec(retrieveMapHandlers);
retrieveMapHandlers.push(function (source) {
    var sourceMappingURL = retrieveSourceMapURL(source);
    if (!sourceMappingURL)
        return null;
    // Read the contents of the source map
    var sourceMapData;
    if (reSourceMap.test(sourceMappingURL)) {
        // Support source map URL as a data url
        var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(',') + 1);
        sourceMapData = new Buffer(rawData, "base64").toString();
        sourceMappingURL = null;
    }
    else {
        // Support source map URLs relative to the source URL
        sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
        sourceMapData = retrieveFile(sourceMappingURL);
    }
    if (!sourceMapData) {
        return null;
    }
    return {
        url: sourceMappingURL,
        map: sourceMapData
    };
});
function mapSourcePosition(position) {
    var sourceMap = sourceMapCache[position.source];
    if (!sourceMap) {
        // Call the (overrideable) retrieveSourceMap function to get the source map.
        var urlAndMap = retrieveSourceMap(position.source);
        if (urlAndMap) {
            sourceMap = sourceMapCache[position.source] = {
                url: urlAndMap.url,
                map: new SourceMapConsumer(urlAndMap.map)
            };
            // Load all sources stored inline with the source map into the file cache
            // to pretend like they are already loaded. They may not exist on disk.
            if (sourceMap.map.sourcesContent) {
                sourceMap.map.sources.forEach(function (source, i) {
                    var contents = sourceMap.map.sourcesContent[i];
                    if (contents) {
                        var url = supportRelativeURL(sourceMap.url, source);
                        fileContentsCache[url] = contents;
                    }
                });
            }
        }
        else {
            sourceMap = sourceMapCache[position.source] = {
                url: null,
                map: null
            };
        }
    }
    // Resolve the source URL relative to the URL of the source map
    if (sourceMap && sourceMap.map) {
        var originalPosition = sourceMap.map.originalPositionFor(position);
        // Only return the original position if a matching line was found. If no
        // matching line is found then we return position instead, which will cause
        // the stack trace to print the path and line for the compiled file. It is
        // better to give a precise location in the compiled file than a vague
        // location in the original file.
        if (originalPosition.source !== null) {
            originalPosition.source = supportRelativeURL(sourceMap.url, originalPosition.source);
            return originalPosition;
        }
    }
    return position;
}
// Parses code generated by FormatEvalOrigin(), a function inside V8:
// https://code.google.com/p/v8/source/browse/trunk/src/messages.js
function mapEvalOrigin(origin) {
    // Most eval() calls are in this format
    var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
    if (match) {
        var position = mapSourcePosition({
            source: match[2],
            line: match[3],
            column: match[4] - 1
        });
        return 'eval at ' + match[1] + ' (' + position.source + ':' +
            position.line + ':' + (position.column + 1) + ')';
    }
    // Parse nested eval() calls using recursion
    match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
    if (match) {
        return 'eval at ' + match[1] + ' (' + mapEvalOrigin(match[2]) + ')';
    }
    // Make sure we still return useful information if we didn't find anything
    return origin;
}
// This is copied almost verbatim from the V8 source code at
// https://code.google.com/p/v8/source/browse/trunk/src/messages.js. The
// implementation of wrapCallSite() used to just forward to the actual source
// code of CallSite.prototype.toString but unfortunately a new release of V8
// did something to the prototype chain and broke the shim. The only fix I
// could find was copy/paste.
function CallSiteToString() {
    var fileName;
    var fileLocation = "";
    if (this.isNative()) {
        fileLocation = "native";
    }
    else {
        fileName = this.getScriptNameOrSourceURL();
        if (!fileName && this.isEval()) {
            fileLocation = this.getEvalOrigin();
            fileLocation += ", "; // Expecting source position to follow.
        }
        if (fileName) {
            fileLocation += fileName;
        }
        else {
            // Source code does not originate from a file and is not native, but we
            // can still get the source position inside the source string, e.g. in
            // an eval string.
            fileLocation += "<anonymous>";
        }
        var lineNumber = this.getLineNumber();
        if (lineNumber != null) {
            fileLocation += ":" + lineNumber;
            var columnNumber = this.getColumnNumber();
            if (columnNumber) {
                fileLocation += ":" + columnNumber;
            }
        }
    }
    var line = "";
    var functionName = this.getFunctionName();
    var addSuffix = true;
    var isConstructor = this.isConstructor();
    var isMethodCall = !(this.isToplevel() || isConstructor);
    if (isMethodCall) {
        var typeName = this.getTypeName();
        var methodName = this.getMethodName();
        if (functionName) {
            if (typeName && functionName.indexOf(typeName) != 0) {
                line += typeName + ".";
            }
            line += functionName;
            if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
                line += " [as " + methodName + "]";
            }
        }
        else {
            line += typeName + "." + (methodName || "<anonymous>");
        }
    }
    else if (isConstructor) {
        line += "new " + (functionName || "<anonymous>");
    }
    else if (functionName) {
        line += functionName;
    }
    else {
        line += fileLocation;
        addSuffix = false;
    }
    if (addSuffix) {
        line += " (" + fileLocation + ")";
    }
    return line;
}
function cloneCallSite(frame) {
    var object = {};
    Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function (name) {
        object[name] = /^(?:is|get)/.test(name) ? function () { return frame[name].call(frame); } : frame[name];
    });
    object.toString = CallSiteToString;
    return object;
}
function wrapCallSite(frame) {
    // Most call sites will return the source file from getFileName(), but code
    // passed to eval() ending in "//# sourceURL=..." will return the source file
    // from getScriptNameOrSourceURL() instead
    var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
    if (source) {
        var line = frame.getLineNumber();
        var column = frame.getColumnNumber() - 1;
        // Fix position in Node where some (internal) code is prepended.
        // See https://github.com/evanw/node-source-map-support/issues/36
        if (line === 1 && !isInBrowser() && !frame.isEval()) {
            column -= 62;
        }
        var position = mapSourcePosition({
            source: source,
            line: line,
            column: column
        });
        frame = cloneCallSite(frame);
        frame.getFileName = function () { return position.source; };
        frame.getLineNumber = function () { return position.line; };
        frame.getColumnNumber = function () { return position.column + 1; };
        frame.getScriptNameOrSourceURL = function () { return position.source; };
        return frame;
    }
    // Code called using eval() needs special handling
    var origin = frame.isEval() && frame.getEvalOrigin();
    if (origin) {
        origin = mapEvalOrigin(origin);
        frame = cloneCallSite(frame);
        frame.getEvalOrigin = function () { return origin; };
        return frame;
    }
    // If we get here then we were unable to change the source position
    return frame;
}
// This function is part of the V8 stack trace API, for more info see:
// http://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
function prepareStackTrace(error, stack) {
    if (emptyCacheBetweenOperations) {
        fileContentsCache = {};
        sourceMapCache = {};
    }
    return error + stack.map(function (frame) {
        return '\n    at ' + wrapCallSite(frame);
    }).join('');
}
// Generate position and snippet of original source with pointer
function getErrorSource(error) {
    var match = /\n    at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
    if (match) {
        var source = match[1];
        var line = +match[2];
        var column = +match[3];
        // Support the inline sourceContents inside the source map
        var contents = fileContentsCache[source];
        // Support files on disk
        if (!contents && fs.existsSync(source)) {
            contents = fs.readFileSync(source, 'utf8');
        }
        // Format the line from the original source code like node does
        if (contents) {
            var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
            if (code) {
                return source + ':' + line + '\n' + code + '\n' +
                    new Array(column).join(' ') + '^';
            }
        }
    }
    return null;
}
function printErrorAndExit(error) {
    var source = getErrorSource(error);
    if (source) {
        console.error();
        console.error(source);
    }
    console.error(error.stack);
    process.exit(1);
}
function shimEmitUncaughtException() {
    var origEmit = process.emit;
    process.emit = function (type) {
        if (type === 'uncaughtException') {
            var hasStack = (arguments[1] && arguments[1].stack);
            var hasListeners = (this.listeners(type).length > 0);
            if (hasStack && !hasListeners) {
                return printErrorAndExit(arguments[1]);
            }
        }
        return origEmit.apply(this, arguments);
    };
}
exports.wrapCallSite = wrapCallSite;
exports.getErrorSource = getErrorSource;
exports.mapSourcePosition = mapSourcePosition;
exports.retrieveSourceMap = retrieveSourceMap;
exports.install = function (options) {
    options = options || {};
    if (options.environment) {
        environment = options.environment;
        if (["node", "browser", "auto"].indexOf(environment) === -1) {
            throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}");
        }
    }
    // Allow sources to be found by methods other than reading the files
    // directly from disk.
    if (options.retrieveFile) {
        if (options.overrideRetrieveFile) {
            retrieveFileHandlers.length = 0;
        }
        retrieveFileHandlers.unshift(options.retrieveFile);
    }
    // Allow source maps to be found by methods other than reading the files
    // directly from disk.
    if (options.retrieveSourceMap) {
        if (options.overrideRetrieveSourceMap) {
            retrieveMapHandlers.length = 0;
        }
        retrieveMapHandlers.unshift(options.retrieveSourceMap);
    }
    // Configure options
    if (!emptyCacheBetweenOperations) {
        emptyCacheBetweenOperations = 'emptyCacheBetweenOperations' in options ?
            options.emptyCacheBetweenOperations : false;
    }
    // Install the error reformatter
    if (!errorFormatterInstalled) {
        errorFormatterInstalled = true;
        Error.prepareStackTrace = prepareStackTrace;
    }
    if (!uncaughtShimInstalled) {
        var installHandler = 'handleUncaughtExceptions' in options ?
            options.handleUncaughtExceptions : true;
        // Provide the option to not install the uncaught exception handler. This is
        // to support other uncaught exception handlers (in test frameworks, for
        // example). If this handler is not installed and there are no other uncaught
        // exception handlers, uncaught exceptions will be caught by node's built-in
        // exception handler and the process will still be terminated. However, the
        // generated JavaScript code will be shown above the stack trace instead of
        // the original source code.
        if (installHandler && hasGlobalProcessEventEmitter()) {
            uncaughtShimInstalled = true;
            shimEmitUncaughtException();
        }
    }
};

}).call(this,require('_process'),require("buffer").Buffer)

},{"_process":67,"buffer":63,"fs":62,"path":66,"source-map":43}],53:[function(require,module,exports){
module.exports = require('./lib/type');

},{"./lib/type":54}],54:[function(require,module,exports){
/*!
 * type-detect
 * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
 * MIT Licensed
 */
/*!
 * Primary Exports
 */
var exports = module.exports = getType;
/**
 * ### typeOf (obj)
 *
 * Use several different techniques to determine
 * the type of object being tested.
 *
 *
 * @param {Mixed} object
 * @return {String} object type
 * @api public
 */
var objectTypeRegexp = /^\[object (.*)\]$/;
function getType(obj) {
    var type = Object.prototype.toString.call(obj).match(objectTypeRegexp)[1].toLowerCase();
    // Let "new String('')" return 'object'
    if (typeof Promise === 'function' && obj instanceof Promise)
        return 'promise';
    // PhantomJS has type "DOMWindow" for null
    if (obj === null)
        return 'null';
    // PhantomJS has type "DOMWindow" for undefined
    if (obj === undefined)
        return 'undefined';
    return type;
}
exports.Library = Library;
/**
 * ### Library
 *
 * Create a repository for custom type detection.
 *
 * ```js
 * var lib = new type.Library;
 * ```
 *
 */
function Library() {
    if (!(this instanceof Library))
        return new Library();
    this.tests = {};
}
/**
 * #### .of (obj)
 *
 * Expose replacement `typeof` detection to the library.
 *
 * ```js
 * if ('string' === lib.of('hello world')) {
 *   // ...
 * }
 * ```
 *
 * @param {Mixed} object to test
 * @return {String} type
 */
Library.prototype.of = getType;
/**
 * #### .define (type, test)
 *
 * Add a test to for the `.test()` assertion.
 *
 * Can be defined as a regular expression:
 *
 * ```js
 * lib.define('int', /^[0-9]+$/);
 * ```
 *
 * ... or as a function:
 *
 * ```js
 * lib.define('bln', function (obj) {
 *   if ('boolean' === lib.of(obj)) return true;
 *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
 *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
 *   return !! ~blns.indexOf(obj);
 * });
 * ```
 *
 * @param {String} type
 * @param {RegExp|Function} test
 * @api public
 */
Library.prototype.define = function (type, test) {
    if (arguments.length === 1)
        return this.tests[type];
    this.tests[type] = test;
    return this;
};
/**
 * #### .test (obj, test)
 *
 * Assert that an object is of type. Will first
 * check natives, and if that does not pass it will
 * use the user defined custom tests.
 *
 * ```js
 * assert(lib.test('1', 'int'));
 * assert(lib.test('yes', 'bln'));
 * ```
 *
 * @param {Mixed} object
 * @param {String} type
 * @return {Boolean} result
 * @api public
 */
Library.prototype.test = function (obj, type) {
    if (type === getType(obj))
        return true;
    var test = this.tests[type];
    if (test && 'regexp' === getType(test)) {
        return test.test(obj);
    }
    else if (test && 'function' === getType(test)) {
        return test(obj);
    }
    else {
        throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
    }
};

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

},{}],56:[function(require,module,exports){
(function (global){
"use strict";
var _1 = require("../");
var chai_1 = require("chai");
var isBrowser = !!global.document;
describe("The default component", function () {
    it("should be instantiable", function () {
        var inst = new _1.Component({});
    });
    it("should store the given data", function () {
        var inst = new _1.Component({ x: 5 });
        chai_1.expect(inst.$data.x).to.equal(5);
    });
    it("should produce HTML when asked", function () {
        var inst = new _1.Component({});
        var body = inst.toString();
        chai_1.expect(body).to.contain(_1.Component.$tagName);
    });
    it("should properly serialize data", function () {
        var inst = new _1.Component({ x: 5 });
        var serialized = inst.$serializeData();
        chai_1.expect(serialized.x).to.equal(inst.$data.x);
        chai_1.expect(serialized).to.not.equal(inst.$data);
    });
    it("should be deflatable", function () {
        var inst = new _1.Component({ x: 5 });
        var deflated = inst.$deflate();
        chai_1.expect(deflated.data.x).to.equal(5);
    });
    it("should be inflatable", function () {
        var inst = new _1.Component({ x: 5 });
        var deflated = inst.$deflate();
        var reinst = _1.Component.$inflate(deflated);
        chai_1.expect(reinst.$data.x).to.equal(5);
    });
    it("should expose a consistent identifier", function () {
        var inst = new _1.Component({});
        chai_1.expect(inst.$getIdentifier()).to.equal(_1.Component.$getIdentifier(inst.$label));
    });
    it("should properly nest", function () {
        var parent = new _1.Component({});
        var child = _1.Component.$for(parent, "", {});
        chai_1.expect(parent.$children).to.contain(child);
    });
    if (isBrowser) {
        it("should have an element after being ensured", function () {
            var inst = new _1.Component({});
            inst.$ensureElement();
            chai_1.expect(inst.$element).to.be.instanceof(Element);
        });
        it("should created an element when reified", function () {
            var inst = new _1.Component({});
            inst.$reify();
            chai_1.expect(inst.$element).to.be.instanceof(Element);
        });
        it("should attach to existing elements", function () {
            var inst = new _1.Component({});
            var el = document.createElement("arm-component");
            inst.$attachTo(el);
            chai_1.expect(inst.$element).to.equal(el);
        });
    }
});

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../":6,"chai":9}],57:[function(require,module,exports){
"use strict";
require("source-map-support").install();
require("./default-component");
require("./simple-component");
require("./nesting-component");

},{"./default-component":56,"./nesting-component":58,"./simple-component":59,"source-map-support":52}],58:[function(require,module,exports){
(function (global){
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var _1 = require("../");
var chai_1 = require("chai");
var isBrowser = !!global.document;
describe("A nesting component", function () {
    var template = function (component) { return ("\n\t\tThis is a child: " + Child.$for(component, "", null) + "\n\t"); };
    var Parent = (function (_super) {
        __extends(Parent, _super);
        function Parent(data) {
            _super.call(this, data);
            Child.$for(this, "", {});
        }
        Parent = __decorate([
            _1.TagName("parent-component"),
            _1.Template(template)
        ], Parent);
        return Parent;
    }(_1.Component));
    var Child = (function (_super) {
        __extends(Child, _super);
        function Child() {
            _super.apply(this, arguments);
        }
        Child = __decorate([
            _1.TagName("child-component")
        ], Child);
        return Child;
    }(_1.Component));
    it("should recall children correctly", function () {
        var parent = new Parent({});
        var child = Child.$for(parent, "", null);
        chai_1.expect(parent.$children[0]).to.equal(child);
    });
    if (isBrowser) {
        it("should reify without creating a new child component", function () {
            var parent = new Parent({});
            parent.$reify();
            chai_1.expect(parent.$children).to.have.length(1);
        });
        it("should be able to locate itself in the parent", function () {
            var parent = new Parent({});
            parent.$reify();
            var child = Child.$for(parent, "", null);
            chai_1.expect(child.$element).to.be.instanceof(Element);
        });
    }
});

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../":6,"chai":9}],59:[function(require,module,exports){
(function (global){
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var _1 = require("../");
var chai_1 = require("chai");
var isBrowser = !!global.document;
describe("A simple component", function () {
    var template = function (component) { return ("\n\t\tWe have this: " + component.$data.x + "\n\t"); };
    var Simple = (function (_super) {
        __extends(Simple, _super);
        function Simple(params) {
            _super.call(this, params);
        }
        Simple = __decorate([
            _1.TagName("simple-component"),
            _1.Template(template)
        ], Simple);
        return Simple;
    }(_1.Component));
    if (isBrowser) {
        it("should render with the correct markup", function () {
            var inst = new Simple({ x: 5 });
            inst.$reify();
            chai_1.expect(inst.$element.innerHTML).to.equal(inst.$template(inst));
        });
    }
});

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../":6,"chai":9}],60:[function(require,module,exports){
arguments[4][55][0].apply(exports,arguments)
},{"dup":55}],61:[function(require,module,exports){
'use strict'

exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

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

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

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

init()

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

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

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

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

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

  var L = 0

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

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

  return arr
}

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

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

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

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

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

  parts.push(output)

  return parts.join('')
}

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

'use strict'

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

exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50

/**
 * 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.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')
  }
}

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)

  that.write(string, encoding)
  return that
}

function fromArrayLike (that, array) {
  var length = 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 (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 'binary':
    case 'base64':
    case 'raw':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

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

  if (list.length === 0) {
    return 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 'binary':
      // Deprecated
      case 'raw':
      case 'raws':
        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 'binary':
        return binarySlice(this, start, end)

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

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

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

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

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

function arrayIndexOf (arr, val, byteOffset, encoding) {
  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 foundIndex = -1
  for (var i = 0; byteOffset + i < arrLength; i++) {
    if (read(arr, byteOffset + i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
      if (foundIndex === -1) foundIndex = i
      if (i - foundIndex + 1 === valLength) return (byteOffset + foundIndex) * indexSize
    } else {
      if (foundIndex !== -1) i -= i - foundIndex
      foundIndex = -1
    }
  }
  return -1
}

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

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

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

  if (typeof val === 'string') {
    val = Buffer.from(val, encoding)
  }

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

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

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

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

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

  if (length > strLen / 2) {
    length = strLen / 2
  }
  for (var i = 0; i < length; i++) {
    var parsed = parseInt(string.substr(i * 2, 2), 16)
    if (isNaN(parsed)) 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 binaryWrite (buf, string, offset, length) {
  return asciiWrite(buf, string, offset, length)
}

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

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

Buffer.prototype.write = function write (string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset | 0
    if (isFinite(length)) {
      length = length | 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  // legacy write(string, encoding, offset, length) - remove in v0.13
  } else {
    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 'binary':
        return binaryWrite(this, string, offset, length)

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

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

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

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

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

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

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

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

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

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

    res.push(codePoint)
    i += bytesPerSequence
  }

  return decodeCodePointsArray(res)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  if (end < start) end = start

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

  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,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

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

  i += d

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

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

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

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

  value = Math.abs(value)

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

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

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

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

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

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

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

},{}],66:[function(require,module,exports){
(function (process){
// 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;
}

// Split a filename into [root, dir, basename, ext], unix version
// 'root' is just a slash, or nothing.
var splitPathRe =
    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
var splitPath = function(filename) {
  return splitPathRe.exec(filename).slice(1);
};

// 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) {
  var result = splitPath(path),
      root = result[0],
      dir = result[1];

  if (!root && !dir) {
    // No dirname whatsoever
    return '.';
  }

  if (dir) {
    // It has a dirname, strip trailing slash
    dir = dir.substr(0, dir.length - 1);
  }

  return root + dir;
};


exports.basename = function(path, ext) {
  var f = splitPath(path)[2];
  // TODO: make this comparison case-insensitive on windows?
  if (ext && f.substr(-1 * ext.length) === ext) {
    f = f.substr(0, f.length - ext.length);
  }
  return f;
};


exports.extname = function(path) {
  return splitPath(path)[3];
};

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 = 'ab'.substr(-1) === 'b'
    ? function (str, start, len) { return str.substr(start, len) }
    : function (str, start, len) {
        if (start < 0) start = str.length + start;
        return str.substr(start, len);
    }
;

}).call(this,require('_process'))

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

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

function cleanUpNextTick() {
    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 = setTimeout(cleanUpNextTick);
    draining = true;

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

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

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

function noop() {}

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

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

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

},{}]},{},[57,55,60])(60)
});


//# sourceMappingURL=test.js.map