{"version":3,"file":"static/js/vendor.async.landing~524fe4f2.e2b25448.chunk.js","mappings":"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","sources":["../../../node_modules/sinon-legacy/index.js"],"sourcesContent":["/* eslint-disable */\r\n/**\r\n * Sinon.JS 1.17.2, 2015/10/21\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @author Contributors: https://github.com/cjohansen/Sinon.JS/blob/master/AUTHORS\r\n *\r\n * (The BSD License)\r\n *\r\n * Copyright (c) 2010-2014, Christian Johansen, christian@cjohansen.no\r\n * All rights reserved.\r\n *\r\n * Redistribution and use in source and binary forms, with or without modification,\r\n * are permitted provided that the following conditions are met:\r\n *\r\n *     * Redistributions of source code must retain the above copyright notice,\r\n *       this list of conditions and the following disclaimer.\r\n *     * Redistributions in binary form must reproduce the above copyright notice,\r\n *       this list of conditions and the following disclaimer in the documentation\r\n *       and/or other materials provided with the distribution.\r\n *     * Neither the name of Christian Johansen nor the names of his contributors\r\n *       may be used to endorse or promote products derived from this software\r\n *       without specific prior written permission.\r\n *\r\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\r\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r\n * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n */\r\n\r\nvar lolexModule = require('lolex');\r\n\r\n(function (root, factory) {\r\n  'use strict';\r\n  if (/* typeof define === 'function' && define.amd */ false) {\r\n    define('sinon-legacy', [], function () {\r\n      return (root.sinon = factory());\r\n    });\r\n  } else if (typeof exports === 'object') {\r\n    module.exports = factory();\r\n  } else {\r\n    root.sinon = factory();\r\n  }\r\n}(this, function () {\r\n  var samsam, formatio, lolex;\r\n  lolex = lolexModule;\r\n  (function () {\r\n                function define(mod, deps, fn) {\r\n                  if (mod == 'samsam') {\r\n                    samsam = deps();\r\n                  } else if (typeof deps === 'function' && mod.length === 0) {\r\n                    lolex = deps();\r\n                  } else if (typeof fn === 'function') {\r\n                    formatio = fn(samsam);\r\n                  }\r\n                }\r\n    define.amd = {};\r\n((/* typeof define === 'function' && define.amd */ false && function (m) { define('samsam', m); }) ||\r\n (typeof module === 'object' &&\r\n      function (m) { module.exports = m(); }) || // Node\r\n function (m) { this.samsam = m(); } // Browser globals\r\n)(function () {\r\n    var o = Object.prototype;\r\n    var div = typeof document !== 'undefined' && document.createElement('div');\r\n\r\n    function isNaN(value) {\r\n        // Unlike global isNaN, this avoids type coercion\r\n        // typeof check avoids IE host object issues, hat tip to\r\n        // lodash\r\n        var val = value; // JsLint thinks value !== value is \"weird\"\r\n        return typeof value === 'number' && value !== val;\r\n    }\r\n\r\n    function getClass(value) {\r\n        // Returns the internal [[Class]] by calling Object.prototype.toString\r\n        // with the provided value as this. Return value is a string, naming the\r\n        // internal class, e.g. \"Array\"\r\n        return o.toString.call(value).split(/[ \\]]/)[1];\r\n    }\r\n\r\n    /**\r\n     * @name samsam.isArguments\r\n     * @param Object object\r\n     *\r\n     * Returns ``true`` if ``object`` is an ``arguments`` object,\r\n     * ``false`` otherwise.\r\n     */\r\n    function isArguments(object) {\r\n        if (getClass(object) === 'Arguments') { return true; }\r\n        if (typeof object !== 'object' || typeof object.length !== 'number' ||\r\n                getClass(object) === 'Array') {\r\n            return false;\r\n        }\r\n        if (typeof object.callee == 'function') { return true; }\r\n        try {\r\n            object[object.length] = 6;\r\n            delete object[object.length];\r\n        } catch (e) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * @name samsam.isElement\r\n     * @param Object object\r\n     *\r\n     * Returns ``true`` if ``object`` is a DOM element node. Unlike\r\n     * Underscore.js/lodash, this function will return ``false`` if ``object``\r\n     * is an *element-like* object, i.e. a regular object with a ``nodeType``\r\n     * property that holds the value ``1``.\r\n     */\r\n    function isElement(object) {\r\n        if (!object || object.nodeType !== 1 || !div) { return false; }\r\n        try {\r\n            object.appendChild(div);\r\n            object.removeChild(div);\r\n        } catch (e) {\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @name samsam.keys\r\n     * @param Object object\r\n     *\r\n     * Return an array of own property names.\r\n     */\r\n    function keys(object) {\r\n        var ks = [], prop;\r\n        for (prop in object) {\r\n            if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }\r\n        }\r\n        return ks;\r\n    }\r\n\r\n    /**\r\n     * @name samsam.isDate\r\n     * @param Object value\r\n     *\r\n     * Returns true if the object is a ``Date``, or *date-like*. Duck typing\r\n     * of date objects work by checking that the object has a ``getTime``\r\n     * function whose return value equals the return value from the object's\r\n     * ``valueOf``.\r\n     */\r\n    function isDate(value) {\r\n        return typeof value.getTime == 'function' &&\r\n            value.getTime() == value.valueOf();\r\n    }\r\n\r\n    /**\r\n     * @name samsam.isNegZero\r\n     * @param Object value\r\n     *\r\n     * Returns ``true`` if ``value`` is ``-0``.\r\n     */\r\n    function isNegZero(value) {\r\n        return value === 0 && 1 / value === -Infinity;\r\n    }\r\n\r\n    /**\r\n     * @name samsam.equal\r\n     * @param Object obj1\r\n     * @param Object obj2\r\n     *\r\n     * Returns ``true`` if two objects are strictly equal. Compared to\r\n     * ``===`` there are two exceptions:\r\n     *\r\n     *   - NaN is considered equal to NaN\r\n     *   - -0 and +0 are not considered equal\r\n     */\r\n    function identical(obj1, obj2) {\r\n        if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {\r\n            return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * @name samsam.deepEqual\r\n     * @param Object obj1\r\n     * @param Object obj2\r\n     *\r\n     * Deep equal comparison. Two values are \"deep equal\" if:\r\n     *\r\n     *   - They are equal, according to samsam.identical\r\n     *   - They are both date objects representing the same time\r\n     *   - They are both arrays containing elements that are all deepEqual\r\n     *   - They are objects with the same set of properties, and each property\r\n     *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``\r\n     *\r\n     * Supports cyclic objects.\r\n     */\r\n    function deepEqualCyclic(obj1, obj2) {\r\n\r\n        // used for cyclic comparison\r\n        // contain already visited objects\r\n        var objects1 = [],\r\n            objects2 = [],\r\n        // contain pathes (position in the object structure)\r\n        // of the already visited objects\r\n        // indexes same as in objects arrays\r\n            paths1 = [],\r\n            paths2 = [],\r\n        // contains combinations of already compared objects\r\n        // in the manner: { \"$1['ref']$2['ref']\": true }\r\n            compared = {};\r\n\r\n        /**\r\n         * used to check, if the value of a property is an object\r\n         * (cyclic logic is only needed for objects)\r\n         * only needed for cyclic logic\r\n         */\r\n        function isObject(value) {\r\n\r\n            if (typeof value === 'object' && value !== null &&\r\n                    !(value instanceof Boolean) &&\r\n                    !(value instanceof Date)    &&\r\n                    !(value instanceof Number)  &&\r\n                    !(value instanceof RegExp)  &&\r\n                    !(value instanceof String)) {\r\n\r\n                return true;\r\n            }\r\n\r\n            return false;\r\n        }\r\n\r\n        /**\r\n         * returns the index of the given object in the\r\n         * given objects array, -1 if not contained\r\n         * only needed for cyclic logic\r\n         */\r\n        function getIndex(objects, obj) {\r\n\r\n            var i;\r\n            for (i = 0; i < objects.length; i++) {\r\n                if (objects[i] === obj) {\r\n                    return i;\r\n                }\r\n            }\r\n\r\n            return -1;\r\n        }\r\n\r\n        // does the recursion for the deep equal check\r\n        return (function deepEqual(obj1, obj2, path1, path2) {\r\n            var type1 = typeof obj1;\r\n            var type2 = typeof obj2;\r\n\r\n            // == null also matches undefined\r\n            if (obj1 === obj2 ||\r\n                    isNaN(obj1) || isNaN(obj2) ||\r\n                    obj1 == null || obj2 == null ||\r\n                    type1 !== 'object' || type2 !== 'object') {\r\n\r\n                return identical(obj1, obj2);\r\n            }\r\n\r\n            // Elements are only equal if identical(expected, actual)\r\n            if (isElement(obj1) || isElement(obj2)) { return false; }\r\n\r\n            var isDate1 = isDate(obj1), isDate2 = isDate(obj2);\r\n            if (isDate1 || isDate2) {\r\n                if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {\r\n                    return false;\r\n                }\r\n            }\r\n\r\n            if (obj1 instanceof RegExp && obj2 instanceof RegExp) {\r\n                if (obj1.toString() !== obj2.toString()) { return false; }\r\n            }\r\n\r\n            var class1 = getClass(obj1);\r\n            var class2 = getClass(obj2);\r\n            var keys1 = keys(obj1);\r\n            var keys2 = keys(obj2);\r\n\r\n            if (isArguments(obj1) || isArguments(obj2)) {\r\n                if (obj1.length !== obj2.length) { return false; }\r\n            } else {\r\n                if (type1 !== type2 || class1 !== class2 ||\r\n                        keys1.length !== keys2.length) {\r\n                    return false;\r\n                }\r\n            }\r\n\r\n            var key, i, l,\r\n                // following vars are used for the cyclic logic\r\n                value1, value2,\r\n                isObject1, isObject2,\r\n                index1, index2,\r\n                newPath1, newPath2;\r\n\r\n            for (i = 0, l = keys1.length; i < l; i++) {\r\n                key = keys1[i];\r\n                if (!o.hasOwnProperty.call(obj2, key)) {\r\n                    return false;\r\n                }\r\n\r\n                // Start of the cyclic logic\r\n\r\n                value1 = obj1[key];\r\n                value2 = obj2[key];\r\n\r\n                isObject1 = isObject(value1);\r\n                isObject2 = isObject(value2);\r\n\r\n                // determine, if the objects were already visited\r\n                // (it's faster to check for isObject first, than to\r\n                // get -1 from getIndex for non objects)\r\n                index1 = isObject1 ? getIndex(objects1, value1) : -1;\r\n                index2 = isObject2 ? getIndex(objects2, value2) : -1;\r\n\r\n                // determine the new pathes of the objects\r\n                // - for non cyclic objects the current path will be extended\r\n                //   by current property name\r\n                // - for cyclic objects the stored path is taken\r\n                newPath1 = index1 !== -1\r\n                    ? paths1[index1]\r\n                    : path1 + '[' + JSON.stringify(key) + ']';\r\n                newPath2 = index2 !== -1\r\n                    ? paths2[index2]\r\n                    : path2 + '[' + JSON.stringify(key) + ']';\r\n\r\n                // stop recursion if current objects are already compared\r\n                if (compared[newPath1 + newPath2]) {\r\n                    return true;\r\n                }\r\n\r\n                // remember the current objects and their pathes\r\n                if (index1 === -1 && isObject1) {\r\n                    objects1.push(value1);\r\n                    paths1.push(newPath1);\r\n                }\r\n                if (index2 === -1 && isObject2) {\r\n                    objects2.push(value2);\r\n                    paths2.push(newPath2);\r\n                }\r\n\r\n                // remember that the current objects are already compared\r\n                if (isObject1 && isObject2) {\r\n                    compared[newPath1 + newPath2] = true;\r\n                }\r\n\r\n                // End of cyclic logic\r\n\r\n                // neither value1 nor value2 is a cycle\r\n                // continue with next level\r\n                if (!deepEqual(value1, value2, newPath1, newPath2)) {\r\n                    return false;\r\n                }\r\n            }\r\n\r\n            return true;\r\n\r\n        }(obj1, obj2, '$1', '$2'));\r\n    }\r\n\r\n    var match;\r\n\r\n    function arrayContains(array, subset) {\r\n        if (subset.length === 0) { return true; }\r\n        var i, l, j, k;\r\n        for (i = 0, l = array.length; i < l; ++i) {\r\n            if (match(array[i], subset[0])) {\r\n                for (j = 0, k = subset.length; j < k; ++j) {\r\n                    if (!match(array[i + j], subset[j])) { return false; }\r\n                }\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * @name samsam.match\r\n     * @param Object object\r\n     * @param Object matcher\r\n     *\r\n     * Compare arbitrary value ``object`` with matcher.\r\n     */\r\n    match = function match(object, matcher) {\r\n        if (matcher && typeof matcher.test === 'function') {\r\n            return matcher.test(object);\r\n        }\r\n\r\n        if (typeof matcher === 'function') {\r\n            return matcher(object) === true;\r\n        }\r\n\r\n        if (typeof matcher === 'string') {\r\n            matcher = matcher.toLowerCase();\r\n            var notNull = typeof object === 'string' || !!object;\r\n            return notNull &&\r\n                (String(object)).toLowerCase().indexOf(matcher) >= 0;\r\n        }\r\n\r\n        if (typeof matcher === 'number') {\r\n            return matcher === object;\r\n        }\r\n\r\n        if (typeof matcher === 'boolean') {\r\n            return matcher === object;\r\n        }\r\n\r\n        if (typeof(matcher) === 'undefined') {\r\n            return typeof(object) === 'undefined';\r\n        }\r\n\r\n        if (matcher === null) {\r\n            return object === null;\r\n        }\r\n\r\n        if (getClass(object) === 'Array' && getClass(matcher) === 'Array') {\r\n            return arrayContains(object, matcher);\r\n        }\r\n\r\n        if (matcher && typeof matcher === 'object') {\r\n            if (matcher === object) {\r\n                return true;\r\n            }\r\n            var prop;\r\n            for (prop in matcher) {\r\n                var value = object[prop];\r\n                if (typeof value === 'undefined' &&\r\n                        typeof object.getAttribute === 'function') {\r\n                    value = object.getAttribute(prop);\r\n                }\r\n                if (matcher[prop] === null || typeof matcher[prop] === 'undefined') {\r\n                    if (value !== matcher[prop]) {\r\n                        return false;\r\n                    }\r\n                } else if (typeof  value === 'undefined' || !match(value, matcher[prop])) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n\r\n        throw new Error('Matcher was not a string, a number, a ' +\r\n                        'function, a boolean or an object');\r\n    };\r\n\r\n    return {\r\n        isArguments: isArguments,\r\n        isElement: isElement,\r\n        isDate: isDate,\r\n        isNegZero: isNegZero,\r\n        identical: identical,\r\n        deepEqual: deepEqualCyclic,\r\n        match: match,\r\n        keys: keys\r\n    };\r\n});\r\n((/* typeof define === 'function' && define.amd */ false && function (m) {\r\n    define('formatio', ['samsam'], m);\r\n}) || (typeof module === 'object' && function (m) {\r\n    module.exports = m(/* require */('samsam'));\r\n}) || function (m) { this.formatio = m(this.samsam); }\r\n)(function (samsam) {\r\n\r\n    var formatio = {\r\n        excludeConstructors: ['Object', /^.$/],\r\n        quoteStrings: true,\r\n        limitChildrenCount: 0\r\n    };\r\n\r\n    var hasOwn = Object.prototype.hasOwnProperty;\r\n\r\n    var specialObjects = [];\r\n    if (typeof global !== 'undefined') {\r\n        specialObjects.push({ object: global, value: '[object global]' });\r\n    }\r\n    if (typeof document !== 'undefined') {\r\n        specialObjects.push({\r\n            object: document,\r\n            value: '[object HTMLDocument]'\r\n        });\r\n    }\r\n    if (typeof window !== 'undefined') {\r\n        specialObjects.push({ object: window, value: '[object Window]' });\r\n    }\r\n\r\n    function functionName(func) {\r\n        if (!func) { return ''; }\r\n        if (func.displayName) { return func.displayName; }\r\n        if (func.name) { return func.name; }\r\n        var matches = func.toString().match(/function\\s+([^\\(]+)/m);\r\n        return (matches && matches[1]) || '';\r\n    }\r\n\r\n    function constructorName(f, object) {\r\n        var name = functionName(object && object.constructor);\r\n        var excludes = f.excludeConstructors ||\r\n                formatio.excludeConstructors || [];\r\n\r\n        var i, l;\r\n        for (i = 0, l = excludes.length; i < l; ++i) {\r\n            if (typeof excludes[i] === 'string' && excludes[i] === name) {\r\n                return '';\r\n            } else if (excludes[i].test && excludes[i].test(name)) {\r\n                return '';\r\n            }\r\n        }\r\n\r\n        return name;\r\n    }\r\n\r\n    function isCircular(object, objects) {\r\n        if (typeof object !== 'object') { return false; }\r\n        var i, l;\r\n        for (i = 0, l = objects.length; i < l; ++i) {\r\n            if (objects[i] === object) { return true; }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    function ascii(f, object, processed, indent) {\r\n        if (typeof object === 'string') {\r\n            var qs = f.quoteStrings;\r\n            var quote = typeof qs !== 'boolean' || qs;\r\n            return processed || quote ? '\"' + object + '\"' : object;\r\n        }\r\n\r\n        if (typeof object === 'function' && !(object instanceof RegExp)) {\r\n            return ascii.func(object);\r\n        }\r\n\r\n        processed = processed || [];\r\n\r\n        if (isCircular(object, processed)) { return '[Circular]'; }\r\n\r\n        if (Object.prototype.toString.call(object) === '[object Array]') {\r\n            return ascii.array.call(f, object, processed);\r\n        }\r\n\r\n        if (!object) { return String((1/object) === -Infinity ? '-0' : object); }\r\n        if (samsam.isElement(object)) { return ascii.element(object); }\r\n\r\n        if (typeof object.toString === 'function' &&\r\n                object.toString !== Object.prototype.toString) {\r\n            return object.toString();\r\n        }\r\n\r\n        var i, l;\r\n        for (i = 0, l = specialObjects.length; i < l; i++) {\r\n            if (object === specialObjects[i].object) {\r\n                return specialObjects[i].value;\r\n            }\r\n        }\r\n\r\n        return ascii.object.call(f, object, processed, indent);\r\n    }\r\n\r\n    ascii.func = function (func) {\r\n        return 'function ' + functionName(func) + '() {}';\r\n    };\r\n\r\n    ascii.array = function (array, processed) {\r\n        processed = processed || [];\r\n        processed.push(array);\r\n        var pieces = [];\r\n        var i, l;\r\n        l = (this.limitChildrenCount > 0) ?\r\n            Math.min(this.limitChildrenCount, array.length) : array.length;\r\n\r\n        for (i = 0; i < l; ++i) {\r\n            pieces.push(ascii(this, array[i], processed));\r\n        }\r\n\r\n        if(l < array.length)\r\n            pieces.push('[... ' + (array.length - l) + ' more elements]');\r\n\r\n        return '[' + pieces.join(', ') + ']';\r\n    };\r\n\r\n    ascii.object = function (object, processed, indent) {\r\n        processed = processed || [];\r\n        processed.push(object);\r\n        indent = indent || 0;\r\n        var pieces = [], properties = samsam.keys(object).sort();\r\n        var length = 3;\r\n        var prop, str, obj, i, k, l;\r\n        l = (this.limitChildrenCount > 0) ?\r\n            Math.min(this.limitChildrenCount, properties.length) : properties.length;\r\n\r\n        for (i = 0; i < l; ++i) {\r\n            prop = properties[i];\r\n            obj = object[prop];\r\n\r\n            if (isCircular(obj, processed)) {\r\n                str = '[Circular]';\r\n            } else {\r\n                str = ascii(this, obj, processed, indent + 2);\r\n            }\r\n\r\n            str = (/\\s/.test(prop) ? '\"' + prop + '\"' : prop) + ': ' + str;\r\n            length += str.length;\r\n            pieces.push(str);\r\n        }\r\n\r\n        var cons = constructorName(this, object);\r\n        var prefix = cons ? '[' + cons + '] ' : '';\r\n        var is = '';\r\n        for (i = 0, k = indent; i < k; ++i) { is += ' '; }\r\n\r\n        if(l < properties.length)\r\n            pieces.push('[... ' + (properties.length - l) + ' more elements]');\r\n\r\n        if (length + indent > 80) {\r\n            return prefix + '{\\n  ' + is + pieces.join(',\\n  ' + is) + '\\n' +\r\n                is + '}';\r\n        }\r\n        return prefix + '{ ' + pieces.join(', ') + ' }';\r\n    };\r\n\r\n    ascii.element = function (element) {\r\n        var tagName = element.tagName.toLowerCase();\r\n        var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;\r\n\r\n        for (i = 0, l = attrs.length; i < l; ++i) {\r\n            attr = attrs.item(i);\r\n            attrName = attr.nodeName.toLowerCase().replace('html:', '');\r\n            val = attr.nodeValue;\r\n            if (attrName !== 'contenteditable' || val !== 'inherit') {\r\n                if (!!val) { pairs.push(attrName + '=\"' + val + '\"'); }\r\n            }\r\n        }\r\n\r\n        var formatted = '<' + tagName + (pairs.length > 0 ? ' ' : '');\r\n        var content = element.innerHTML;\r\n\r\n        if (content.length > 20) {\r\n            content = content.substr(0, 20) + '[...]';\r\n        }\r\n\r\n        var res = formatted + pairs.join(' ') + '>' + content +\r\n                '</' + tagName + '>';\r\n\r\n        return res.replace(/ contentEditable=\"inherit\"/, '');\r\n    };\r\n\r\n    function Formatio(options) {\r\n        for (var opt in options) {\r\n            this[opt] = options[opt];\r\n        }\r\n    }\r\n\r\n    Formatio.prototype = {\r\n        functionName: functionName,\r\n\r\n        configure: function (options) {\r\n            return new Formatio(options);\r\n        },\r\n\r\n        constructorName: function (object) {\r\n            return constructorName(this, object);\r\n        },\r\n\r\n        ascii: function (object, processed, indent) {\r\n            return ascii(this, object, processed, indent);\r\n        }\r\n    };\r\n\r\n    return Formatio.prototype;\r\n});\r\n!function(e){if('object'==typeof exports&&'undefined'!=typeof module)module.exports=e();else if(/* typeof define === 'function' && define.amd */ false)define([],e);else{var f;'undefined'!=typeof window?f=window:'undefined'!=typeof global?f=global:'undefined'!=typeof self&&(f=self),f.lolex=e()}}(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){\r\n(function (global){\r\n/*global global, window*/\r\n/**\r\n * @author Christian Johansen (christian@cjohansen.no) and contributors\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2014 Christian Johansen\r\n */\r\n\r\n(function (global) {\r\n\r\n    // Make properties writable in IE, as per\r\n    // http://www.adequatelygood.com/Replacing-setTimeout-Globally.html\r\n    // JSLint being anal\r\n    var glbl = global;\r\n\r\n    global.setTimeout = glbl.setTimeout;\r\n    global.clearTimeout = glbl.clearTimeout;\r\n    global.setInterval = glbl.setInterval;\r\n    global.clearInterval = glbl.clearInterval;\r\n    global.Date = glbl.Date;\r\n\r\n    // setImmediate is not a standard function\r\n    // avoid adding the prop to the window object if not present\r\n    if('setImmediate' in global) {\r\n        global.setImmediate = glbl.setImmediate;\r\n        global.clearImmediate = glbl.clearImmediate;\r\n    }\r\n\r\n    // node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref()\r\n    // browsers, a number.\r\n    // see https://github.com/cjohansen/Sinon.JS/pull/436\r\n\r\n    var NOOP = function () { return undefined; };\r\n    var timeoutResult = setTimeout(NOOP, 0);\r\n    var addTimerReturnsObject = typeof timeoutResult === 'object';\r\n    clearTimeout(timeoutResult);\r\n\r\n    var NativeDate = Date;\r\n    var uniqueTimerId = 1;\r\n\r\n    /**\r\n     * Parse strings like \"01:10:00\" (meaning 1 hour, 10 minutes, 0 seconds) into\r\n     * number of milliseconds. This is used to support human-readable strings passed\r\n     * to clock.tick()\r\n     */\r\n    function parseTime(str) {\r\n        if (!str) {\r\n            return 0;\r\n        }\r\n\r\n        var strings = str.split(':');\r\n        var l = strings.length, i = l;\r\n        var ms = 0, parsed;\r\n\r\n        if (l > 3 || !/^(\\d\\d:){0,2}\\d\\d?$/.test(str)) {\r\n            throw new Error('tick only understands numbers and \\'h:m:s\\'');\r\n        }\r\n\r\n        while (i--) {\r\n            parsed = parseInt(strings[i], 10);\r\n\r\n            if (parsed >= 60) {\r\n                throw new Error('Invalid time ' + str);\r\n            }\r\n\r\n            ms += parsed * Math.pow(60, (l - i - 1));\r\n        }\r\n\r\n        return ms * 1000;\r\n    }\r\n\r\n    /**\r\n     * Used to grok the `now` parameter to createClock.\r\n     */\r\n    function getEpoch(epoch) {\r\n        if (!epoch) { return 0; }\r\n        if (typeof epoch.getTime === 'function') { return epoch.getTime(); }\r\n        if (typeof epoch === 'number') { return epoch; }\r\n        throw new TypeError('now should be milliseconds since UNIX epoch');\r\n    }\r\n\r\n    function inRange(from, to, timer) {\r\n        return timer && timer.callAt >= from && timer.callAt <= to;\r\n    }\r\n\r\n    function mirrorDateProperties(target, source) {\r\n        var prop;\r\n        for (prop in source) {\r\n            if (source.hasOwnProperty(prop)) {\r\n                target[prop] = source[prop];\r\n            }\r\n        }\r\n\r\n        // set special now implementation\r\n        if (source.now) {\r\n            target.now = function now() {\r\n                return target.clock.now;\r\n            };\r\n        } else {\r\n            delete target.now;\r\n        }\r\n\r\n        // set special toSource implementation\r\n        if (source.toSource) {\r\n            target.toSource = function toSource() {\r\n                return source.toSource();\r\n            };\r\n        } else {\r\n            delete target.toSource;\r\n        }\r\n\r\n        // set special toString implementation\r\n        target.toString = function toString() {\r\n            return source.toString();\r\n        };\r\n\r\n        target.prototype = source.prototype;\r\n        target.parse = source.parse;\r\n        target.UTC = source.UTC;\r\n        target.prototype.toUTCString = source.prototype.toUTCString;\r\n\r\n        return target;\r\n    }\r\n\r\n    function createDate() {\r\n        function ClockDate(year, month, date, hour, minute, second, ms) {\r\n            // Defensive and verbose to avoid potential harm in passing\r\n            // explicit undefined when user does not pass argument\r\n            switch (arguments.length) {\r\n            case 0:\r\n                return new NativeDate(ClockDate.clock.now);\r\n            case 1:\r\n                return new NativeDate(year);\r\n            case 2:\r\n                return new NativeDate(year, month);\r\n            case 3:\r\n                return new NativeDate(year, month, date);\r\n            case 4:\r\n                return new NativeDate(year, month, date, hour);\r\n            case 5:\r\n                return new NativeDate(year, month, date, hour, minute);\r\n            case 6:\r\n                return new NativeDate(year, month, date, hour, minute, second);\r\n            default:\r\n                return new NativeDate(year, month, date, hour, minute, second, ms);\r\n            }\r\n        }\r\n\r\n        return mirrorDateProperties(ClockDate, NativeDate);\r\n    }\r\n\r\n    function addTimer(clock, timer) {\r\n        if (timer.func === undefined) {\r\n            throw new Error('Callback must be provided to timer calls');\r\n        }\r\n\r\n        if (!clock.timers) {\r\n            clock.timers = {};\r\n        }\r\n\r\n        timer.id = uniqueTimerId++;\r\n        timer.createdAt = clock.now;\r\n        timer.callAt = clock.now + (timer.delay || (clock.duringTick ? 1 : 0));\r\n\r\n        clock.timers[timer.id] = timer;\r\n\r\n        if (addTimerReturnsObject) {\r\n            return {\r\n                id: timer.id,\r\n                ref: NOOP,\r\n                unref: NOOP\r\n            };\r\n        }\r\n\r\n        return timer.id;\r\n    }\r\n\r\n\r\n    function compareTimers(a, b) {\r\n        // Sort first by absolute timing\r\n        if (a.callAt < b.callAt) {\r\n            return -1;\r\n        }\r\n        if (a.callAt > b.callAt) {\r\n            return 1;\r\n        }\r\n\r\n        // Sort next by immediate, immediate timers take precedence\r\n        if (a.immediate && !b.immediate) {\r\n            return -1;\r\n        }\r\n        if (!a.immediate && b.immediate) {\r\n            return 1;\r\n        }\r\n\r\n        // Sort next by creation time, earlier-created timers take precedence\r\n        if (a.createdAt < b.createdAt) {\r\n            return -1;\r\n        }\r\n        if (a.createdAt > b.createdAt) {\r\n            return 1;\r\n        }\r\n\r\n        // Sort next by id, lower-id timers take precedence\r\n        if (a.id < b.id) {\r\n            return -1;\r\n        }\r\n        if (a.id > b.id) {\r\n            return 1;\r\n        }\r\n\r\n        // As timer ids are unique, no fallback `0` is necessary\r\n    }\r\n\r\n    function firstTimerInRange(clock, from, to) {\r\n        var timers = clock.timers,\r\n            timer = null,\r\n            id,\r\n            isInRange;\r\n\r\n        for (id in timers) {\r\n            if (timers.hasOwnProperty(id)) {\r\n                isInRange = inRange(from, to, timers[id]);\r\n\r\n                if (isInRange && (!timer || compareTimers(timer, timers[id]) === 1)) {\r\n                    timer = timers[id];\r\n                }\r\n            }\r\n        }\r\n\r\n        return timer;\r\n    }\r\n\r\n    function callTimer(clock, timer) {\r\n        var exception;\r\n\r\n        if (typeof timer.interval === 'number') {\r\n            clock.timers[timer.id].callAt += timer.interval;\r\n        } else {\r\n            delete clock.timers[timer.id];\r\n        }\r\n\r\n        try {\r\n            if (typeof timer.func === 'function') {\r\n                timer.func.apply(null, timer.args);\r\n            } else {\r\n                eval(timer.func);\r\n            }\r\n        } catch (e) {\r\n            exception = e;\r\n        }\r\n\r\n        if (!clock.timers[timer.id]) {\r\n            if (exception) {\r\n                throw exception;\r\n            }\r\n            return;\r\n        }\r\n\r\n        if (exception) {\r\n            throw exception;\r\n        }\r\n    }\r\n\r\n    function timerType(timer) {\r\n        if (timer.immediate) {\r\n            return 'Immediate';\r\n        } else if (typeof timer.interval !== 'undefined') {\r\n            return 'Interval';\r\n        } else {\r\n            return 'Timeout';\r\n        }\r\n    }\r\n\r\n    function clearTimer(clock, timerId, ttype) {\r\n        if (!timerId) {\r\n            // null appears to be allowed in most browsers, and appears to be\r\n            // relied upon by some libraries, like Bootstrap carousel\r\n            return;\r\n        }\r\n\r\n        if (!clock.timers) {\r\n            clock.timers = [];\r\n        }\r\n\r\n        // in Node, timerId is an object with .ref()/.unref(), and\r\n        // its .id field is the actual timer id.\r\n        if (typeof timerId === 'object') {\r\n            timerId = timerId.id;\r\n        }\r\n\r\n        if (clock.timers.hasOwnProperty(timerId)) {\r\n            // check that the ID matches a timer of the correct type\r\n            var timer = clock.timers[timerId];\r\n            if (timerType(timer) === ttype) {\r\n                delete clock.timers[timerId];\r\n            } else {\r\n\t\t\t\tthrow new Error('Cannot clear timer: timer created with set' + ttype + '() but cleared with clear' + timerType(timer) + '()');\r\n\t\t\t}\r\n        }\r\n    }\r\n\r\n    function uninstall(clock, target) {\r\n        var method,\r\n            i,\r\n            l;\r\n\r\n        for (i = 0, l = clock.methods.length; i < l; i++) {\r\n            method = clock.methods[i];\r\n\r\n            if (target[method].hadOwnProperty) {\r\n                target[method] = clock['_' + method];\r\n            } else {\r\n                try {\r\n                    delete target[method];\r\n                } catch (ignore) {}\r\n            }\r\n        }\r\n\r\n        // Prevent multiple executions which will completely remove these props\r\n        clock.methods = [];\r\n    }\r\n\r\n    function hijackMethod(target, method, clock) {\r\n        var prop;\r\n\r\n        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);\r\n        clock['_' + method] = target[method];\r\n\r\n        if (method === 'Date') {\r\n            var date = mirrorDateProperties(clock[method], target[method]);\r\n            target[method] = date;\r\n        } else {\r\n            target[method] = function () {\r\n                return clock[method].apply(clock, arguments);\r\n            };\r\n\r\n            for (prop in clock[method]) {\r\n                if (clock[method].hasOwnProperty(prop)) {\r\n                    target[method][prop] = clock[method][prop];\r\n                }\r\n            }\r\n        }\r\n\r\n        target[method].clock = clock;\r\n    }\r\n\r\n    var timers = {\r\n        setTimeout: setTimeout,\r\n        clearTimeout: clearTimeout,\r\n        setImmediate: global.setImmediate,\r\n        clearImmediate: global.clearImmediate,\r\n        setInterval: setInterval,\r\n        clearInterval: clearInterval,\r\n        Date: Date\r\n    };\r\n\r\n    var keys = Object.keys || function (obj) {\r\n        var ks = [],\r\n            key;\r\n\r\n        for (key in obj) {\r\n            if (obj.hasOwnProperty(key)) {\r\n                ks.push(key);\r\n            }\r\n        }\r\n\r\n        return ks;\r\n    };\r\n\r\n    exports.timers = timers;\r\n\r\n    function createClock(now) {\r\n        var clock = {\r\n            now: getEpoch(now),\r\n            timeouts: {},\r\n            Date: createDate()\r\n        };\r\n\r\n        clock.Date.clock = clock;\r\n\r\n        clock.setTimeout = function setTimeout(func, timeout) {\r\n            return addTimer(clock, {\r\n                func: func,\r\n                args: Array.prototype.slice.call(arguments, 2),\r\n                delay: timeout\r\n            });\r\n        };\r\n\r\n        clock.clearTimeout = function clearTimeout(timerId) {\r\n            return clearTimer(clock, timerId, 'Timeout');\r\n        };\r\n\r\n        clock.setInterval = function setInterval(func, timeout) {\r\n            return addTimer(clock, {\r\n                func: func,\r\n                args: Array.prototype.slice.call(arguments, 2),\r\n                delay: timeout,\r\n                interval: timeout\r\n            });\r\n        };\r\n\r\n        clock.clearInterval = function clearInterval(timerId) {\r\n            return clearTimer(clock, timerId, 'Interval');\r\n        };\r\n\r\n        clock.setImmediate = function setImmediate(func) {\r\n            return addTimer(clock, {\r\n                func: func,\r\n                args: Array.prototype.slice.call(arguments, 1),\r\n                immediate: true\r\n            });\r\n        };\r\n\r\n        clock.clearImmediate = function clearImmediate(timerId) {\r\n            return clearTimer(clock, timerId, 'Immediate');\r\n        };\r\n\r\n        clock.tick = function tick(ms) {\r\n            ms = typeof ms === 'number' ? ms : parseTime(ms);\r\n            var tickFrom = clock.now, tickTo = clock.now + ms, previous = clock.now;\r\n            var timer = firstTimerInRange(clock, tickFrom, tickTo);\r\n            var oldNow;\r\n\r\n            clock.duringTick = true;\r\n\r\n            var firstException;\r\n            while (timer && tickFrom <= tickTo) {\r\n                if (clock.timers[timer.id]) {\r\n                    tickFrom = clock.now = timer.callAt;\r\n                    try {\r\n                        oldNow = clock.now;\r\n                        callTimer(clock, timer);\r\n                        // compensate for any setSystemTime() call during timer callback\r\n                        if (oldNow !== clock.now) {\r\n                            tickFrom += clock.now - oldNow;\r\n                            tickTo += clock.now - oldNow;\r\n                            previous += clock.now - oldNow;\r\n                        }\r\n                    } catch (e) {\r\n                        firstException = firstException || e;\r\n                    }\r\n                }\r\n\r\n                timer = firstTimerInRange(clock, previous, tickTo);\r\n                previous = tickFrom;\r\n            }\r\n\r\n            clock.duringTick = false;\r\n            clock.now = tickTo;\r\n\r\n            if (firstException) {\r\n                throw firstException;\r\n            }\r\n\r\n            return clock.now;\r\n        };\r\n\r\n        clock.reset = function reset() {\r\n            clock.timers = {};\r\n        };\r\n\r\n        clock.setSystemTime = function setSystemTime(now) {\r\n            // determine time difference\r\n            var newNow = getEpoch(now);\r\n            var difference = newNow - clock.now;\r\n\r\n            // update 'system clock'\r\n            clock.now = newNow;\r\n\r\n            // update timers and intervals to keep them stable\r\n            for (var id in clock.timers) {\r\n                if (clock.timers.hasOwnProperty(id)) {\r\n                    var timer = clock.timers[id];\r\n                    timer.createdAt += difference;\r\n                    timer.callAt += difference;\r\n                }\r\n            }\r\n        };\r\n\r\n        return clock;\r\n    }\r\n    exports.createClock = createClock;\r\n\r\n    exports.install = function install(target, now, toFake) {\r\n        var i,\r\n            l;\r\n\r\n        if (typeof target === 'number') {\r\n            toFake = now;\r\n            now = target;\r\n            target = null;\r\n        }\r\n\r\n        if (!target) {\r\n            target = global;\r\n        }\r\n\r\n        var clock = createClock(now);\r\n\r\n        clock.uninstall = function () {\r\n            uninstall(clock, target);\r\n        };\r\n\r\n        clock.methods = toFake || [];\r\n\r\n        if (clock.methods.length === 0) {\r\n            clock.methods = keys(timers);\r\n        }\r\n\r\n        for (i = 0, l = clock.methods.length; i < l; i++) {\r\n            hijackMethod(target, clock.methods[i], clock);\r\n        }\r\n\r\n        return clock;\r\n    };\r\n\r\n}(global || this));\r\n\r\n}).call(this,typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})\r\n},{}]},{},[1])(1)\r\n});\r\n  })();\r\n  var define;\r\n/**\r\n * Sinon core utilities. For internal use only.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\nvar sinon = (function () {\r\n'use strict';\r\n // eslint-disable-line no-unused-vars\r\n\r\n    var sinonModule;\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = /* typeof define === \"function\" && typeof define.amd === \"object\" && define.amd */ false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        sinonModule = module.exports = /* require */('./sinon/util/core');\r\n        /* require */('./sinon/extend');\r\n        /* require */('./sinon/walk');\r\n        /* require */('./sinon/typeOf');\r\n        /* require */('./sinon/times_in_words');\r\n        /* require */('./sinon/spy');\r\n        /* require */('./sinon/call');\r\n        /* require */('./sinon/behavior');\r\n        /* require */('./sinon/stub');\r\n        /* require */('./sinon/mock');\r\n        /* require */('./sinon/collection');\r\n        /* require */('./sinon/assert');\r\n        /* require */('./sinon/sandbox');\r\n        /* require */('./sinon/test');\r\n        /* require */('./sinon/test_case');\r\n        /* require */('./sinon/match');\r\n        /* require */('./sinon/format');\r\n        /* require */('./sinon/log_error');\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        sinonModule = module.exports;\r\n    } else {\r\n        sinonModule = {};\r\n    }\r\n\r\n    return sinonModule;\r\n}());\r\n\r\n/**\r\n * depend ../../sinon.js\r\n */\r\n/**\r\n * Sinon core utilities. For internal use only.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    var div = typeof document !== 'undefined' && document.createElement('div');\r\n    var hasOwn = Object.prototype.hasOwnProperty;\r\n\r\n    function isDOMNode(obj) {\r\n        var success = false;\r\n\r\n        try {\r\n            obj.appendChild(div);\r\n            success = div.parentNode === obj;\r\n        } catch (e) {\r\n            return false;\r\n        } finally {\r\n            try {\r\n                obj.removeChild(div);\r\n            } catch (e) {\r\n                // Remove failed, not much we can do about that\r\n            }\r\n        }\r\n\r\n        return success;\r\n    }\r\n\r\n    function isElement(obj) {\r\n        return div && obj && obj.nodeType === 1 && isDOMNode(obj);\r\n    }\r\n\r\n    function isFunction(obj) {\r\n        return typeof obj === 'function' || !!(obj && obj.constructor && obj.call && obj.apply);\r\n    }\r\n\r\n    function isReallyNaN(val) {\r\n        return typeof val === 'number' && isNaN(val);\r\n    }\r\n\r\n    function mirrorProperties(target, source) {\r\n        for (var prop in source) {\r\n            if (!hasOwn.call(target, prop)) {\r\n                target[prop] = source[prop];\r\n            }\r\n        }\r\n    }\r\n\r\n    function isRestorable(obj) {\r\n        return typeof obj === 'function' && typeof obj.restore === 'function' && obj.restore.sinon;\r\n    }\r\n\r\n    // Cheap way to detect if we have ES5 support.\r\n    var hasES5Support = 'keys' in Object;\r\n\r\n    function makeApi(sinon) {\r\n        sinon.wrapMethod = function wrapMethod(object, property, method) {\r\n            if (!object) {\r\n                throw new TypeError('Should wrap property of object');\r\n            }\r\n\r\n            if (typeof method !== 'function' && typeof method !== 'object') {\r\n                throw new TypeError('Method wrapper should be a function or a property descriptor');\r\n            }\r\n\r\n            function checkWrappedMethod(wrappedMethod) {\r\n                var error;\r\n\r\n                if (!isFunction(wrappedMethod)) {\r\n                    error = new TypeError('Attempted to wrap ' + (typeof wrappedMethod) + ' property ' +\r\n                                        property + ' as function');\r\n                } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {\r\n                    error = new TypeError('Attempted to wrap ' + property + ' which is already wrapped');\r\n                } else if (wrappedMethod.calledBefore) {\r\n                    var verb = wrappedMethod.returns ? 'stubbed' : 'spied on';\r\n                    error = new TypeError('Attempted to wrap ' + property + ' which is already ' + verb);\r\n                }\r\n\r\n                if (error) {\r\n                    if (wrappedMethod && wrappedMethod.stackTrace) {\r\n                        error.stack += '\\n--------------\\n' + wrappedMethod.stackTrace;\r\n                    }\r\n                    throw error;\r\n                }\r\n            }\r\n\r\n            var error, wrappedMethod, i;\r\n\r\n            // IE 8 does not support hasOwnProperty on the window object and Firefox has a problem\r\n            // when using hasOwn.call on objects from other frames.\r\n            var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);\r\n\r\n            if (hasES5Support) {\r\n                var methodDesc = (typeof method === 'function') ? {value: method} : method;\r\n                var wrappedMethodDesc = sinon.getPropertyDescriptor(object, property);\r\n\r\n                if (!wrappedMethodDesc) {\r\n                    error = new TypeError('Attempted to wrap ' + (typeof wrappedMethod) + ' property ' +\r\n                                        property + ' as function');\r\n                } else if (wrappedMethodDesc.restore && wrappedMethodDesc.restore.sinon) {\r\n                    error = new TypeError('Attempted to wrap ' + property + ' which is already wrapped');\r\n                }\r\n                if (error) {\r\n                    if (wrappedMethodDesc && wrappedMethodDesc.stackTrace) {\r\n                        error.stack += '\\n--------------\\n' + wrappedMethodDesc.stackTrace;\r\n                    }\r\n                    throw error;\r\n                }\r\n\r\n                var types = sinon.objectKeys(methodDesc);\r\n                for (i = 0; i < types.length; i++) {\r\n                    wrappedMethod = wrappedMethodDesc[types[i]];\r\n                    checkWrappedMethod(wrappedMethod);\r\n                }\r\n\r\n                mirrorProperties(methodDesc, wrappedMethodDesc);\r\n                for (i = 0; i < types.length; i++) {\r\n                    mirrorProperties(methodDesc[types[i]], wrappedMethodDesc[types[i]]);\r\n                }\r\n                Object.defineProperty(object, property, methodDesc);\r\n            } else {\r\n                wrappedMethod = object[property];\r\n                checkWrappedMethod(wrappedMethod);\r\n                object[property] = method;\r\n                method.displayName = property;\r\n            }\r\n\r\n            method.displayName = property;\r\n\r\n            // Set up a stack trace which can be used later to find what line of\r\n            // code the original method was created on.\r\n            method.stackTrace = (new Error('Stack Trace for original')).stack;\r\n\r\n            method.restore = function () {\r\n                // For prototype properties try to reset by delete first.\r\n                // If this fails (ex: localStorage on mobile safari) then force a reset\r\n                // via direct assignment.\r\n                if (!owned) {\r\n                    // In some cases `delete` may throw an error\r\n                    try {\r\n                        delete object[property];\r\n                    } catch (e) {} // eslint-disable-line no-empty\r\n                    // For native code functions `delete` fails without throwing an error\r\n                    // on Chrome < 43, PhantomJS, etc.\r\n                } else if (hasES5Support) {\r\n                    Object.defineProperty(object, property, wrappedMethodDesc);\r\n                }\r\n\r\n                // Use strict equality comparison to check failures then force a reset\r\n                // via direct assignment.\r\n                if (object[property] === method) {\r\n                    object[property] = wrappedMethod;\r\n                }\r\n            };\r\n\r\n            method.restore.sinon = true;\r\n\r\n            if (!hasES5Support) {\r\n                mirrorProperties(method, wrappedMethod);\r\n            }\r\n\r\n            return method;\r\n        };\r\n\r\n        sinon.create = function create(proto) {\r\n            var F = function () {};\r\n            F.prototype = proto;\r\n            return new F();\r\n        };\r\n\r\n        sinon.deepEqual = function deepEqual(a, b) {\r\n            if (sinon.match && sinon.match.isMatcher(a)) {\r\n                return a.test(b);\r\n            }\r\n\r\n            if (typeof a !== 'object' || typeof b !== 'object') {\r\n                return isReallyNaN(a) && isReallyNaN(b) || a === b;\r\n            }\r\n\r\n            if (isElement(a) || isElement(b)) {\r\n                return a === b;\r\n            }\r\n\r\n            if (a === b) {\r\n                return true;\r\n            }\r\n\r\n            if ((a === null && b !== null) || (a !== null && b === null)) {\r\n                return false;\r\n            }\r\n\r\n            if (a instanceof RegExp && b instanceof RegExp) {\r\n                return (a.source === b.source) && (a.global === b.global) &&\r\n                    (a.ignoreCase === b.ignoreCase) && (a.multiline === b.multiline);\r\n            }\r\n\r\n            var aString = Object.prototype.toString.call(a);\r\n            if (aString !== Object.prototype.toString.call(b)) {\r\n                return false;\r\n            }\r\n\r\n            if (aString === '[object Date]') {\r\n                return a.valueOf() === b.valueOf();\r\n            }\r\n\r\n            var prop;\r\n            var aLength = 0;\r\n            var bLength = 0;\r\n\r\n            if (aString === '[object Array]' && a.length !== b.length) {\r\n                return false;\r\n            }\r\n\r\n            for (prop in a) {\r\n                if (a.hasOwnProperty(prop)) {\r\n                    aLength += 1;\r\n\r\n                    if (!(prop in b)) {\r\n                        return false;\r\n                    }\r\n\r\n                    if (!deepEqual(a[prop], b[prop])) {\r\n                        return false;\r\n                    }\r\n                }\r\n            }\r\n\r\n            for (prop in b) {\r\n                if (b.hasOwnProperty(prop)) {\r\n                    bLength += 1;\r\n                }\r\n            }\r\n\r\n            return aLength === bLength;\r\n        };\r\n\r\n        sinon.functionName = function functionName(func) {\r\n            var name = func.displayName || func.name;\r\n\r\n            // Use function decomposition as a last resort to get function\r\n            // name. Does not rely on function decomposition to work - if it\r\n            // doesn't debugging will be slightly less informative\r\n            // (i.e. toString will say 'spy' rather than 'myFunc').\r\n            if (!name) {\r\n                var matches = func.toString().match(/function ([^\\s\\(]+)/);\r\n                name = matches && matches[1];\r\n            }\r\n\r\n            return name;\r\n        };\r\n\r\n        sinon.functionToString = function toString() {\r\n            if (this.getCall && this.callCount) {\r\n                var thisValue,\r\n                    prop;\r\n                var i = this.callCount;\r\n\r\n                while (i--) {\r\n                    thisValue = this.getCall(i).thisValue;\r\n\r\n                    for (prop in thisValue) {\r\n                        if (thisValue[prop] === this) {\r\n                            return prop;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n\r\n            return this.displayName || 'sinon fake';\r\n        };\r\n\r\n        sinon.objectKeys = function objectKeys(obj) {\r\n            if (obj !== Object(obj)) {\r\n                throw new TypeError('sinon.objectKeys called on a non-object');\r\n            }\r\n\r\n            var keys = [];\r\n            var key;\r\n            for (key in obj) {\r\n                if (hasOwn.call(obj, key)) {\r\n                    keys.push(key);\r\n                }\r\n            }\r\n\r\n            return keys;\r\n        };\r\n\r\n        sinon.getPropertyDescriptor = function getPropertyDescriptor(object, property) {\r\n            var proto = object;\r\n            var descriptor;\r\n\r\n            while (proto && !(descriptor = Object.getOwnPropertyDescriptor(proto, property))) {\r\n                proto = Object.getPrototypeOf(proto);\r\n            }\r\n            return descriptor;\r\n        };\r\n\r\n        sinon.getConfig = function (custom) {\r\n            var config = {};\r\n            custom = custom || {};\r\n            var defaults = sinon.defaultConfig;\r\n\r\n            for (var prop in defaults) {\r\n                if (defaults.hasOwnProperty(prop)) {\r\n                    config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];\r\n                }\r\n            }\r\n\r\n            return config;\r\n        };\r\n\r\n        sinon.defaultConfig = {\r\n            injectIntoThis: true,\r\n            injectInto: null,\r\n            properties: ['spy', 'stub', 'mock', 'clock', 'server', 'requests'],\r\n            useFakeTimers: true,\r\n            useFakeServer: true\r\n        };\r\n\r\n        sinon.timesInWords = function timesInWords(count) {\r\n            return count === 1 && 'once' ||\r\n                count === 2 && 'twice' ||\r\n                count === 3 && 'thrice' ||\r\n                (count || 0) + ' times';\r\n        };\r\n\r\n        sinon.calledInOrder = function (spies) {\r\n            for (var i = 1, l = spies.length; i < l; i++) {\r\n                if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {\r\n                    return false;\r\n                }\r\n            }\r\n\r\n            return true;\r\n        };\r\n\r\n        sinon.orderByFirstCall = function (spies) {\r\n            return spies.sort(function (a, b) {\r\n                // uuid, won't ever be equal\r\n                var aCall = a.getCall(0);\r\n                var bCall = b.getCall(0);\r\n                var aId = aCall && aCall.callId || -1;\r\n                var bId = bCall && bCall.callId || -1;\r\n\r\n                return aId < bId ? -1 : 1;\r\n            });\r\n        };\r\n\r\n        sinon.createStubInstance = function (constructor) {\r\n            if (typeof constructor !== 'function') {\r\n                throw new TypeError('The constructor should be a function.');\r\n            }\r\n            return sinon.stub(sinon.create(constructor.prototype));\r\n        };\r\n\r\n        sinon.restore = function (object) {\r\n            if (object !== null && typeof object === 'object') {\r\n                for (var prop in object) {\r\n                    if (isRestorable(object[prop])) {\r\n                        object[prop].restore();\r\n                    }\r\n                }\r\n            } else if (isRestorable(object)) {\r\n                object.restore();\r\n            }\r\n        };\r\n\r\n        return sinon;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = /* typeof define === \"function\" && typeof define.amd === \"object\" && define.amd */ false;\r\n\r\n    function loadDependencies(require, exports) {\r\n        makeApi(exports);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n\r\n        // Adapted from https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug\r\n        var hasDontEnumBug = (function () {\r\n            var obj = {\r\n                constructor: function () {\r\n                    return '0';\r\n                },\r\n                toString: function () {\r\n                    return '1';\r\n                },\r\n                valueOf: function () {\r\n                    return '2';\r\n                },\r\n                toLocaleString: function () {\r\n                    return '3';\r\n                },\r\n                prototype: function () {\r\n                    return '4';\r\n                },\r\n                isPrototypeOf: function () {\r\n                    return '5';\r\n                },\r\n                propertyIsEnumerable: function () {\r\n                    return '6';\r\n                },\r\n                hasOwnProperty: function () {\r\n                    return '7';\r\n                },\r\n                length: function () {\r\n                    return '8';\r\n                },\r\n                unique: function () {\r\n                    return '9';\r\n                }\r\n            };\r\n\r\n            var result = [];\r\n            for (var prop in obj) {\r\n                if (obj.hasOwnProperty(prop)) {\r\n                    result.push(obj[prop]());\r\n                }\r\n            }\r\n            return result.join('') !== '0123456789';\r\n        })();\r\n\r\n        /* Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will\r\n         *         override properties in previous sources.\r\n         *\r\n         * target - The Object to extend\r\n         * sources - Objects to copy properties from.\r\n         *\r\n         * Returns the extended target\r\n         */\r\n        function extend(target /*, sources */) {\r\n            var sources = Array.prototype.slice.call(arguments, 1);\r\n            var source, i, prop;\r\n\r\n            for (i = 0; i < sources.length; i++) {\r\n                source = sources[i];\r\n\r\n                for (prop in source) {\r\n                    if (source.hasOwnProperty(prop)) {\r\n                        target[prop] = source[prop];\r\n                    }\r\n                }\r\n\r\n                // Make sure we copy (own) toString method even when in JScript with DontEnum bug\r\n                // See https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug\r\n                if (hasDontEnumBug && source.hasOwnProperty('toString') && source.toString !== target.toString) {\r\n                    target.toString = source.toString;\r\n                }\r\n            }\r\n\r\n            return target;\r\n        }\r\n\r\n        sinon.extend = extend;\r\n        return sinon.extend;\r\n    }\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n\r\n        function timesInWords(count) {\r\n            switch (count) {\r\n                case 1:\r\n                    return 'once';\r\n                case 2:\r\n                    return 'twice';\r\n                case 3:\r\n                    return 'thrice';\r\n                default:\r\n                    return (count || 0) + ' times';\r\n            }\r\n        }\r\n\r\n        sinon.timesInWords = timesInWords;\r\n        return sinon.timesInWords;\r\n    }\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var core = /* require */('./util/core');\r\n        module.exports = makeApi(core);\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n */\r\n/**\r\n * Format functions\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2014 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        function typeOf(value) {\r\n            if (value === null) {\r\n                return 'null';\r\n            } else if (value === undefined) {\r\n                return 'undefined';\r\n            }\r\n            var string = Object.prototype.toString.call(value);\r\n            return string.substring(8, string.length - 1).toLowerCase();\r\n        }\r\n\r\n        sinon.typeOf = typeOf;\r\n        return sinon.typeOf;\r\n    }\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var core = /* require */('./util/core');\r\n        module.exports = makeApi(core);\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n * depend typeOf.js\r\n */\r\n/*jslint eqeqeq: false, onevar: false, plusplus: false*/\r\n/*global module, require, sinon*/\r\n/**\r\n * Match functions\r\n *\r\n * @author Maximilian Antoni (mail@maxantoni.de)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2012 Maximilian Antoni\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        function assertType(value, type, name) {\r\n            var actual = sinon.typeOf(value);\r\n            if (actual !== type) {\r\n                throw new TypeError('Expected type of ' + name + ' to be ' +\r\n                    type + ', but was ' + actual);\r\n            }\r\n        }\r\n\r\n        var matcher = {\r\n            toString: function () {\r\n                return this.message;\r\n            }\r\n        };\r\n\r\n        function isMatcher(object) {\r\n            return matcher.isPrototypeOf(object);\r\n        }\r\n\r\n        function matchObject(expectation, actual) {\r\n            if (actual === null || actual === undefined) {\r\n                return false;\r\n            }\r\n            for (var key in expectation) {\r\n                if (expectation.hasOwnProperty(key)) {\r\n                    var exp = expectation[key];\r\n                    var act = actual[key];\r\n                    if (isMatcher(exp)) {\r\n                        if (!exp.test(act)) {\r\n                            return false;\r\n                        }\r\n                    } else if (sinon.typeOf(exp) === 'object') {\r\n                        if (!matchObject(exp, act)) {\r\n                            return false;\r\n                        }\r\n                    } else if (!sinon.deepEqual(exp, act)) {\r\n                        return false;\r\n                    }\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n\r\n        function match(expectation, message) {\r\n            var m = sinon.create(matcher);\r\n            var type = sinon.typeOf(expectation);\r\n            switch (type) {\r\n            case 'object':\r\n                if (typeof expectation.test === 'function') {\r\n                    m.test = function (actual) {\r\n                        return expectation.test(actual) === true;\r\n                    };\r\n                    m.message = 'match(' + sinon.functionName(expectation.test) + ')';\r\n                    return m;\r\n                }\r\n                var str = [];\r\n                for (var key in expectation) {\r\n                    if (expectation.hasOwnProperty(key)) {\r\n                        str.push(key + ': ' + expectation[key]);\r\n                    }\r\n                }\r\n                m.test = function (actual) {\r\n                    return matchObject(expectation, actual);\r\n                };\r\n                m.message = 'match(' + str.join(', ') + ')';\r\n                break;\r\n            case 'number':\r\n                m.test = function (actual) {\r\n                    // we need type coercion here\r\n                    return expectation == actual; // eslint-disable-line eqeqeq\r\n                };\r\n                break;\r\n            case 'string':\r\n                m.test = function (actual) {\r\n                    if (typeof actual !== 'string') {\r\n                        return false;\r\n                    }\r\n                    return actual.indexOf(expectation) !== -1;\r\n                };\r\n                m.message = 'match(\"' + expectation + '\")';\r\n                break;\r\n            case 'regexp':\r\n                m.test = function (actual) {\r\n                    if (typeof actual !== 'string') {\r\n                        return false;\r\n                    }\r\n                    return expectation.test(actual);\r\n                };\r\n                break;\r\n            case 'function':\r\n                m.test = expectation;\r\n                if (message) {\r\n                    m.message = message;\r\n                } else {\r\n                    m.message = 'match(' + sinon.functionName(expectation) + ')';\r\n                }\r\n                break;\r\n            default:\r\n                m.test = function (actual) {\r\n                    return sinon.deepEqual(expectation, actual);\r\n                };\r\n            }\r\n            if (!m.message) {\r\n                m.message = 'match(' + expectation + ')';\r\n            }\r\n            return m;\r\n        }\r\n\r\n        matcher.or = function (m2) {\r\n            if (!arguments.length) {\r\n                throw new TypeError('Matcher expected');\r\n            } else if (!isMatcher(m2)) {\r\n                m2 = match(m2);\r\n            }\r\n            var m1 = this;\r\n            var or = sinon.create(matcher);\r\n            or.test = function (actual) {\r\n                return m1.test(actual) || m2.test(actual);\r\n            };\r\n            or.message = m1.message + '.or(' + m2.message + ')';\r\n            return or;\r\n        };\r\n\r\n        matcher.and = function (m2) {\r\n            if (!arguments.length) {\r\n                throw new TypeError('Matcher expected');\r\n            } else if (!isMatcher(m2)) {\r\n                m2 = match(m2);\r\n            }\r\n            var m1 = this;\r\n            var and = sinon.create(matcher);\r\n            and.test = function (actual) {\r\n                return m1.test(actual) && m2.test(actual);\r\n            };\r\n            and.message = m1.message + '.and(' + m2.message + ')';\r\n            return and;\r\n        };\r\n\r\n        match.isMatcher = isMatcher;\r\n\r\n        match.any = match(function () {\r\n            return true;\r\n        }, 'any');\r\n\r\n        match.defined = match(function (actual) {\r\n            return actual !== null && actual !== undefined;\r\n        }, 'defined');\r\n\r\n        match.truthy = match(function (actual) {\r\n            return !!actual;\r\n        }, 'truthy');\r\n\r\n        match.falsy = match(function (actual) {\r\n            return !actual;\r\n        }, 'falsy');\r\n\r\n        match.same = function (expectation) {\r\n            return match(function (actual) {\r\n                return expectation === actual;\r\n            }, 'same(' + expectation + ')');\r\n        };\r\n\r\n        match.typeOf = function (type) {\r\n            assertType(type, 'string', 'type');\r\n            return match(function (actual) {\r\n                return sinon.typeOf(actual) === type;\r\n            }, 'typeOf(\"' + type + '\")');\r\n        };\r\n\r\n        match.instanceOf = function (type) {\r\n            assertType(type, 'function', 'type');\r\n            return match(function (actual) {\r\n                return actual instanceof type;\r\n            }, 'instanceOf(' + sinon.functionName(type) + ')');\r\n        };\r\n\r\n        function createPropertyMatcher(propertyTest, messagePrefix) {\r\n            return function (property, value) {\r\n                assertType(property, 'string', 'property');\r\n                var onlyProperty = arguments.length === 1;\r\n                var message = messagePrefix + '(\"' + property + '\"';\r\n                if (!onlyProperty) {\r\n                    message += ', ' + value;\r\n                }\r\n                message += ')';\r\n                return match(function (actual) {\r\n                    if (actual === undefined || actual === null ||\r\n                            !propertyTest(actual, property)) {\r\n                        return false;\r\n                    }\r\n                    return onlyProperty || sinon.deepEqual(value, actual[property]);\r\n                }, message);\r\n            };\r\n        }\r\n\r\n        match.has = createPropertyMatcher(function (actual, property) {\r\n            if (typeof actual === 'object') {\r\n                return property in actual;\r\n            }\r\n            return actual[property] !== undefined;\r\n        }, 'has');\r\n\r\n        match.hasOwn = createPropertyMatcher(function (actual, property) {\r\n            return actual.hasOwnProperty(property);\r\n        }, 'hasOwn');\r\n\r\n        match.bool = match.typeOf('boolean');\r\n        match.number = match.typeOf('number');\r\n        match.string = match.typeOf('string');\r\n        match.object = match.typeOf('object');\r\n        match.func = match.typeOf('function');\r\n        match.array = match.typeOf('array');\r\n        match.regexp = match.typeOf('regexp');\r\n        match.date = match.typeOf('date');\r\n\r\n        sinon.match = match;\r\n        return match;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./typeOf');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n */\r\n/**\r\n * Format functions\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2014 Christian Johansen\r\n */\r\n(function (sinonGlobal, formatio) {\r\n\r\n    function makeApi(sinon) {\r\n        function valueFormatter(value) {\r\n            return '' + value;\r\n        }\r\n\r\n        function getFormatioFormatter() {\r\n            var formatter = formatio.configure({\r\n                    quoteStrings: false,\r\n                    limitChildrenCount: 250\r\n                });\r\n\r\n            function format() {\r\n                return formatter.ascii.apply(formatter, arguments);\r\n            }\r\n\r\n            return format;\r\n        }\r\n\r\n        function getNodeFormatter() {\r\n            try {\r\n                var util = /* require */('util');\r\n            } catch (e) {\r\n                /* Node, but no util module - would be very old, but better safe than sorry */\r\n            }\r\n\r\n            function format(v) {\r\n                var isObjectWithNativeToString = typeof v === 'object' && v.toString === Object.prototype.toString;\r\n                return isObjectWithNativeToString ? util.inspect(v) : v;\r\n            }\r\n\r\n            return util ? format : valueFormatter;\r\n        }\r\n\r\n        var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n        var formatter;\r\n\r\n        if (isNode) {\r\n            try {\r\n                formatio = /* require */('formatio');\r\n            }\r\n            catch (e) {} // eslint-disable-line no-empty\r\n        }\r\n\r\n        if (formatio) {\r\n            formatter = getFormatioFormatter();\r\n        } else if (isNode) {\r\n            formatter = getNodeFormatter();\r\n        } else {\r\n            formatter = valueFormatter;\r\n        }\r\n\r\n        sinon.format = formatter;\r\n        return sinon.format;\r\n    }\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon, // eslint-disable-line no-undef\r\n    typeof formatio === 'object' && formatio // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n  * depend util/core.js\r\n  * depend match.js\r\n  * depend format.js\r\n  */\r\n/**\r\n  * Spy calls\r\n  *\r\n  * @author Christian Johansen (christian@cjohansen.no)\r\n  * @author Maximilian Antoni (mail@maxantoni.de)\r\n  * @license BSD\r\n  *\r\n  * Copyright (c) 2010-2013 Christian Johansen\r\n  * Copyright (c) 2013 Maximilian Antoni\r\n  */\r\n(function (sinonGlobal) {\r\n\r\n    var slice = Array.prototype.slice;\r\n\r\n    function makeApi(sinon) {\r\n        function throwYieldError(proxy, text, args) {\r\n            var msg = sinon.functionName(proxy) + text;\r\n            if (args.length) {\r\n                msg += ' Received [' + slice.call(args).join(', ') + ']';\r\n            }\r\n            throw new Error(msg);\r\n        }\r\n\r\n        var callProto = {\r\n            calledOn: function calledOn(thisValue) {\r\n                if (sinon.match && sinon.match.isMatcher(thisValue)) {\r\n                    return thisValue.test(this.thisValue);\r\n                }\r\n                return this.thisValue === thisValue;\r\n            },\r\n\r\n            calledWith: function calledWith() {\r\n                var l = arguments.length;\r\n                if (l > this.args.length) {\r\n                    return false;\r\n                }\r\n                for (var i = 0; i < l; i += 1) {\r\n                    if (!sinon.deepEqual(arguments[i], this.args[i])) {\r\n                        return false;\r\n                    }\r\n                }\r\n\r\n                return true;\r\n            },\r\n\r\n            calledWithMatch: function calledWithMatch() {\r\n                var l = arguments.length;\r\n                if (l > this.args.length) {\r\n                    return false;\r\n                }\r\n                for (var i = 0; i < l; i += 1) {\r\n                    var actual = this.args[i];\r\n                    var expectation = arguments[i];\r\n                    if (!sinon.match || !sinon.match(expectation).test(actual)) {\r\n                        return false;\r\n                    }\r\n                }\r\n                return true;\r\n            },\r\n\r\n            calledWithExactly: function calledWithExactly() {\r\n                return arguments.length === this.args.length &&\r\n                    this.calledWith.apply(this, arguments);\r\n            },\r\n\r\n            notCalledWith: function notCalledWith() {\r\n                return !this.calledWith.apply(this, arguments);\r\n            },\r\n\r\n            notCalledWithMatch: function notCalledWithMatch() {\r\n                return !this.calledWithMatch.apply(this, arguments);\r\n            },\r\n\r\n            returned: function returned(value) {\r\n                return sinon.deepEqual(value, this.returnValue);\r\n            },\r\n\r\n            threw: function threw(error) {\r\n                if (typeof error === 'undefined' || !this.exception) {\r\n                    return !!this.exception;\r\n                }\r\n\r\n                return this.exception === error || this.exception.name === error;\r\n            },\r\n\r\n            calledWithNew: function calledWithNew() {\r\n                return this.proxy.prototype && this.thisValue instanceof this.proxy;\r\n            },\r\n\r\n            calledBefore: function (other) {\r\n                return this.callId < other.callId;\r\n            },\r\n\r\n            calledAfter: function (other) {\r\n                return this.callId > other.callId;\r\n            },\r\n\r\n            callArg: function (pos) {\r\n                this.args[pos]();\r\n            },\r\n\r\n            callArgOn: function (pos, thisValue) {\r\n                this.args[pos].apply(thisValue);\r\n            },\r\n\r\n            callArgWith: function (pos) {\r\n                this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));\r\n            },\r\n\r\n            callArgOnWith: function (pos, thisValue) {\r\n                var args = slice.call(arguments, 2);\r\n                this.args[pos].apply(thisValue, args);\r\n            },\r\n\r\n            'yield': function () {\r\n                this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));\r\n            },\r\n\r\n            yieldOn: function (thisValue) {\r\n                var args = this.args;\r\n                for (var i = 0, l = args.length; i < l; ++i) {\r\n                    if (typeof args[i] === 'function') {\r\n                        args[i].apply(thisValue, slice.call(arguments, 1));\r\n                        return;\r\n                    }\r\n                }\r\n                throwYieldError(this.proxy, ' cannot yield since no callback was passed.', args);\r\n            },\r\n\r\n            yieldTo: function (prop) {\r\n                this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));\r\n            },\r\n\r\n            yieldToOn: function (prop, thisValue) {\r\n                var args = this.args;\r\n                for (var i = 0, l = args.length; i < l; ++i) {\r\n                    if (args[i] && typeof args[i][prop] === 'function') {\r\n                        args[i][prop].apply(thisValue, slice.call(arguments, 2));\r\n                        return;\r\n                    }\r\n                }\r\n                throwYieldError(this.proxy, ' cannot yield to \\'' + prop +\r\n                    '\\' since no callback was passed.', args);\r\n            },\r\n\r\n            getStackFrames: function () {\r\n                // Omit the error message and the two top stack frames in sinon itself:\r\n                return this.stack && this.stack.split('\\n').slice(3);\r\n            },\r\n\r\n            toString: function () {\r\n                var callStr = this.proxy.toString() + '(';\r\n                var args = [];\r\n\r\n                for (var i = 0, l = this.args.length; i < l; ++i) {\r\n                    args.push(sinon.format(this.args[i]));\r\n                }\r\n\r\n                callStr = callStr + args.join(', ') + ')';\r\n\r\n                if (typeof this.returnValue !== 'undefined') {\r\n                    callStr += ' => ' + sinon.format(this.returnValue);\r\n                }\r\n\r\n                if (this.exception) {\r\n                    callStr += ' !' + this.exception.name;\r\n\r\n                    if (this.exception.message) {\r\n                        callStr += '(' + this.exception.message + ')';\r\n                    }\r\n                }\r\n                if (this.stack) {\r\n                    callStr += this.getStackFrames()[0].replace(/^\\s*(?:at\\s+|@)?/, ' at ');\r\n\r\n                }\r\n\r\n                return callStr;\r\n            }\r\n        };\r\n\r\n        callProto.invokeCallback = callProto.yield;\r\n\r\n        function createSpyCall(spy, thisValue, args, returnValue, exception, id, stack) {\r\n            if (typeof id !== 'number') {\r\n                throw new TypeError('Call id is not a number');\r\n            }\r\n            var proxyCall = sinon.create(callProto);\r\n            proxyCall.proxy = spy;\r\n            proxyCall.thisValue = thisValue;\r\n            proxyCall.args = args;\r\n            proxyCall.returnValue = returnValue;\r\n            proxyCall.exception = exception;\r\n            proxyCall.callId = id;\r\n            proxyCall.stack = stack;\r\n\r\n            return proxyCall;\r\n        }\r\n        createSpyCall.toString = callProto.toString; // used by mocks\r\n\r\n        sinon.spyCall = createSpyCall;\r\n        return createSpyCall;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./match');\r\n        /* require */('./format');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n  * depend times_in_words.js\r\n  * depend util/core.js\r\n  * depend extend.js\r\n  * depend call.js\r\n  * depend format.js\r\n  */\r\n/**\r\n  * Spy functions\r\n  *\r\n  * @author Christian Johansen (christian@cjohansen.no)\r\n  * @license BSD\r\n  *\r\n  * Copyright (c) 2010-2013 Christian Johansen\r\n  */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        var push = Array.prototype.push;\r\n        var slice = Array.prototype.slice;\r\n        var callId = 0;\r\n\r\n        function spy(object, property, types) {\r\n            if (!property && typeof object === 'function') {\r\n                return spy.create(object);\r\n            }\r\n\r\n            if (!object && !property) {\r\n                return spy.create(function () { });\r\n            }\r\n\r\n            if (types) {\r\n                var methodDesc = sinon.getPropertyDescriptor(object, property);\r\n                for (var i = 0; i < types.length; i++) {\r\n                    methodDesc[types[i]] = spy.create(methodDesc[types[i]]);\r\n                }\r\n                return sinon.wrapMethod(object, property, methodDesc);\r\n            }\r\n\r\n            return sinon.wrapMethod(object, property, spy.create(object[property]));\r\n        }\r\n\r\n        function matchingFake(fakes, args, strict) {\r\n            if (!fakes) {\r\n                return undefined;\r\n            }\r\n\r\n            for (var i = 0, l = fakes.length; i < l; i++) {\r\n                if (fakes[i].matches(args, strict)) {\r\n                    return fakes[i];\r\n                }\r\n            }\r\n        }\r\n\r\n        function incrementCallCount() {\r\n            this.called = true;\r\n            this.callCount += 1;\r\n            this.notCalled = false;\r\n            this.calledOnce = this.callCount === 1;\r\n            this.calledTwice = this.callCount === 2;\r\n            this.calledThrice = this.callCount === 3;\r\n        }\r\n\r\n        function createCallProperties() {\r\n            this.firstCall = this.getCall(0);\r\n            this.secondCall = this.getCall(1);\r\n            this.thirdCall = this.getCall(2);\r\n            this.lastCall = this.getCall(this.callCount - 1);\r\n        }\r\n\r\n        var vars = 'a,b,c,d,e,f,g,h,i,j,k,l';\r\n        function createProxy(func, proxyLength) {\r\n            // Retain the function length:\r\n            var p;\r\n            if (proxyLength) {\r\n                eval('p = (function proxy(' + vars.substring(0, proxyLength * 2 - 1) + // eslint-disable-line no-eval\r\n                    ') { return p.invoke(func, this, slice.call(arguments)); });');\r\n            } else {\r\n                p = function proxy() {\r\n                    return p.invoke(func, this, slice.call(arguments));\r\n                };\r\n            }\r\n            p.isSinonProxy = true;\r\n            return p;\r\n        }\r\n\r\n        var uuid = 0;\r\n\r\n        // Public API\r\n        var spyApi = {\r\n            reset: function () {\r\n                if (this.invoking) {\r\n                    var err = new Error('Cannot reset Sinon function while invoking it. ' +\r\n                                        'Move the call to .reset outside of the callback.');\r\n                    err.name = 'InvalidResetException';\r\n                    throw err;\r\n                }\r\n\r\n                this.called = false;\r\n                this.notCalled = true;\r\n                this.calledOnce = false;\r\n                this.calledTwice = false;\r\n                this.calledThrice = false;\r\n                this.callCount = 0;\r\n                this.firstCall = null;\r\n                this.secondCall = null;\r\n                this.thirdCall = null;\r\n                this.lastCall = null;\r\n                this.args = [];\r\n                this.returnValues = [];\r\n                this.thisValues = [];\r\n                this.exceptions = [];\r\n                this.callIds = [];\r\n                this.stacks = [];\r\n                if (this.fakes) {\r\n                    for (var i = 0; i < this.fakes.length; i++) {\r\n                        this.fakes[i].reset();\r\n                    }\r\n                }\r\n\r\n                return this;\r\n            },\r\n\r\n            create: function create(func, spyLength) {\r\n                var name;\r\n\r\n                if (typeof func !== 'function') {\r\n                    func = function () { };\r\n                } else {\r\n                    name = sinon.functionName(func);\r\n                }\r\n\r\n                if (!spyLength) {\r\n                    spyLength = func.length;\r\n                }\r\n\r\n                var proxy = createProxy(func, spyLength);\r\n\r\n                sinon.extend(proxy, spy);\r\n                delete proxy.create;\r\n                sinon.extend(proxy, func);\r\n\r\n                proxy.reset();\r\n                proxy.prototype = func.prototype;\r\n                proxy.displayName = name || 'spy';\r\n                proxy.toString = sinon.functionToString;\r\n                proxy.instantiateFake = sinon.spy.create;\r\n                proxy.id = 'spy#' + uuid++;\r\n\r\n                return proxy;\r\n            },\r\n\r\n            invoke: function invoke(func, thisValue, args) {\r\n                var matching = matchingFake(this.fakes, args);\r\n                var exception, returnValue;\r\n\r\n                incrementCallCount.call(this);\r\n                push.call(this.thisValues, thisValue);\r\n                push.call(this.args, args);\r\n                push.call(this.callIds, callId++);\r\n\r\n                // Make call properties available from within the spied function:\r\n                createCallProperties.call(this);\r\n\r\n                try {\r\n                    this.invoking = true;\r\n\r\n                    if (matching) {\r\n                        returnValue = matching.invoke(func, thisValue, args);\r\n                    } else {\r\n                        returnValue = (this.func || func).apply(thisValue, args);\r\n                    }\r\n\r\n                    var thisCall = this.getCall(this.callCount - 1);\r\n                    if (thisCall.calledWithNew() && typeof returnValue !== 'object') {\r\n                        returnValue = thisValue;\r\n                    }\r\n                } catch (e) {\r\n                    exception = e;\r\n                } finally {\r\n                    delete this.invoking;\r\n                }\r\n\r\n                push.call(this.exceptions, exception);\r\n                push.call(this.returnValues, returnValue);\r\n                push.call(this.stacks, new Error().stack);\r\n\r\n                // Make return value and exception available in the calls:\r\n                createCallProperties.call(this);\r\n\r\n                if (exception !== undefined) {\r\n                    throw exception;\r\n                }\r\n\r\n                return returnValue;\r\n            },\r\n\r\n            named: function named(name) {\r\n                this.displayName = name;\r\n                return this;\r\n            },\r\n\r\n            getCall: function getCall(i) {\r\n                if (i < 0 || i >= this.callCount) {\r\n                    return null;\r\n                }\r\n\r\n                return sinon.spyCall(this, this.thisValues[i], this.args[i],\r\n                                        this.returnValues[i], this.exceptions[i],\r\n                                        this.callIds[i], this.stacks[i]);\r\n            },\r\n\r\n            getCalls: function () {\r\n                var calls = [];\r\n                var i;\r\n\r\n                for (i = 0; i < this.callCount; i++) {\r\n                    calls.push(this.getCall(i));\r\n                }\r\n\r\n                return calls;\r\n            },\r\n\r\n            calledBefore: function calledBefore(spyFn) {\r\n                if (!this.called) {\r\n                    return false;\r\n                }\r\n\r\n                if (!spyFn.called) {\r\n                    return true;\r\n                }\r\n\r\n                return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];\r\n            },\r\n\r\n            calledAfter: function calledAfter(spyFn) {\r\n                if (!this.called || !spyFn.called) {\r\n                    return false;\r\n                }\r\n\r\n                return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];\r\n            },\r\n\r\n            withArgs: function () {\r\n                var args = slice.call(arguments);\r\n\r\n                if (this.fakes) {\r\n                    var match = matchingFake(this.fakes, args, true);\r\n\r\n                    if (match) {\r\n                        return match;\r\n                    }\r\n                } else {\r\n                    this.fakes = [];\r\n                }\r\n\r\n                var original = this;\r\n                var fake = this.instantiateFake();\r\n                fake.matchingAguments = args;\r\n                fake.parent = this;\r\n                push.call(this.fakes, fake);\r\n\r\n                fake.withArgs = function () {\r\n                    return original.withArgs.apply(original, arguments);\r\n                };\r\n\r\n                for (var i = 0; i < this.args.length; i++) {\r\n                    if (fake.matches(this.args[i])) {\r\n                        incrementCallCount.call(fake);\r\n                        push.call(fake.thisValues, this.thisValues[i]);\r\n                        push.call(fake.args, this.args[i]);\r\n                        push.call(fake.returnValues, this.returnValues[i]);\r\n                        push.call(fake.exceptions, this.exceptions[i]);\r\n                        push.call(fake.callIds, this.callIds[i]);\r\n                    }\r\n                }\r\n                createCallProperties.call(fake);\r\n\r\n                return fake;\r\n            },\r\n\r\n            matches: function (args, strict) {\r\n                var margs = this.matchingAguments;\r\n\r\n                if (margs.length <= args.length &&\r\n                    sinon.deepEqual(margs, args.slice(0, margs.length))) {\r\n                    return !strict || margs.length === args.length;\r\n                }\r\n            },\r\n\r\n            printf: function (format) {\r\n                var spyInstance = this;\r\n                var args = slice.call(arguments, 1);\r\n                var formatter;\r\n\r\n                return (format || '').replace(/%(.)/g, function (match, specifyer) {\r\n                    formatter = spyApi.formatters[specifyer];\r\n\r\n                    if (typeof formatter === 'function') {\r\n                        return formatter.call(null, spyInstance, args);\r\n                    } else if (!isNaN(parseInt(specifyer, 10))) {\r\n                        return sinon.format(args[specifyer - 1]);\r\n                    }\r\n\r\n                    return '%' + specifyer;\r\n                });\r\n            }\r\n        };\r\n\r\n        function delegateToCalls(method, matchAny, actual, notCalled) {\r\n            spyApi[method] = function () {\r\n                if (!this.called) {\r\n                    if (notCalled) {\r\n                        return notCalled.apply(this, arguments);\r\n                    }\r\n                    return false;\r\n                }\r\n\r\n                var currentCall;\r\n                var matches = 0;\r\n\r\n                for (var i = 0, l = this.callCount; i < l; i += 1) {\r\n                    currentCall = this.getCall(i);\r\n\r\n                    if (currentCall[actual || method].apply(currentCall, arguments)) {\r\n                        matches += 1;\r\n\r\n                        if (matchAny) {\r\n                            return true;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                return matches === this.callCount;\r\n            };\r\n        }\r\n\r\n        delegateToCalls('calledOn', true);\r\n        delegateToCalls('alwaysCalledOn', false, 'calledOn');\r\n        delegateToCalls('calledWith', true);\r\n        delegateToCalls('calledWithMatch', true);\r\n        delegateToCalls('alwaysCalledWith', false, 'calledWith');\r\n        delegateToCalls('alwaysCalledWithMatch', false, 'calledWithMatch');\r\n        delegateToCalls('calledWithExactly', true);\r\n        delegateToCalls('alwaysCalledWithExactly', false, 'calledWithExactly');\r\n        delegateToCalls('neverCalledWith', false, 'notCalledWith', function () {\r\n            return true;\r\n        });\r\n        delegateToCalls('neverCalledWithMatch', false, 'notCalledWithMatch', function () {\r\n            return true;\r\n        });\r\n        delegateToCalls('threw', true);\r\n        delegateToCalls('alwaysThrew', false, 'threw');\r\n        delegateToCalls('returned', true);\r\n        delegateToCalls('alwaysReturned', false, 'returned');\r\n        delegateToCalls('calledWithNew', true);\r\n        delegateToCalls('alwaysCalledWithNew', false, 'calledWithNew');\r\n        delegateToCalls('callArg', false, 'callArgWith', function () {\r\n            throw new Error(this.toString() + ' cannot call arg since it was not yet invoked.');\r\n        });\r\n        spyApi.callArgWith = spyApi.callArg;\r\n        delegateToCalls('callArgOn', false, 'callArgOnWith', function () {\r\n            throw new Error(this.toString() + ' cannot call arg since it was not yet invoked.');\r\n        });\r\n        spyApi.callArgOnWith = spyApi.callArgOn;\r\n        delegateToCalls('yield', false, 'yield', function () {\r\n            throw new Error(this.toString() + ' cannot yield since it was not yet invoked.');\r\n        });\r\n        // \"invokeCallback\" is an alias for \"yield\" since \"yield\" is invalid in strict mode.\r\n        spyApi.invokeCallback = spyApi.yield;\r\n        delegateToCalls('yieldOn', false, 'yieldOn', function () {\r\n            throw new Error(this.toString() + ' cannot yield since it was not yet invoked.');\r\n        });\r\n        delegateToCalls('yieldTo', false, 'yieldTo', function (property) {\r\n            throw new Error(this.toString() + ' cannot yield to \\'' + property +\r\n                '\\' since it was not yet invoked.');\r\n        });\r\n        delegateToCalls('yieldToOn', false, 'yieldToOn', function (property) {\r\n            throw new Error(this.toString() + ' cannot yield to \\'' + property +\r\n                '\\' since it was not yet invoked.');\r\n        });\r\n\r\n        spyApi.formatters = {\r\n            c: function (spyInstance) {\r\n                return sinon.timesInWords(spyInstance.callCount);\r\n            },\r\n\r\n            n: function (spyInstance) {\r\n                return spyInstance.toString();\r\n            },\r\n\r\n            C: function (spyInstance) {\r\n                var calls = [];\r\n\r\n                for (var i = 0, l = spyInstance.callCount; i < l; ++i) {\r\n                    var stringifiedCall = '    ' + spyInstance.getCall(i).toString();\r\n                    if (/\\n/.test(calls[i - 1])) {\r\n                        stringifiedCall = '\\n' + stringifiedCall;\r\n                    }\r\n                    push.call(calls, stringifiedCall);\r\n                }\r\n\r\n                return calls.length > 0 ? '\\n' + calls.join('\\n') : '';\r\n            },\r\n\r\n            t: function (spyInstance) {\r\n                var objects = [];\r\n\r\n                for (var i = 0, l = spyInstance.callCount; i < l; ++i) {\r\n                    push.call(objects, sinon.format(spyInstance.thisValues[i]));\r\n                }\r\n\r\n                return objects.join(', ');\r\n            },\r\n\r\n            '*': function (spyInstance, args) {\r\n                var formatted = [];\r\n\r\n                for (var i = 0, l = args.length; i < l; ++i) {\r\n                    push.call(formatted, sinon.format(args[i]));\r\n                }\r\n\r\n                return formatted.join(', ');\r\n            }\r\n        };\r\n\r\n        sinon.extend(spy, spyApi);\r\n\r\n        spy.spyCall = sinon.spyCall;\r\n        sinon.spy = spy;\r\n\r\n        return spy;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var core = /* require */('./util/core');\r\n        /* require */('./call');\r\n        /* require */('./extend');\r\n        /* require */('./times_in_words');\r\n        /* require */('./format');\r\n        module.exports = makeApi(core);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n * depend extend.js\r\n */\r\n/**\r\n * Stub behavior\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @author Tim Fischbach (mail@timfischbach.de)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    var slice = Array.prototype.slice;\r\n    var join = Array.prototype.join;\r\n    var useLeftMostCallback = -1;\r\n    var useRightMostCallback = -2;\r\n\r\n    var nextTick = (function () {\r\n        if (typeof process === 'object' && typeof process.nextTick === 'function') {\r\n            return process.nextTick;\r\n        }\r\n\r\n        if (typeof setImmediate === 'function') {\r\n            return setImmediate;\r\n        }\r\n\r\n        return function (callback) {\r\n            setTimeout(callback, 0);\r\n        };\r\n    })();\r\n\r\n    function throwsException(error, message) {\r\n        if (typeof error === 'string') {\r\n            this.exception = new Error(message || '');\r\n            this.exception.name = error;\r\n        } else if (!error) {\r\n            this.exception = new Error('Error');\r\n        } else {\r\n            this.exception = error;\r\n        }\r\n\r\n        return this;\r\n    }\r\n\r\n    function getCallback(behavior, args) {\r\n        var callArgAt = behavior.callArgAt;\r\n\r\n        if (callArgAt >= 0) {\r\n            return args[callArgAt];\r\n        }\r\n\r\n        var argumentList;\r\n\r\n        if (callArgAt === useLeftMostCallback) {\r\n            argumentList = args;\r\n        }\r\n\r\n        if (callArgAt === useRightMostCallback) {\r\n            argumentList = slice.call(args).reverse();\r\n        }\r\n\r\n        var callArgProp = behavior.callArgProp;\r\n\r\n        for (var i = 0, l = argumentList.length; i < l; ++i) {\r\n            if (!callArgProp && typeof argumentList[i] === 'function') {\r\n                return argumentList[i];\r\n            }\r\n\r\n            if (callArgProp && argumentList[i] &&\r\n                typeof argumentList[i][callArgProp] === 'function') {\r\n                return argumentList[i][callArgProp];\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    function makeApi(sinon) {\r\n        function getCallbackError(behavior, func, args) {\r\n            if (behavior.callArgAt < 0) {\r\n                var msg;\r\n\r\n                if (behavior.callArgProp) {\r\n                    msg = sinon.functionName(behavior.stub) +\r\n                        ' expected to yield to \\'' + behavior.callArgProp +\r\n                        '\\', but no object with such a property was passed.';\r\n                } else {\r\n                    msg = sinon.functionName(behavior.stub) +\r\n                        ' expected to yield, but no callback was passed.';\r\n                }\r\n\r\n                if (args.length > 0) {\r\n                    msg += ' Received [' + join.call(args, ', ') + ']';\r\n                }\r\n\r\n                return msg;\r\n            }\r\n\r\n            return 'argument at index ' + behavior.callArgAt + ' is not a function: ' + func;\r\n        }\r\n\r\n        function callCallback(behavior, args) {\r\n            if (typeof behavior.callArgAt === 'number') {\r\n                var func = getCallback(behavior, args);\r\n\r\n                if (typeof func !== 'function') {\r\n                    throw new TypeError(getCallbackError(behavior, func, args));\r\n                }\r\n\r\n                if (behavior.callbackAsync) {\r\n                    nextTick(function () {\r\n                        func.apply(behavior.callbackContext, behavior.callbackArguments);\r\n                    });\r\n                } else {\r\n                    func.apply(behavior.callbackContext, behavior.callbackArguments);\r\n                }\r\n            }\r\n        }\r\n\r\n        var proto = {\r\n            create: function create(stub) {\r\n                var behavior = sinon.extend({}, sinon.behavior);\r\n                delete behavior.create;\r\n                behavior.stub = stub;\r\n\r\n                return behavior;\r\n            },\r\n\r\n            isPresent: function isPresent() {\r\n                return (typeof this.callArgAt === 'number' ||\r\n                        this.exception ||\r\n                        typeof this.returnArgAt === 'number' ||\r\n                        this.returnThis ||\r\n                        this.returnValueDefined);\r\n            },\r\n\r\n            invoke: function invoke(context, args) {\r\n                callCallback(this, args);\r\n\r\n                if (this.exception) {\r\n                    throw this.exception;\r\n                } else if (typeof this.returnArgAt === 'number') {\r\n                    return args[this.returnArgAt];\r\n                } else if (this.returnThis) {\r\n                    return context;\r\n                }\r\n\r\n                return this.returnValue;\r\n            },\r\n\r\n            onCall: function onCall(index) {\r\n                return this.stub.onCall(index);\r\n            },\r\n\r\n            onFirstCall: function onFirstCall() {\r\n                return this.stub.onFirstCall();\r\n            },\r\n\r\n            onSecondCall: function onSecondCall() {\r\n                return this.stub.onSecondCall();\r\n            },\r\n\r\n            onThirdCall: function onThirdCall() {\r\n                return this.stub.onThirdCall();\r\n            },\r\n\r\n            withArgs: function withArgs(/* arguments */) {\r\n                throw new Error(\r\n                    'Defining a stub by invoking \"stub.onCall(...).withArgs(...)\" ' +\r\n                    'is not supported. Use \"stub.withArgs(...).onCall(...)\" ' +\r\n                    'to define sequential behavior for calls with certain arguments.'\r\n                );\r\n            },\r\n\r\n            callsArg: function callsArg(pos) {\r\n                if (typeof pos !== 'number') {\r\n                    throw new TypeError('argument index is not number');\r\n                }\r\n\r\n                this.callArgAt = pos;\r\n                this.callbackArguments = [];\r\n                this.callbackContext = undefined;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            callsArgOn: function callsArgOn(pos, context) {\r\n                if (typeof pos !== 'number') {\r\n                    throw new TypeError('argument index is not number');\r\n                }\r\n                if (typeof context !== 'object') {\r\n                    throw new TypeError('argument context is not an object');\r\n                }\r\n\r\n                this.callArgAt = pos;\r\n                this.callbackArguments = [];\r\n                this.callbackContext = context;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            callsArgWith: function callsArgWith(pos) {\r\n                if (typeof pos !== 'number') {\r\n                    throw new TypeError('argument index is not number');\r\n                }\r\n\r\n                this.callArgAt = pos;\r\n                this.callbackArguments = slice.call(arguments, 1);\r\n                this.callbackContext = undefined;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            callsArgOnWith: function callsArgWith(pos, context) {\r\n                if (typeof pos !== 'number') {\r\n                    throw new TypeError('argument index is not number');\r\n                }\r\n                if (typeof context !== 'object') {\r\n                    throw new TypeError('argument context is not an object');\r\n                }\r\n\r\n                this.callArgAt = pos;\r\n                this.callbackArguments = slice.call(arguments, 2);\r\n                this.callbackContext = context;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            yields: function () {\r\n                this.callArgAt = useLeftMostCallback;\r\n                this.callbackArguments = slice.call(arguments, 0);\r\n                this.callbackContext = undefined;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            yieldsRight: function () {\r\n                this.callArgAt = useRightMostCallback;\r\n                this.callbackArguments = slice.call(arguments, 0);\r\n                this.callbackContext = undefined;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            yieldsOn: function (context) {\r\n                if (typeof context !== 'object') {\r\n                    throw new TypeError('argument context is not an object');\r\n                }\r\n\r\n                this.callArgAt = useLeftMostCallback;\r\n                this.callbackArguments = slice.call(arguments, 1);\r\n                this.callbackContext = context;\r\n                this.callArgProp = undefined;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            yieldsTo: function (prop) {\r\n                this.callArgAt = useLeftMostCallback;\r\n                this.callbackArguments = slice.call(arguments, 1);\r\n                this.callbackContext = undefined;\r\n                this.callArgProp = prop;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            yieldsToOn: function (prop, context) {\r\n                if (typeof context !== 'object') {\r\n                    throw new TypeError('argument context is not an object');\r\n                }\r\n\r\n                this.callArgAt = useLeftMostCallback;\r\n                this.callbackArguments = slice.call(arguments, 2);\r\n                this.callbackContext = context;\r\n                this.callArgProp = prop;\r\n                this.callbackAsync = false;\r\n\r\n                return this;\r\n            },\r\n\r\n            throws: throwsException,\r\n            throwsException: throwsException,\r\n\r\n            returns: function returns(value) {\r\n                this.returnValue = value;\r\n                this.returnValueDefined = true;\r\n                this.exception = undefined;\r\n\r\n                return this;\r\n            },\r\n\r\n            returnsArg: function returnsArg(pos) {\r\n                if (typeof pos !== 'number') {\r\n                    throw new TypeError('argument index is not number');\r\n                }\r\n\r\n                this.returnArgAt = pos;\r\n\r\n                return this;\r\n            },\r\n\r\n            returnsThis: function returnsThis() {\r\n                this.returnThis = true;\r\n\r\n                return this;\r\n            }\r\n        };\r\n\r\n        function createAsyncVersion(syncFnName) {\r\n            return function () {\r\n                var result = this[syncFnName].apply(this, arguments);\r\n                this.callbackAsync = true;\r\n                return result;\r\n            };\r\n        }\r\n\r\n        // create asynchronous versions of callsArg* and yields* methods\r\n        for (var method in proto) {\r\n            // need to avoid creating anotherasync versions of the newly added async methods\r\n            if (proto.hasOwnProperty(method) && method.match(/^(callsArg|yields)/) && !method.match(/Async/)) {\r\n                proto[method + 'Async'] = createAsyncVersion(method);\r\n            }\r\n        }\r\n\r\n        sinon.behavior = proto;\r\n        return proto;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./extend');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        function walkInternal(obj, iterator, context, originalObj, seen) {\r\n            var proto, prop;\r\n\r\n            if (typeof Object.getOwnPropertyNames !== 'function') {\r\n                // We explicitly want to enumerate through all of the prototype's properties\r\n                // in this case, therefore we deliberately leave out an own property check.\r\n                /* eslint-disable guard-for-in */\r\n                for (prop in obj) {\r\n                    iterator.call(context, obj[prop], prop, obj);\r\n                }\r\n                /* eslint-enable guard-for-in */\r\n\r\n                return;\r\n            }\r\n\r\n            Object.getOwnPropertyNames(obj).forEach(function (k) {\r\n                if (!seen[k]) {\r\n                    seen[k] = true;\r\n                    var target = typeof Object.getOwnPropertyDescriptor(obj, k).get === 'function' ?\r\n                        originalObj : obj;\r\n                    iterator.call(context, target[k], k, target);\r\n                }\r\n            });\r\n\r\n            proto = Object.getPrototypeOf(obj);\r\n            if (proto) {\r\n                walkInternal(proto, iterator, context, originalObj, seen);\r\n            }\r\n        }\r\n\r\n        /* Public: walks the prototype chain of an object and iterates over every own property\r\n         * name encountered. The iterator is called in the same fashion that Array.prototype.forEach\r\n         * works, where it is passed the value, key, and own object as the 1st, 2nd, and 3rd positional\r\n         * argument, respectively. In cases where Object.getOwnPropertyNames is not available, walk will\r\n         * default to using a simple for..in loop.\r\n         *\r\n         * obj - The object to walk the prototype chain for.\r\n         * iterator - The function to be called on each pass of the walk.\r\n         * context - (Optional) When given, the iterator will be called with this object as the receiver.\r\n         */\r\n        function walk(obj, iterator, context) {\r\n            return walkInternal(obj, iterator, context, obj, {});\r\n        }\r\n\r\n        sinon.walk = walk;\r\n        return sinon.walk;\r\n    }\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n * depend extend.js\r\n * depend spy.js\r\n * depend behavior.js\r\n * depend walk.js\r\n */\r\n/**\r\n * Stub functions\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        function stub(object, property, func) {\r\n            if (!!func && typeof func !== 'function' && typeof func !== 'object') {\r\n                throw new TypeError('Custom stub should be a function or a property descriptor');\r\n            }\r\n\r\n            var wrapper;\r\n\r\n            if (func) {\r\n                if (typeof func === 'function') {\r\n                    wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;\r\n                } else {\r\n                    wrapper = func;\r\n                    if (sinon.spy && sinon.spy.create) {\r\n                        var types = sinon.objectKeys(wrapper);\r\n                        for (var i = 0; i < types.length; i++) {\r\n                            wrapper[types[i]] = sinon.spy.create(wrapper[types[i]]);\r\n                        }\r\n                    }\r\n                }\r\n            } else {\r\n                var stubLength = 0;\r\n                if (typeof object === 'object' && typeof object[property] === 'function') {\r\n                    stubLength = object[property].length;\r\n                }\r\n                wrapper = stub.create(stubLength);\r\n            }\r\n\r\n            if (!object && typeof property === 'undefined') {\r\n                return sinon.stub.create();\r\n            }\r\n\r\n            if (typeof property === 'undefined' && typeof object === 'object') {\r\n                sinon.walk(object || {}, function (value, prop, propOwner) {\r\n                    // we don't want to stub things like toString(), valueOf(), etc. so we only stub if the object\r\n                    // is not Object.prototype\r\n                    if (\r\n                        propOwner !== Object.prototype &&\r\n                        prop !== 'constructor' &&\r\n                        typeof sinon.getPropertyDescriptor(propOwner, prop).value === 'function'\r\n                    ) {\r\n                        stub(object, prop);\r\n                    }\r\n                });\r\n\r\n                return object;\r\n            }\r\n\r\n            return sinon.wrapMethod(object, property, wrapper);\r\n        }\r\n\r\n\r\n        /*eslint-disable no-use-before-define*/\r\n        function getParentBehaviour(stubInstance) {\r\n            return (stubInstance.parent && getCurrentBehavior(stubInstance.parent));\r\n        }\r\n\r\n        function getDefaultBehavior(stubInstance) {\r\n            return stubInstance.defaultBehavior ||\r\n                    getParentBehaviour(stubInstance) ||\r\n                    sinon.behavior.create(stubInstance);\r\n        }\r\n\r\n        function getCurrentBehavior(stubInstance) {\r\n            var behavior = stubInstance.behaviors[stubInstance.callCount - 1];\r\n            return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stubInstance);\r\n        }\r\n        /*eslint-enable no-use-before-define*/\r\n\r\n        var uuid = 0;\r\n\r\n        var proto = {\r\n            create: function create(stubLength) {\r\n                var functionStub = function () {\r\n                    return getCurrentBehavior(functionStub).invoke(this, arguments);\r\n                };\r\n\r\n                functionStub.id = 'stub#' + uuid++;\r\n                var orig = functionStub;\r\n                functionStub = sinon.spy.create(functionStub, stubLength);\r\n                functionStub.func = orig;\r\n\r\n                sinon.extend(functionStub, stub);\r\n                functionStub.instantiateFake = sinon.stub.create;\r\n                functionStub.displayName = 'stub';\r\n                functionStub.toString = sinon.functionToString;\r\n\r\n                functionStub.defaultBehavior = null;\r\n                functionStub.behaviors = [];\r\n\r\n                return functionStub;\r\n            },\r\n\r\n            resetBehavior: function () {\r\n                var i;\r\n\r\n                this.defaultBehavior = null;\r\n                this.behaviors = [];\r\n\r\n                delete this.returnValue;\r\n                delete this.returnArgAt;\r\n                this.returnThis = false;\r\n\r\n                if (this.fakes) {\r\n                    for (i = 0; i < this.fakes.length; i++) {\r\n                        this.fakes[i].resetBehavior();\r\n                    }\r\n                }\r\n            },\r\n\r\n            onCall: function onCall(index) {\r\n                if (!this.behaviors[index]) {\r\n                    this.behaviors[index] = sinon.behavior.create(this);\r\n                }\r\n\r\n                return this.behaviors[index];\r\n            },\r\n\r\n            onFirstCall: function onFirstCall() {\r\n                return this.onCall(0);\r\n            },\r\n\r\n            onSecondCall: function onSecondCall() {\r\n                return this.onCall(1);\r\n            },\r\n\r\n            onThirdCall: function onThirdCall() {\r\n                return this.onCall(2);\r\n            }\r\n        };\r\n\r\n        function createBehavior(behaviorMethod) {\r\n            return function () {\r\n                this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this);\r\n                this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments);\r\n                return this;\r\n            };\r\n        }\r\n\r\n        for (var method in sinon.behavior) {\r\n            if (sinon.behavior.hasOwnProperty(method) &&\r\n                !proto.hasOwnProperty(method) &&\r\n                method !== 'create' &&\r\n                method !== 'withArgs' &&\r\n                method !== 'invoke') {\r\n                proto[method] = createBehavior(method);\r\n            }\r\n        }\r\n\r\n        sinon.extend(stub, proto);\r\n        sinon.stub = stub;\r\n\r\n        return stub;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var core = /* require */('./util/core');\r\n        /* require */('./behavior');\r\n        /* require */('./spy');\r\n        /* require */('./extend');\r\n        module.exports = makeApi(core);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend times_in_words.js\r\n * depend util/core.js\r\n * depend call.js\r\n * depend extend.js\r\n * depend match.js\r\n * depend spy.js\r\n * depend stub.js\r\n * depend format.js\r\n */\r\n/**\r\n * Mock functions.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        var push = [].push;\r\n        var match = sinon.match;\r\n\r\n        function mock(object) {\r\n            // if (typeof console !== undefined && console.warn) {\r\n            //     console.warn(\"mock will be removed from Sinon.JS v2.0\");\r\n            // }\r\n\r\n            if (!object) {\r\n                return sinon.expectation.create('Anonymous mock');\r\n            }\r\n\r\n            return mock.create(object);\r\n        }\r\n\r\n        function each(collection, callback) {\r\n            if (!collection) {\r\n                return;\r\n            }\r\n\r\n            for (var i = 0, l = collection.length; i < l; i += 1) {\r\n                callback(collection[i]);\r\n            }\r\n        }\r\n\r\n        function arrayEquals(arr1, arr2, compareLength) {\r\n            if (compareLength && (arr1.length !== arr2.length)) {\r\n                return false;\r\n            }\r\n\r\n            for (var i = 0, l = arr1.length; i < l; i++) {\r\n                if (!sinon.deepEqual(arr1[i], arr2[i])) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n\r\n        sinon.extend(mock, {\r\n            create: function create(object) {\r\n                if (!object) {\r\n                    throw new TypeError('object is null');\r\n                }\r\n\r\n                var mockObject = sinon.extend({}, mock);\r\n                mockObject.object = object;\r\n                delete mockObject.create;\r\n\r\n                return mockObject;\r\n            },\r\n\r\n            expects: function expects(method) {\r\n                if (!method) {\r\n                    throw new TypeError('method is falsy');\r\n                }\r\n\r\n                if (!this.expectations) {\r\n                    this.expectations = {};\r\n                    this.proxies = [];\r\n                }\r\n\r\n                if (!this.expectations[method]) {\r\n                    this.expectations[method] = [];\r\n                    var mockObject = this;\r\n\r\n                    sinon.wrapMethod(this.object, method, function () {\r\n                        return mockObject.invokeMethod(method, this, arguments);\r\n                    });\r\n\r\n                    push.call(this.proxies, method);\r\n                }\r\n\r\n                var expectation = sinon.expectation.create(method);\r\n                push.call(this.expectations[method], expectation);\r\n\r\n                return expectation;\r\n            },\r\n\r\n            restore: function restore() {\r\n                var object = this.object;\r\n\r\n                each(this.proxies, function (proxy) {\r\n                    if (typeof object[proxy].restore === 'function') {\r\n                        object[proxy].restore();\r\n                    }\r\n                });\r\n            },\r\n\r\n            verify: function verify() {\r\n                var expectations = this.expectations || {};\r\n                var messages = [];\r\n                var met = [];\r\n\r\n                each(this.proxies, function (proxy) {\r\n                    each(expectations[proxy], function (expectation) {\r\n                        if (!expectation.met()) {\r\n                            push.call(messages, expectation.toString());\r\n                        } else {\r\n                            push.call(met, expectation.toString());\r\n                        }\r\n                    });\r\n                });\r\n\r\n                this.restore();\r\n\r\n                if (messages.length > 0) {\r\n                    sinon.expectation.fail(messages.concat(met).join('\\n'));\r\n                } else if (met.length > 0) {\r\n                    sinon.expectation.pass(messages.concat(met).join('\\n'));\r\n                }\r\n\r\n                return true;\r\n            },\r\n\r\n            invokeMethod: function invokeMethod(method, thisValue, args) {\r\n                var expectations = this.expectations && this.expectations[method] ? this.expectations[method] : [];\r\n                var expectationsWithMatchingArgs = [];\r\n                var currentArgs = args || [];\r\n                var i, available;\r\n\r\n                for (i = 0; i < expectations.length; i += 1) {\r\n                    var expectedArgs = expectations[i].expectedArguments || [];\r\n                    if (arrayEquals(expectedArgs, currentArgs, expectations[i].expectsExactArgCount)) {\r\n                        expectationsWithMatchingArgs.push(expectations[i]);\r\n                    }\r\n                }\r\n\r\n                for (i = 0; i < expectationsWithMatchingArgs.length; i += 1) {\r\n                    if (!expectationsWithMatchingArgs[i].met() &&\r\n                        expectationsWithMatchingArgs[i].allowsCall(thisValue, args)) {\r\n                        return expectationsWithMatchingArgs[i].apply(thisValue, args);\r\n                    }\r\n                }\r\n\r\n                var messages = [];\r\n                var exhausted = 0;\r\n\r\n                for (i = 0; i < expectationsWithMatchingArgs.length; i += 1) {\r\n                    if (expectationsWithMatchingArgs[i].allowsCall(thisValue, args)) {\r\n                        available = available || expectationsWithMatchingArgs[i];\r\n                    } else {\r\n                        exhausted += 1;\r\n                    }\r\n                }\r\n\r\n                if (available && exhausted === 0) {\r\n                    return available.apply(thisValue, args);\r\n                }\r\n\r\n                for (i = 0; i < expectations.length; i += 1) {\r\n                    push.call(messages, '    ' + expectations[i].toString());\r\n                }\r\n\r\n                messages.unshift('Unexpected call: ' + sinon.spyCall.toString.call({\r\n                    proxy: method,\r\n                    args: args\r\n                }));\r\n\r\n                sinon.expectation.fail(messages.join('\\n'));\r\n            }\r\n        });\r\n\r\n        var times = sinon.timesInWords;\r\n        var slice = Array.prototype.slice;\r\n\r\n        function callCountInWords(callCount) {\r\n            if (callCount === 0) {\r\n                return 'never called';\r\n            }\r\n\r\n            return 'called ' + times(callCount);\r\n        }\r\n\r\n        function expectedCallCountInWords(expectation) {\r\n            var min = expectation.minCalls;\r\n            var max = expectation.maxCalls;\r\n\r\n            if (typeof min === 'number' && typeof max === 'number') {\r\n                var str = times(min);\r\n\r\n                if (min !== max) {\r\n                    str = 'at least ' + str + ' and at most ' + times(max);\r\n                }\r\n\r\n                return str;\r\n            }\r\n\r\n            if (typeof min === 'number') {\r\n                return 'at least ' + times(min);\r\n            }\r\n\r\n            return 'at most ' + times(max);\r\n        }\r\n\r\n        function receivedMinCalls(expectation) {\r\n            var hasMinLimit = typeof expectation.minCalls === 'number';\r\n            return !hasMinLimit || expectation.callCount >= expectation.minCalls;\r\n        }\r\n\r\n        function receivedMaxCalls(expectation) {\r\n            if (typeof expectation.maxCalls !== 'number') {\r\n                return false;\r\n            }\r\n\r\n            return expectation.callCount === expectation.maxCalls;\r\n        }\r\n\r\n        function verifyMatcher(possibleMatcher, arg) {\r\n            var isMatcher = match && match.isMatcher(possibleMatcher);\r\n\r\n            return isMatcher && possibleMatcher.test(arg) || true;\r\n        }\r\n\r\n        sinon.expectation = {\r\n            minCalls: 1,\r\n            maxCalls: 1,\r\n\r\n            create: function create(methodName) {\r\n                var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);\r\n                delete expectation.create;\r\n                expectation.method = methodName;\r\n\r\n                return expectation;\r\n            },\r\n\r\n            invoke: function invoke(func, thisValue, args) {\r\n                this.verifyCallAllowed(thisValue, args);\r\n\r\n                return sinon.spy.invoke.apply(this, arguments);\r\n            },\r\n\r\n            atLeast: function atLeast(num) {\r\n                if (typeof num !== 'number') {\r\n                    throw new TypeError('\\'' + num + '\\' is not number');\r\n                }\r\n\r\n                if (!this.limitsSet) {\r\n                    this.maxCalls = null;\r\n                    this.limitsSet = true;\r\n                }\r\n\r\n                this.minCalls = num;\r\n\r\n                return this;\r\n            },\r\n\r\n            atMost: function atMost(num) {\r\n                if (typeof num !== 'number') {\r\n                    throw new TypeError('\\'' + num + '\\' is not number');\r\n                }\r\n\r\n                if (!this.limitsSet) {\r\n                    this.minCalls = null;\r\n                    this.limitsSet = true;\r\n                }\r\n\r\n                this.maxCalls = num;\r\n\r\n                return this;\r\n            },\r\n\r\n            never: function never() {\r\n                return this.exactly(0);\r\n            },\r\n\r\n            once: function once() {\r\n                return this.exactly(1);\r\n            },\r\n\r\n            twice: function twice() {\r\n                return this.exactly(2);\r\n            },\r\n\r\n            thrice: function thrice() {\r\n                return this.exactly(3);\r\n            },\r\n\r\n            exactly: function exactly(num) {\r\n                if (typeof num !== 'number') {\r\n                    throw new TypeError('\\'' + num + '\\' is not a number');\r\n                }\r\n\r\n                this.atLeast(num);\r\n                return this.atMost(num);\r\n            },\r\n\r\n            met: function met() {\r\n                return !this.failed && receivedMinCalls(this);\r\n            },\r\n\r\n            verifyCallAllowed: function verifyCallAllowed(thisValue, args) {\r\n                if (receivedMaxCalls(this)) {\r\n                    this.failed = true;\r\n                    sinon.expectation.fail(this.method + ' already called ' + times(this.maxCalls));\r\n                }\r\n\r\n                if ('expectedThis' in this && this.expectedThis !== thisValue) {\r\n                    sinon.expectation.fail(this.method + ' called with ' + thisValue + ' as thisValue, expected ' +\r\n                        this.expectedThis);\r\n                }\r\n\r\n                if (!('expectedArguments' in this)) {\r\n                    return;\r\n                }\r\n\r\n                if (!args) {\r\n                    sinon.expectation.fail(this.method + ' received no arguments, expected ' +\r\n                        sinon.format(this.expectedArguments));\r\n                }\r\n\r\n                if (args.length < this.expectedArguments.length) {\r\n                    sinon.expectation.fail(this.method + ' received too few arguments (' + sinon.format(args) +\r\n                        '), expected ' + sinon.format(this.expectedArguments));\r\n                }\r\n\r\n                if (this.expectsExactArgCount &&\r\n                    args.length !== this.expectedArguments.length) {\r\n                    sinon.expectation.fail(this.method + ' received too many arguments (' + sinon.format(args) +\r\n                        '), expected ' + sinon.format(this.expectedArguments));\r\n                }\r\n\r\n                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {\r\n\r\n                    if (!verifyMatcher(this.expectedArguments[i], args[i])) {\r\n                        sinon.expectation.fail(this.method + ' received wrong arguments ' + sinon.format(args) +\r\n                            ', didn\\'t match ' + this.expectedArguments.toString());\r\n                    }\r\n\r\n                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {\r\n                        sinon.expectation.fail(this.method + ' received wrong arguments ' + sinon.format(args) +\r\n                            ', expected ' + sinon.format(this.expectedArguments));\r\n                    }\r\n                }\r\n            },\r\n\r\n            allowsCall: function allowsCall(thisValue, args) {\r\n                if (this.met() && receivedMaxCalls(this)) {\r\n                    return false;\r\n                }\r\n\r\n                if ('expectedThis' in this && this.expectedThis !== thisValue) {\r\n                    return false;\r\n                }\r\n\r\n                if (!('expectedArguments' in this)) {\r\n                    return true;\r\n                }\r\n\r\n                args = args || [];\r\n\r\n                if (args.length < this.expectedArguments.length) {\r\n                    return false;\r\n                }\r\n\r\n                if (this.expectsExactArgCount &&\r\n                    args.length !== this.expectedArguments.length) {\r\n                    return false;\r\n                }\r\n\r\n                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {\r\n                    if (!verifyMatcher(this.expectedArguments[i], args[i])) {\r\n                        return false;\r\n                    }\r\n\r\n                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {\r\n                        return false;\r\n                    }\r\n                }\r\n\r\n                return true;\r\n            },\r\n\r\n            withArgs: function withArgs() {\r\n                this.expectedArguments = slice.call(arguments);\r\n                return this;\r\n            },\r\n\r\n            withExactArgs: function withExactArgs() {\r\n                this.withArgs.apply(this, arguments);\r\n                this.expectsExactArgCount = true;\r\n                return this;\r\n            },\r\n\r\n            on: function on(thisValue) {\r\n                this.expectedThis = thisValue;\r\n                return this;\r\n            },\r\n\r\n            toString: function () {\r\n                var args = (this.expectedArguments || []).slice();\r\n\r\n                if (!this.expectsExactArgCount) {\r\n                    push.call(args, '[...]');\r\n                }\r\n\r\n                var callStr = sinon.spyCall.toString.call({\r\n                    proxy: this.method || 'anonymous mock expectation',\r\n                    args: args\r\n                });\r\n\r\n                var message = callStr.replace(', [...', '[, ...') + ' ' +\r\n                    expectedCallCountInWords(this);\r\n\r\n                if (this.met()) {\r\n                    return 'Expectation met: ' + message;\r\n                }\r\n\r\n                return 'Expected ' + message + ' (' +\r\n                    callCountInWords(this.callCount) + ')';\r\n            },\r\n\r\n            verify: function verify() {\r\n                if (!this.met()) {\r\n                    sinon.expectation.fail(this.toString());\r\n                } else {\r\n                    sinon.expectation.pass(this.toString());\r\n                }\r\n\r\n                return true;\r\n            },\r\n\r\n            pass: function pass(message) {\r\n                sinon.assert.pass(message);\r\n            },\r\n\r\n            fail: function fail(message) {\r\n                var exception = new Error(message);\r\n                exception.name = 'ExpectationError';\r\n\r\n                throw exception;\r\n            }\r\n        };\r\n\r\n        sinon.mock = mock;\r\n        return mock;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./times_in_words');\r\n        /* require */('./call');\r\n        /* require */('./extend');\r\n        /* require */('./match');\r\n        /* require */('./spy');\r\n        /* require */('./stub');\r\n        /* require */('./format');\r\n\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n * depend spy.js\r\n * depend stub.js\r\n * depend mock.js\r\n */\r\n/**\r\n * Collections of stubs, spies and mocks.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    var push = [].push;\r\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\r\n\r\n    function getFakes(fakeCollection) {\r\n        if (!fakeCollection.fakes) {\r\n            fakeCollection.fakes = [];\r\n        }\r\n\r\n        return fakeCollection.fakes;\r\n    }\r\n\r\n    function each(fakeCollection, method) {\r\n        var fakes = getFakes(fakeCollection);\r\n\r\n        for (var i = 0, l = fakes.length; i < l; i += 1) {\r\n            if (typeof fakes[i][method] === 'function') {\r\n                fakes[i][method]();\r\n            }\r\n        }\r\n    }\r\n\r\n    function compact(fakeCollection) {\r\n        var fakes = getFakes(fakeCollection);\r\n        var i = 0;\r\n        while (i < fakes.length) {\r\n            fakes.splice(i, 1);\r\n        }\r\n    }\r\n\r\n    function makeApi(sinon) {\r\n        var collection = {\r\n            verify: function resolve() {\r\n                each(this, 'verify');\r\n            },\r\n\r\n            restore: function restore() {\r\n                each(this, 'restore');\r\n                compact(this);\r\n            },\r\n\r\n            reset: function restore() {\r\n                each(this, 'reset');\r\n            },\r\n\r\n            verifyAndRestore: function verifyAndRestore() {\r\n                var exception;\r\n\r\n                try {\r\n                    this.verify();\r\n                } catch (e) {\r\n                    exception = e;\r\n                }\r\n\r\n                this.restore();\r\n\r\n                if (exception) {\r\n                    throw exception;\r\n                }\r\n            },\r\n\r\n            add: function add(fake) {\r\n                push.call(getFakes(this), fake);\r\n                return fake;\r\n            },\r\n\r\n            spy: function spy() {\r\n                return this.add(sinon.spy.apply(sinon, arguments));\r\n            },\r\n\r\n            stub: function stub(object, property, value) {\r\n                if (property) {\r\n                    var original = object[property];\r\n\r\n                    if (typeof original !== 'function') {\r\n                        if (!hasOwnProperty.call(object, property)) {\r\n                            throw new TypeError('Cannot stub non-existent own property ' + property);\r\n                        }\r\n\r\n                        object[property] = value;\r\n\r\n                        return this.add({\r\n                            restore: function () {\r\n                                object[property] = original;\r\n                            }\r\n                        });\r\n                    }\r\n                }\r\n                if (!property && !!object && typeof object === 'object') {\r\n                    var stubbedObj = sinon.stub.apply(sinon, arguments);\r\n\r\n                    for (var prop in stubbedObj) {\r\n                        if (typeof stubbedObj[prop] === 'function') {\r\n                            this.add(stubbedObj[prop]);\r\n                        }\r\n                    }\r\n\r\n                    return stubbedObj;\r\n                }\r\n\r\n                return this.add(sinon.stub.apply(sinon, arguments));\r\n            },\r\n\r\n            mock: function mock() {\r\n                return this.add(sinon.mock.apply(sinon, arguments));\r\n            },\r\n\r\n            inject: function inject(obj) {\r\n                var col = this;\r\n\r\n                obj.spy = function () {\r\n                    return col.spy.apply(col, arguments);\r\n                };\r\n\r\n                obj.stub = function () {\r\n                    return col.stub.apply(col, arguments);\r\n                };\r\n\r\n                obj.mock = function () {\r\n                    return col.mock.apply(col, arguments);\r\n                };\r\n\r\n                return obj;\r\n            }\r\n        };\r\n\r\n        sinon.collection = collection;\r\n        return collection;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./mock');\r\n        /* require */('./spy');\r\n        /* require */('./stub');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * Fake timer API\r\n * setTimeout\r\n * setInterval\r\n * clearTimeout\r\n * clearInterval\r\n * tick\r\n * reset\r\n * Date\r\n *\r\n * Inspired by jsUnitMockTimeOut from JsUnit\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function () {\r\n\r\n    function makeApi(s, lol) {\r\n        /*global lolex */\r\n        var llx = (typeof lolex !== 'undefined' ? lolex : lol) || window.lolex;\r\n\r\n        s.useFakeTimers = function () {\r\n            var now;\r\n            var methods = Array.prototype.slice.call(arguments);\r\n\r\n            if (typeof methods[0] === 'string') {\r\n                now = 0;\r\n            } else {\r\n                now = methods.shift();\r\n            }\r\n\r\n            var clock = llx.install(now || 0, methods);\r\n            clock.restore = clock.uninstall;\r\n            return clock;\r\n        };\r\n\r\n        s.clock = {\r\n            create: function (now) {\r\n                return llx.createClock(now);\r\n            }\r\n        };\r\n\r\n        s.timers = {\r\n            setTimeout: setTimeout,\r\n            clearTimeout: clearTimeout,\r\n            setImmediate: (typeof setImmediate !== 'undefined' ? setImmediate : undefined),\r\n            clearImmediate: (typeof clearImmediate !== 'undefined' ? clearImmediate : undefined),\r\n            setInterval: setInterval,\r\n            clearInterval: clearInterval,\r\n            Date: Date\r\n        };\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, epxorts, module, lolex) {\r\n        var core = /* require */('./core');\r\n        makeApi(core, lolex);\r\n        module.exports = core;\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require, module.exports, module, /* require */('lolex'));\r\n    } else {\r\n        makeApi(sinon); // eslint-disable-line no-undef\r\n    }\r\n}());\r\n\r\n/**\r\n * Minimal Event interface implementation\r\n *\r\n * Original implementation by Sven Fuchs: https://gist.github.com/995028\r\n * Modifications and tests by Christian Johansen.\r\n *\r\n * @author Sven Fuchs (svenfuchs@artweb-design.de)\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2011 Sven Fuchs, Christian Johansen\r\n */\r\nif (typeof sinon === 'undefined') {\r\n    this.sinon = {};\r\n}\r\n\r\n(function () {\r\n\r\n    var push = [].push;\r\n\r\n    function makeApi(sinon) {\r\n        sinon.Event = function Event(type, bubbles, cancelable, target) {\r\n            this.initEvent(type, bubbles, cancelable, target);\r\n        };\r\n\r\n        sinon.Event.prototype = {\r\n            initEvent: function (type, bubbles, cancelable, target) {\r\n                this.type = type;\r\n                this.bubbles = bubbles;\r\n                this.cancelable = cancelable;\r\n                this.target = target;\r\n            },\r\n\r\n            stopPropagation: function () {},\r\n\r\n            preventDefault: function () {\r\n                this.defaultPrevented = true;\r\n            }\r\n        };\r\n\r\n        sinon.ProgressEvent = function ProgressEvent(type, progressEventRaw, target) {\r\n            this.initEvent(type, false, false, target);\r\n            this.loaded = progressEventRaw.loaded || null;\r\n            this.total = progressEventRaw.total || null;\r\n            this.lengthComputable = !!progressEventRaw.total;\r\n        };\r\n\r\n        sinon.ProgressEvent.prototype = new sinon.Event();\r\n\r\n        sinon.ProgressEvent.prototype.constructor = sinon.ProgressEvent;\r\n\r\n        sinon.CustomEvent = function CustomEvent(type, customData, target) {\r\n            this.initEvent(type, false, false, target);\r\n            this.detail = customData.detail || null;\r\n        };\r\n\r\n        sinon.CustomEvent.prototype = new sinon.Event();\r\n\r\n        sinon.CustomEvent.prototype.constructor = sinon.CustomEvent;\r\n\r\n        sinon.EventTarget = {\r\n            addEventListener: function addEventListener(event, listener) {\r\n                this.eventListeners = this.eventListeners || {};\r\n                this.eventListeners[event] = this.eventListeners[event] || [];\r\n                push.call(this.eventListeners[event], listener);\r\n            },\r\n\r\n            removeEventListener: function removeEventListener(event, listener) {\r\n                var listeners = this.eventListeners && this.eventListeners[event] || [];\r\n\r\n                for (var i = 0, l = listeners.length; i < l; ++i) {\r\n                    if (listeners[i] === listener) {\r\n                        return listeners.splice(i, 1);\r\n                    }\r\n                }\r\n            },\r\n\r\n            dispatchEvent: function dispatchEvent(event) {\r\n                var type = event.type;\r\n                var listeners = this.eventListeners && this.eventListeners[type] || [];\r\n\r\n                for (var i = 0; i < listeners.length; i++) {\r\n                    if (typeof listeners[i] === 'function') {\r\n                        listeners[i].call(this, event);\r\n                    } else {\r\n                        listeners[i].handleEvent(event);\r\n                    }\r\n                }\r\n\r\n                return !!event.defaultPrevented;\r\n            }\r\n        };\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require) {\r\n        var sinon = /* require */('./core');\r\n        makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require);\r\n    } else {\r\n        makeApi(sinon); // eslint-disable-line no-undef\r\n    }\r\n}());\r\n\r\n/**\r\n * depend util/core.js\r\n */\r\n/**\r\n * Logs errors\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2014 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    // cache a reference to setTimeout, so that our reference won't be stubbed out\r\n    // when using fake timers and errors will still get logged\r\n    // https://github.com/cjohansen/Sinon.JS/issues/381\r\n    var realSetTimeout = setTimeout;\r\n\r\n    function makeApi(sinon) {\r\n\r\n        function log() {}\r\n\r\n        function logError(label, err) {\r\n            var msg = label + ' threw exception: ';\r\n\r\n            function throwLoggedError() {\r\n                err.message = msg + err.message;\r\n                throw err;\r\n            }\r\n\r\n            sinon.log(msg + '[' + err.name + '] ' + err.message);\r\n\r\n            if (err.stack) {\r\n                sinon.log(err.stack);\r\n            }\r\n\r\n            if (logError.useImmediateExceptions) {\r\n                throwLoggedError();\r\n            } else {\r\n                logError.setTimeout(throwLoggedError, 0);\r\n            }\r\n        }\r\n\r\n        // When set to true, any errors logged will be thrown immediately;\r\n        // If set to false, the errors will be thrown in separate execution frame.\r\n        logError.useImmediateExceptions = false;\r\n\r\n        // wrap realSetTimeout with something we can stub in tests\r\n        logError.setTimeout = function (func, timeout) {\r\n            realSetTimeout(func, timeout);\r\n        };\r\n\r\n        var exports = {};\r\n        exports.log = sinon.log = log;\r\n        exports.logError = sinon.logError = logError;\r\n\r\n        return exports;\r\n    }\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend core.js\r\n * depend ../extend.js\r\n * depend event.js\r\n * depend ../log_error.js\r\n */\r\n/**\r\n * Fake XDomainRequest object\r\n */\r\nif (typeof sinon === 'undefined') {\r\n    this.sinon = {};\r\n}\r\n\r\n// wrapper for global\r\n(function (global) {\r\n\r\n    var xdr = { XDomainRequest: global.XDomainRequest };\r\n    xdr.GlobalXDomainRequest = global.XDomainRequest;\r\n    xdr.supportsXDR = typeof xdr.GlobalXDomainRequest !== 'undefined';\r\n    xdr.workingXDR = xdr.supportsXDR ? xdr.GlobalXDomainRequest : false;\r\n\r\n    function makeApi(sinon) {\r\n        sinon.xdr = xdr;\r\n\r\n        function FakeXDomainRequest() {\r\n            this.readyState = FakeXDomainRequest.UNSENT;\r\n            this.requestBody = null;\r\n            this.requestHeaders = {};\r\n            this.status = 0;\r\n            this.timeout = null;\r\n\r\n            if (typeof FakeXDomainRequest.onCreate === 'function') {\r\n                FakeXDomainRequest.onCreate(this);\r\n            }\r\n        }\r\n\r\n        function verifyState(x) {\r\n            if (x.readyState !== FakeXDomainRequest.OPENED) {\r\n                throw new Error('INVALID_STATE_ERR');\r\n            }\r\n\r\n            if (x.sendFlag) {\r\n                throw new Error('INVALID_STATE_ERR');\r\n            }\r\n        }\r\n\r\n        function verifyRequestSent(x) {\r\n            if (x.readyState === FakeXDomainRequest.UNSENT) {\r\n                throw new Error('Request not sent');\r\n            }\r\n            if (x.readyState === FakeXDomainRequest.DONE) {\r\n                throw new Error('Request done');\r\n            }\r\n        }\r\n\r\n        function verifyResponseBodyType(body) {\r\n            if (typeof body !== 'string') {\r\n                var error = new Error('Attempted to respond to fake XDomainRequest with ' +\r\n                                    body + ', which is not a string.');\r\n                error.name = 'InvalidBodyException';\r\n                throw error;\r\n            }\r\n        }\r\n\r\n        sinon.extend(FakeXDomainRequest.prototype, sinon.EventTarget, {\r\n            open: function open(method, url) {\r\n                this.method = method;\r\n                this.url = url;\r\n\r\n                this.responseText = null;\r\n                this.sendFlag = false;\r\n\r\n                this.readyStateChange(FakeXDomainRequest.OPENED);\r\n            },\r\n\r\n            readyStateChange: function readyStateChange(state) {\r\n                this.readyState = state;\r\n                var eventName = '';\r\n                switch (this.readyState) {\r\n                case FakeXDomainRequest.UNSENT:\r\n                    break;\r\n                case FakeXDomainRequest.OPENED:\r\n                    break;\r\n                case FakeXDomainRequest.LOADING:\r\n                    if (this.sendFlag) {\r\n                        //raise the progress event\r\n                        eventName = 'onprogress';\r\n                    }\r\n                    break;\r\n                case FakeXDomainRequest.DONE:\r\n                    if (this.isTimeout) {\r\n                        eventName = 'ontimeout';\r\n                    } else if (this.errorFlag || (this.status < 200 || this.status > 299)) {\r\n                        eventName = 'onerror';\r\n                    } else {\r\n                        eventName = 'onload';\r\n                    }\r\n                    break;\r\n                }\r\n\r\n                // raising event (if defined)\r\n                if (eventName) {\r\n                    if (typeof this[eventName] === 'function') {\r\n                        try {\r\n                            this[eventName]();\r\n                        } catch (e) {\r\n                            sinon.logError('Fake XHR ' + eventName + ' handler', e);\r\n                        }\r\n                    }\r\n                }\r\n            },\r\n\r\n            send: function send(data) {\r\n                verifyState(this);\r\n\r\n                if (!/^(get|head)$/i.test(this.method)) {\r\n                    this.requestBody = data;\r\n                }\r\n                this.requestHeaders['Content-Type'] = 'text/plain;charset=utf-8';\r\n\r\n                this.errorFlag = false;\r\n                this.sendFlag = true;\r\n                this.readyStateChange(FakeXDomainRequest.OPENED);\r\n\r\n                if (typeof this.onSend === 'function') {\r\n                    this.onSend(this);\r\n                }\r\n            },\r\n\r\n            abort: function abort() {\r\n                this.aborted = true;\r\n                this.responseText = null;\r\n                this.errorFlag = true;\r\n\r\n                if (this.readyState > sinon.FakeXDomainRequest.UNSENT && this.sendFlag) {\r\n                    this.readyStateChange(sinon.FakeXDomainRequest.DONE);\r\n                    this.sendFlag = false;\r\n                }\r\n            },\r\n\r\n            setResponseBody: function setResponseBody(body) {\r\n                verifyRequestSent(this);\r\n                verifyResponseBodyType(body);\r\n\r\n                var chunkSize = this.chunkSize || 10;\r\n                var index = 0;\r\n                this.responseText = '';\r\n\r\n                do {\r\n                    this.readyStateChange(FakeXDomainRequest.LOADING);\r\n                    this.responseText += body.substring(index, index + chunkSize);\r\n                    index += chunkSize;\r\n                } while (index < body.length);\r\n\r\n                this.readyStateChange(FakeXDomainRequest.DONE);\r\n            },\r\n\r\n            respond: function respond(status, contentType, body) {\r\n                // content-type ignored, since XDomainRequest does not carry this\r\n                // we keep the same syntax for respond(...) as for FakeXMLHttpRequest to ease\r\n                // test integration across browsers\r\n                this.status = typeof status === 'number' ? status : 200;\r\n                this.setResponseBody(body || '');\r\n            },\r\n\r\n            simulatetimeout: function simulatetimeout() {\r\n                this.status = 0;\r\n                this.isTimeout = true;\r\n                // Access to this should actually throw an error\r\n                this.responseText = undefined;\r\n                this.readyStateChange(FakeXDomainRequest.DONE);\r\n            }\r\n        });\r\n\r\n        sinon.extend(FakeXDomainRequest, {\r\n            UNSENT: 0,\r\n            OPENED: 1,\r\n            LOADING: 3,\r\n            DONE: 4\r\n        });\r\n\r\n        sinon.useFakeXDomainRequest = function useFakeXDomainRequest() {\r\n            sinon.FakeXDomainRequest.restore = function restore(keepOnCreate) {\r\n                if (xdr.supportsXDR) {\r\n                    global.XDomainRequest = xdr.GlobalXDomainRequest;\r\n                }\r\n\r\n                delete sinon.FakeXDomainRequest.restore;\r\n\r\n                if (keepOnCreate !== true) {\r\n                    delete sinon.FakeXDomainRequest.onCreate;\r\n                }\r\n            };\r\n            if (xdr.supportsXDR) {\r\n                global.XDomainRequest = sinon.FakeXDomainRequest;\r\n            }\r\n            return sinon.FakeXDomainRequest;\r\n        };\r\n\r\n        sinon.FakeXDomainRequest = FakeXDomainRequest;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./core');\r\n        /* require */('../extend');\r\n        /* require */('./event');\r\n        /* require */('../log_error');\r\n        makeApi(sinon);\r\n        module.exports = sinon;\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n    } else {\r\n        makeApi(sinon); // eslint-disable-line no-undef\r\n    }\r\n})(typeof global !== 'undefined' ? global : self);\r\n\r\n/**\r\n * depend core.js\r\n * depend ../extend.js\r\n * depend event.js\r\n * depend ../log_error.js\r\n */\r\n/**\r\n * Fake XMLHttpRequest object\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal, global) {\r\n\r\n    function getWorkingXHR(globalScope) {\r\n        var supportsXHR = typeof globalScope.XMLHttpRequest !== 'undefined';\r\n        if (supportsXHR) {\r\n            return globalScope.XMLHttpRequest;\r\n        }\r\n\r\n        var supportsActiveX = typeof globalScope.ActiveXObject !== 'undefined';\r\n        if (supportsActiveX) {\r\n            return function () {\r\n                return new globalScope.ActiveXObject('MSXML2.XMLHTTP.3.0');\r\n            };\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    var supportsProgress = typeof ProgressEvent !== 'undefined';\r\n    var supportsCustomEvent = typeof CustomEvent !== 'undefined';\r\n    var supportsFormData = typeof FormData !== 'undefined';\r\n    var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined';\r\n    var supportsBlob = typeof Blob === 'function';\r\n    var sinonXhr = { XMLHttpRequest: global.XMLHttpRequest };\r\n    sinonXhr.GlobalXMLHttpRequest = global.XMLHttpRequest;\r\n    sinonXhr.GlobalActiveXObject = global.ActiveXObject;\r\n    sinonXhr.supportsActiveX = typeof sinonXhr.GlobalActiveXObject !== 'undefined';\r\n    sinonXhr.supportsXHR = typeof sinonXhr.GlobalXMLHttpRequest !== 'undefined';\r\n    sinonXhr.workingXHR = getWorkingXHR(global);\r\n    sinonXhr.supportsCORS = sinonXhr.supportsXHR && 'withCredentials' in (new sinonXhr.GlobalXMLHttpRequest());\r\n\r\n    var unsafeHeaders = {\r\n        'Accept-Charset': true,\r\n        'Accept-Encoding': true,\r\n        Connection: true,\r\n        'Content-Length': true,\r\n        Cookie: true,\r\n        Cookie2: true,\r\n        'Content-Transfer-Encoding': true,\r\n        Date: true,\r\n        Expect: true,\r\n        Host: true,\r\n        'Keep-Alive': true,\r\n        Referer: true,\r\n        TE: true,\r\n        Trailer: true,\r\n        'Transfer-Encoding': true,\r\n        Upgrade: true,\r\n        'User-Agent': true,\r\n        Via: true\r\n    };\r\n\r\n    // An upload object is created for each\r\n    // FakeXMLHttpRequest and allows upload\r\n    // events to be simulated using uploadProgress\r\n    // and uploadError.\r\n    function UploadProgress() {\r\n        this.eventListeners = {\r\n            progress: [],\r\n            load: [],\r\n            abort: [],\r\n            error: []\r\n        };\r\n    }\r\n\r\n    UploadProgress.prototype.addEventListener = function addEventListener(event, listener) {\r\n        this.eventListeners[event].push(listener);\r\n    };\r\n\r\n    UploadProgress.prototype.removeEventListener = function removeEventListener(event, listener) {\r\n        var listeners = this.eventListeners[event] || [];\r\n\r\n        for (var i = 0, l = listeners.length; i < l; ++i) {\r\n            if (listeners[i] === listener) {\r\n                return listeners.splice(i, 1);\r\n            }\r\n        }\r\n    };\r\n\r\n    UploadProgress.prototype.dispatchEvent = function dispatchEvent(event) {\r\n        var listeners = this.eventListeners[event.type] || [];\r\n\r\n        for (var i = 0, listener; (listener = listeners[i]) != null; i++) {\r\n            listener(event);\r\n        }\r\n    };\r\n\r\n    // Note that for FakeXMLHttpRequest to work pre ES5\r\n    // we lose some of the alignment with the spec.\r\n    // To ensure as close a match as possible,\r\n    // set responseType before calling open, send or respond;\r\n    function FakeXMLHttpRequest() {\r\n        this.readyState = FakeXMLHttpRequest.UNSENT;\r\n        this.requestHeaders = {};\r\n        this.requestBody = null;\r\n        this.status = 0;\r\n        this.statusText = '';\r\n        this.upload = new UploadProgress();\r\n        this.responseType = '';\r\n        this.response = '';\r\n        if (sinonXhr.supportsCORS) {\r\n            this.withCredentials = false;\r\n        }\r\n\r\n        var xhr = this;\r\n        var events = ['loadstart', 'load', 'abort', 'loadend'];\r\n\r\n        function addEventListener(eventName) {\r\n            xhr.addEventListener(eventName, function (event) {\r\n                var listener = xhr['on' + eventName];\r\n\r\n                if (listener && typeof listener === 'function') {\r\n                    listener.call(this, event);\r\n                }\r\n            });\r\n        }\r\n\r\n        for (var i = events.length - 1; i >= 0; i--) {\r\n            addEventListener(events[i]);\r\n        }\r\n\r\n        if (typeof FakeXMLHttpRequest.onCreate === 'function') {\r\n            FakeXMLHttpRequest.onCreate(this);\r\n        }\r\n    }\r\n\r\n    function verifyState(xhr) {\r\n        if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {\r\n            throw new Error('INVALID_STATE_ERR');\r\n        }\r\n\r\n        if (xhr.sendFlag) {\r\n            throw new Error('INVALID_STATE_ERR');\r\n        }\r\n    }\r\n\r\n    function getHeader(headers, header) {\r\n        header = header.toLowerCase();\r\n\r\n        for (var h in headers) {\r\n            if (h.toLowerCase() === header) {\r\n                return h;\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    // filtering to enable a white-list version of Sinon FakeXhr,\r\n    // where whitelisted requests are passed through to real XHR\r\n    function each(collection, callback) {\r\n        if (!collection) {\r\n            return;\r\n        }\r\n\r\n        for (var i = 0, l = collection.length; i < l; i += 1) {\r\n            callback(collection[i]);\r\n        }\r\n    }\r\n    function some(collection, callback) {\r\n        for (var index = 0; index < collection.length; index++) {\r\n            if (callback(collection[index]) === true) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n    // largest arity in XHR is 5 - XHR#open\r\n    var apply = function (obj, method, args) {\r\n        switch (args.length) {\r\n        case 0: return obj[method]();\r\n        case 1: return obj[method](args[0]);\r\n        case 2: return obj[method](args[0], args[1]);\r\n        case 3: return obj[method](args[0], args[1], args[2]);\r\n        case 4: return obj[method](args[0], args[1], args[2], args[3]);\r\n        case 5: return obj[method](args[0], args[1], args[2], args[3], args[4]);\r\n        }\r\n    };\r\n\r\n    FakeXMLHttpRequest.filters = [];\r\n    FakeXMLHttpRequest.addFilter = function addFilter(fn) {\r\n        this.filters.push(fn);\r\n    };\r\n    var IE6Re = /MSIE 6/;\r\n    FakeXMLHttpRequest.defake = function defake(fakeXhr, xhrArgs) {\r\n        var xhr = new sinonXhr.workingXHR(); // eslint-disable-line new-cap\r\n\r\n        each([\r\n            'open',\r\n            'setRequestHeader',\r\n            'send',\r\n            'abort',\r\n            'getResponseHeader',\r\n            'getAllResponseHeaders',\r\n            'addEventListener',\r\n            'overrideMimeType',\r\n            'removeEventListener'\r\n        ], function (method) {\r\n            fakeXhr[method] = function () {\r\n                return apply(xhr, method, arguments);\r\n            };\r\n        });\r\n\r\n        var copyAttrs = function (args) {\r\n            each(args, function (attr) {\r\n                try {\r\n                    fakeXhr[attr] = xhr[attr];\r\n                } catch (e) {\r\n                    if (!IE6Re.test(navigator.userAgent)) {\r\n                        throw e;\r\n                    }\r\n                }\r\n            });\r\n        };\r\n\r\n        var stateChange = function stateChange() {\r\n            fakeXhr.readyState = xhr.readyState;\r\n            if (xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {\r\n                copyAttrs(['status', 'statusText']);\r\n            }\r\n            if (xhr.readyState >= FakeXMLHttpRequest.LOADING) {\r\n                copyAttrs(['responseText', 'response']);\r\n            }\r\n            if (xhr.readyState === FakeXMLHttpRequest.DONE) {\r\n                copyAttrs(['responseXML']);\r\n            }\r\n            if (fakeXhr.onreadystatechange) {\r\n                fakeXhr.onreadystatechange.call(fakeXhr, { target: fakeXhr });\r\n            }\r\n        };\r\n\r\n        if (xhr.addEventListener) {\r\n            for (var event in fakeXhr.eventListeners) {\r\n                if (fakeXhr.eventListeners.hasOwnProperty(event)) {\r\n\r\n                    /*eslint-disable no-loop-func*/\r\n                    each(fakeXhr.eventListeners[event], function (handler) {\r\n                        xhr.addEventListener(event, handler);\r\n                    });\r\n                    /*eslint-enable no-loop-func*/\r\n                }\r\n            }\r\n            xhr.addEventListener('readystatechange', stateChange);\r\n        } else {\r\n            xhr.onreadystatechange = stateChange;\r\n        }\r\n        apply(xhr, 'open', xhrArgs);\r\n    };\r\n    FakeXMLHttpRequest.useFilters = false;\r\n\r\n    function verifyRequestOpened(xhr) {\r\n        if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {\r\n            throw new Error('INVALID_STATE_ERR - ' + xhr.readyState);\r\n        }\r\n    }\r\n\r\n    function verifyRequestSent(xhr) {\r\n        if (xhr.readyState === FakeXMLHttpRequest.DONE) {\r\n            throw new Error('Request done');\r\n        }\r\n    }\r\n\r\n    function verifyHeadersReceived(xhr) {\r\n        if (xhr.async && xhr.readyState !== FakeXMLHttpRequest.HEADERS_RECEIVED) {\r\n            throw new Error('No headers received');\r\n        }\r\n    }\r\n\r\n    function verifyResponseBodyType(body) {\r\n        if (typeof body !== 'string') {\r\n            var error = new Error('Attempted to respond to fake XMLHttpRequest with ' +\r\n                                 body + ', which is not a string.');\r\n            error.name = 'InvalidBodyException';\r\n            throw error;\r\n        }\r\n    }\r\n\r\n    function convertToArrayBuffer(body) {\r\n        var buffer = new ArrayBuffer(body.length);\r\n        var view = new Uint8Array(buffer);\r\n        for (var i = 0; i < body.length; i++) {\r\n            var charCode = body.charCodeAt(i);\r\n            if (charCode >= 256) {\r\n                throw new TypeError('arraybuffer or blob responseTypes require binary string, ' +\r\n                                    'invalid character ' + body[i] + ' found.');\r\n            }\r\n            view[i] = charCode;\r\n        }\r\n        return buffer;\r\n    }\r\n\r\n    function isXmlContentType(contentType) {\r\n        return !contentType || /(text\\/xml)|(application\\/xml)|(\\+xml)/.test(contentType);\r\n    }\r\n\r\n    function convertResponseBody(responseType, contentType, body) {\r\n        if (responseType === '' || responseType === 'text') {\r\n            return body;\r\n        } else if (supportsArrayBuffer && responseType === 'arraybuffer') {\r\n            return convertToArrayBuffer(body);\r\n        } else if (responseType === 'json') {\r\n            try {\r\n                return JSON.parse(body);\r\n            } catch (e) {\r\n                // Return parsing failure as null\r\n                return null;\r\n            }\r\n        } else if (supportsBlob && responseType === 'blob') {\r\n            var blobOptions = {};\r\n            if (contentType) {\r\n                blobOptions.type = contentType;\r\n            }\r\n            return new Blob([convertToArrayBuffer(body)], blobOptions);\r\n        } else if (responseType === 'document') {\r\n            if (isXmlContentType(contentType)) {\r\n                return FakeXMLHttpRequest.parseXML(body);\r\n            }\r\n            return null;\r\n        }\r\n        throw new Error('Invalid responseType ' + responseType);\r\n    }\r\n\r\n    function clearResponse(xhr) {\r\n        if (xhr.responseType === '' || xhr.responseType === 'text') {\r\n            xhr.response = xhr.responseText = '';\r\n        } else {\r\n            xhr.response = xhr.responseText = null;\r\n        }\r\n        xhr.responseXML = null;\r\n    }\r\n\r\n    FakeXMLHttpRequest.parseXML = function parseXML(text) {\r\n        // Treat empty string as parsing failure\r\n        if (text !== '') {\r\n            try {\r\n                if (typeof DOMParser !== 'undefined') {\r\n                    var parser = new DOMParser();\r\n                    return parser.parseFromString(text, 'text/xml');\r\n                }\r\n                var xmlDoc = new window.ActiveXObject('Microsoft.XMLDOM');\r\n                xmlDoc.async = 'false';\r\n                xmlDoc.loadXML(text);\r\n                return xmlDoc;\r\n            } catch (e) {\r\n                // Unable to parse XML - no biggie\r\n            }\r\n        }\r\n\r\n        return null;\r\n    };\r\n\r\n    FakeXMLHttpRequest.statusCodes = {\r\n        100: 'Continue',\r\n        101: 'Switching Protocols',\r\n        200: 'OK',\r\n        201: 'Created',\r\n        202: 'Accepted',\r\n        203: 'Non-Authoritative Information',\r\n        204: 'No Content',\r\n        205: 'Reset Content',\r\n        206: 'Partial Content',\r\n        207: 'Multi-Status',\r\n        300: 'Multiple Choice',\r\n        301: 'Moved Permanently',\r\n        302: 'Found',\r\n        303: 'See Other',\r\n        304: 'Not Modified',\r\n        305: 'Use Proxy',\r\n        307: 'Temporary Redirect',\r\n        400: 'Bad Request',\r\n        401: 'Unauthorized',\r\n        402: 'Payment Required',\r\n        403: 'Forbidden',\r\n        404: 'Not Found',\r\n        405: 'Method Not Allowed',\r\n        406: 'Not Acceptable',\r\n        407: 'Proxy Authentication Required',\r\n        408: 'Request Timeout',\r\n        409: 'Conflict',\r\n        410: 'Gone',\r\n        411: 'Length Required',\r\n        412: 'Precondition Failed',\r\n        413: 'Request Entity Too Large',\r\n        414: 'Request-URI Too Long',\r\n        415: 'Unsupported Media Type',\r\n        416: 'Requested Range Not Satisfiable',\r\n        417: 'Expectation Failed',\r\n        422: 'Unprocessable Entity',\r\n        500: 'Internal Server Error',\r\n        501: 'Not Implemented',\r\n        502: 'Bad Gateway',\r\n        503: 'Service Unavailable',\r\n        504: 'Gateway Timeout',\r\n        505: 'HTTP Version Not Supported'\r\n    };\r\n\r\n    function makeApi(sinon) {\r\n        sinon.xhr = sinonXhr;\r\n\r\n        sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {\r\n            async: true,\r\n\r\n            open: function open(method, url, async, username, password) {\r\n                this.method = method;\r\n                this.url = url;\r\n                this.async = typeof async === 'boolean' ? async : true;\r\n                this.username = username;\r\n                this.password = password;\r\n                clearResponse(this);\r\n                this.requestHeaders = {};\r\n                this.sendFlag = false;\r\n\r\n                if (FakeXMLHttpRequest.useFilters === true) {\r\n                    var xhrArgs = arguments;\r\n                    var defake = some(FakeXMLHttpRequest.filters, function (filter) {\r\n                        return filter.apply(this, xhrArgs);\r\n                    });\r\n                    if (defake) {\r\n                        return FakeXMLHttpRequest.defake(this, arguments);\r\n                    }\r\n                }\r\n                this.readyStateChange(FakeXMLHttpRequest.OPENED);\r\n            },\r\n\r\n            readyStateChange: function readyStateChange(state) {\r\n                this.readyState = state;\r\n\r\n                var readyStateChangeEvent = new sinon.Event('readystatechange', false, false, this);\r\n\r\n                if (typeof this.onreadystatechange === 'function') {\r\n                    try {\r\n                        this.onreadystatechange(readyStateChangeEvent);\r\n                    } catch (e) {\r\n                        sinon.logError('Fake XHR onreadystatechange handler', e);\r\n                    }\r\n                }\r\n\r\n                switch (this.readyState) {\r\n                    case FakeXMLHttpRequest.DONE:\r\n                        if (supportsProgress) {\r\n                            this.upload.dispatchEvent(new sinon.ProgressEvent('progress', {loaded: 100, total: 100}));\r\n                            this.dispatchEvent(new sinon.ProgressEvent('progress', {loaded: 100, total: 100}));\r\n                        }\r\n                        this.upload.dispatchEvent(new sinon.Event('load', false, false, this));\r\n                        this.dispatchEvent(new sinon.Event('load', false, false, this));\r\n                        this.dispatchEvent(new sinon.Event('loadend', false, false, this));\r\n                        break;\r\n                }\r\n\r\n                this.dispatchEvent(readyStateChangeEvent);\r\n            },\r\n\r\n            setRequestHeader: function setRequestHeader(header, value) {\r\n                verifyState(this);\r\n\r\n                if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {\r\n                    throw new Error('Refused to set unsafe header \"' + header + '\"');\r\n                }\r\n\r\n                if (this.requestHeaders[header]) {\r\n                    this.requestHeaders[header] += ',' + value;\r\n                } else {\r\n                    this.requestHeaders[header] = value;\r\n                }\r\n            },\r\n\r\n            // Helps testing\r\n            setResponseHeaders: function setResponseHeaders(headers) {\r\n                verifyRequestOpened(this);\r\n                this.responseHeaders = {};\r\n\r\n                for (var header in headers) {\r\n                    if (headers.hasOwnProperty(header)) {\r\n                        this.responseHeaders[header] = headers[header];\r\n                    }\r\n                }\r\n\r\n                if (this.async) {\r\n                    this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);\r\n                } else {\r\n                    this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;\r\n                }\r\n            },\r\n\r\n            // Currently treats ALL data as a DOMString (i.e. no Document)\r\n            send: function send(data) {\r\n                verifyState(this);\r\n\r\n                if (!/^(get|head)$/i.test(this.method)) {\r\n                    var contentType = getHeader(this.requestHeaders, 'Content-Type');\r\n                    if (this.requestHeaders[contentType]) {\r\n                        var value = this.requestHeaders[contentType].split(';');\r\n                        this.requestHeaders[contentType] = value[0] + ';charset=utf-8';\r\n                    } else if (supportsFormData && !(data instanceof FormData)) {\r\n                        this.requestHeaders['Content-Type'] = 'text/plain;charset=utf-8';\r\n                    }\r\n\r\n                    this.requestBody = data;\r\n                }\r\n\r\n                this.errorFlag = false;\r\n                this.sendFlag = this.async;\r\n                clearResponse(this);\r\n                this.readyStateChange(FakeXMLHttpRequest.OPENED);\r\n\r\n                if (typeof this.onSend === 'function') {\r\n                    this.onSend(this);\r\n                }\r\n\r\n                this.dispatchEvent(new sinon.Event('loadstart', false, false, this));\r\n            },\r\n\r\n            abort: function abort() {\r\n                this.aborted = true;\r\n                clearResponse(this);\r\n                this.errorFlag = true;\r\n                this.requestHeaders = {};\r\n                this.responseHeaders = {};\r\n\r\n                if (this.readyState > FakeXMLHttpRequest.UNSENT && this.sendFlag) {\r\n                    this.readyStateChange(FakeXMLHttpRequest.DONE);\r\n                    this.sendFlag = false;\r\n                }\r\n\r\n                this.readyState = FakeXMLHttpRequest.UNSENT;\r\n\r\n                this.dispatchEvent(new sinon.Event('abort', false, false, this));\r\n\r\n                this.upload.dispatchEvent(new sinon.Event('abort', false, false, this));\r\n\r\n                if (typeof this.onerror === 'function') {\r\n                    this.onerror();\r\n                }\r\n            },\r\n\r\n            getResponseHeader: function getResponseHeader(header) {\r\n                if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {\r\n                    return null;\r\n                }\r\n\r\n                if (/^Set-Cookie2?$/i.test(header)) {\r\n                    return null;\r\n                }\r\n\r\n                header = getHeader(this.responseHeaders, header);\r\n\r\n                return this.responseHeaders[header] || null;\r\n            },\r\n\r\n            getAllResponseHeaders: function getAllResponseHeaders() {\r\n                if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {\r\n                    return '';\r\n                }\r\n\r\n                var headers = '';\r\n\r\n                for (var header in this.responseHeaders) {\r\n                    if (this.responseHeaders.hasOwnProperty(header) &&\r\n                        !/^Set-Cookie2?$/i.test(header)) {\r\n                        headers += header + ': ' + this.responseHeaders[header] + '\\r\\n';\r\n                    }\r\n                }\r\n\r\n                return headers;\r\n            },\r\n\r\n            setResponseBody: function setResponseBody(body) {\r\n                verifyRequestSent(this);\r\n                verifyHeadersReceived(this);\r\n                verifyResponseBodyType(body);\r\n                var contentType = this.getResponseHeader('Content-Type');\r\n\r\n                var isTextResponse = this.responseType === '' || this.responseType === 'text';\r\n                clearResponse(this);\r\n                if (this.async) {\r\n                    var chunkSize = this.chunkSize || 10;\r\n                    var index = 0;\r\n\r\n                    do {\r\n                        this.readyStateChange(FakeXMLHttpRequest.LOADING);\r\n\r\n                        if (isTextResponse) {\r\n                            this.responseText = this.response += body.substring(index, index + chunkSize);\r\n                        }\r\n                        index += chunkSize;\r\n                    } while (index < body.length);\r\n                }\r\n\r\n                this.response = convertResponseBody(this.responseType, contentType, body);\r\n                if (isTextResponse) {\r\n                    this.responseText = this.response;\r\n                }\r\n\r\n                if (this.responseType === 'document') {\r\n                    this.responseXML = this.response;\r\n                } else if (this.responseType === '' && isXmlContentType(contentType)) {\r\n                    this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);\r\n                }\r\n                this.readyStateChange(FakeXMLHttpRequest.DONE);\r\n            },\r\n\r\n            respond: function respond(status, headers, body) {\r\n                this.status = typeof status === 'number' ? status : 200;\r\n                this.statusText = FakeXMLHttpRequest.statusCodes[this.status];\r\n                this.setResponseHeaders(headers || {});\r\n                this.setResponseBody(body || '');\r\n            },\r\n\r\n            uploadProgress: function uploadProgress(progressEventRaw) {\r\n                if (supportsProgress) {\r\n                    this.upload.dispatchEvent(new sinon.ProgressEvent('progress', progressEventRaw));\r\n                }\r\n            },\r\n\r\n            downloadProgress: function downloadProgress(progressEventRaw) {\r\n                if (supportsProgress) {\r\n                    this.dispatchEvent(new sinon.ProgressEvent('progress', progressEventRaw));\r\n                }\r\n            },\r\n\r\n            uploadError: function uploadError(error) {\r\n                if (supportsCustomEvent) {\r\n                    this.upload.dispatchEvent(new sinon.CustomEvent('error', {detail: error}));\r\n                }\r\n            }\r\n        });\r\n\r\n        sinon.extend(FakeXMLHttpRequest, {\r\n            UNSENT: 0,\r\n            OPENED: 1,\r\n            HEADERS_RECEIVED: 2,\r\n            LOADING: 3,\r\n            DONE: 4\r\n        });\r\n\r\n        sinon.useFakeXMLHttpRequest = function () {\r\n            FakeXMLHttpRequest.restore = function restore(keepOnCreate) {\r\n                if (sinonXhr.supportsXHR) {\r\n                    global.XMLHttpRequest = sinonXhr.GlobalXMLHttpRequest;\r\n                }\r\n\r\n                if (sinonXhr.supportsActiveX) {\r\n                    global.ActiveXObject = sinonXhr.GlobalActiveXObject;\r\n                }\r\n\r\n                delete FakeXMLHttpRequest.restore;\r\n\r\n                if (keepOnCreate !== true) {\r\n                    delete FakeXMLHttpRequest.onCreate;\r\n                }\r\n            };\r\n            if (sinonXhr.supportsXHR) {\r\n                global.XMLHttpRequest = FakeXMLHttpRequest;\r\n            }\r\n\r\n            if (sinonXhr.supportsActiveX) {\r\n                global.ActiveXObject = function ActiveXObject(objId) {\r\n                    if (objId === 'Microsoft.XMLHTTP' || /^Msxml2\\.XMLHTTP/i.test(objId)) {\r\n\r\n                        return new FakeXMLHttpRequest();\r\n                    }\r\n\r\n                    return new sinonXhr.GlobalActiveXObject(objId);\r\n                };\r\n            }\r\n\r\n            return FakeXMLHttpRequest;\r\n        };\r\n\r\n        sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./core');\r\n        /* require */('../extend');\r\n        /* require */('./event');\r\n        /* require */('../log_error');\r\n        makeApi(sinon);\r\n        module.exports = sinon;\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon, // eslint-disable-line no-undef\r\n    typeof global !== 'undefined' ? global : self\r\n));\r\n\r\n/**\r\n * depend fake_xdomain_request.js\r\n * depend fake_xml_http_request.js\r\n * depend ../format.js\r\n * depend ../log_error.js\r\n */\r\n/**\r\n * The Sinon \"server\" mimics a web server that receives requests from\r\n * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,\r\n * both synchronously and asynchronously. To respond synchronuously, canned\r\n * answers have to be provided upfront.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function () {\r\n\r\n    var push = [].push;\r\n\r\n    function responseArray(handler) {\r\n        var response = handler;\r\n\r\n        if (Object.prototype.toString.call(handler) !== '[object Array]') {\r\n            response = [200, {}, handler];\r\n        }\r\n\r\n        if (typeof response[2] !== 'string') {\r\n            throw new TypeError('Fake server response body should be string, but was ' +\r\n                                typeof response[2]);\r\n        }\r\n\r\n        return response;\r\n    }\r\n\r\n    var wloc = typeof window !== 'undefined' ? window.location : {};\r\n    var rCurrLoc = new RegExp('^' + wloc.protocol + '//' + wloc.host);\r\n\r\n    function matchOne(response, reqMethod, reqUrl) {\r\n        var rmeth = response.method;\r\n        var matchMethod = !rmeth || rmeth.toLowerCase() === reqMethod.toLowerCase();\r\n        var url = response.url;\r\n        var matchUrl = !url || url === reqUrl || (typeof url.test === 'function' && url.test(reqUrl));\r\n\r\n        return matchMethod && matchUrl;\r\n    }\r\n\r\n    function match(response, request) {\r\n        var requestUrl = request.url;\r\n\r\n        if (!/^https?:\\/\\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {\r\n            requestUrl = requestUrl.replace(rCurrLoc, '');\r\n        }\r\n\r\n        if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {\r\n            if (typeof response.response === 'function') {\r\n                var ru = response.url;\r\n                var args = [request].concat(ru && typeof ru.exec === 'function' ? ru.exec(requestUrl).slice(1) : []);\r\n                return response.response.apply(response, args);\r\n            }\r\n\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    function makeApi(sinon) {\r\n        sinon.fakeServer = {\r\n            create: function (config) {\r\n                var server = sinon.create(this);\r\n                server.configure(config);\r\n                if (!sinon.xhr.supportsCORS) {\r\n                    this.xhr = sinon.useFakeXDomainRequest();\r\n                } else {\r\n                    this.xhr = sinon.useFakeXMLHttpRequest();\r\n                }\r\n                server.requests = [];\r\n\r\n                this.xhr.onCreate = function (xhrObj) {\r\n                    server.addRequest(xhrObj);\r\n                };\r\n\r\n                return server;\r\n            },\r\n            configure: function (config) {\r\n                var whitelist = {\r\n                    'autoRespond': true,\r\n                    'autoRespondAfter': true,\r\n                    'respondImmediately': true,\r\n                    'fakeHTTPMethods': true\r\n                };\r\n                var setting;\r\n\r\n                config = config || {};\r\n                for (setting in config) {\r\n                    if (whitelist.hasOwnProperty(setting) && config.hasOwnProperty(setting)) {\r\n                        this[setting] = config[setting];\r\n                    }\r\n                }\r\n            },\r\n            addRequest: function addRequest(xhrObj) {\r\n                var server = this;\r\n                push.call(this.requests, xhrObj);\r\n\r\n                xhrObj.onSend = function () {\r\n                    server.handleRequest(this);\r\n\r\n                    if (server.respondImmediately) {\r\n                        server.respond();\r\n                    } else if (server.autoRespond && !server.responding) {\r\n                        setTimeout(function () {\r\n                            server.responding = false;\r\n                            server.respond();\r\n                        }, server.autoRespondAfter || 10);\r\n\r\n                        server.responding = true;\r\n                    }\r\n                };\r\n            },\r\n\r\n            getHTTPMethod: function getHTTPMethod(request) {\r\n                if (this.fakeHTTPMethods && /post/i.test(request.method)) {\r\n                    var matches = (request.requestBody || '').match(/_method=([^\\b;]+)/);\r\n                    return matches ? matches[1] : request.method;\r\n                }\r\n\r\n                return request.method;\r\n            },\r\n\r\n            handleRequest: function handleRequest(xhr) {\r\n                if (xhr.async) {\r\n                    if (!this.queue) {\r\n                        this.queue = [];\r\n                    }\r\n\r\n                    push.call(this.queue, xhr);\r\n                } else {\r\n                    this.processRequest(xhr);\r\n                }\r\n            },\r\n\r\n            log: function log(response, request) {\r\n                var str;\r\n\r\n                str = 'Request:\\n' + sinon.format(request) + '\\n\\n';\r\n                str += 'Response:\\n' + sinon.format(response) + '\\n\\n';\r\n\r\n                sinon.log(str);\r\n            },\r\n\r\n            respondWith: function respondWith(method, url, body) {\r\n                if (arguments.length === 1 && typeof method !== 'function') {\r\n                    this.response = responseArray(method);\r\n                    return;\r\n                }\r\n\r\n                if (!this.responses) {\r\n                    this.responses = [];\r\n                }\r\n\r\n                if (arguments.length === 1) {\r\n                    body = method;\r\n                    url = method = null;\r\n                }\r\n\r\n                if (arguments.length === 2) {\r\n                    body = url;\r\n                    url = method;\r\n                    method = null;\r\n                }\r\n\r\n                push.call(this.responses, {\r\n                    method: method,\r\n                    url: url,\r\n                    response: typeof body === 'function' ? body : responseArray(body)\r\n                });\r\n            },\r\n\r\n            respond: function respond() {\r\n                if (arguments.length > 0) {\r\n                    this.respondWith.apply(this, arguments);\r\n                }\r\n\r\n                var queue = this.queue || [];\r\n                var requests = queue.splice(0, queue.length);\r\n\r\n                for (var i = 0; i < requests.length; i++) {\r\n                    this.processRequest(requests[i]);\r\n                }\r\n            },\r\n\r\n            processRequest: function processRequest(request) {\r\n                try {\r\n                    if (request.aborted) {\r\n                        return;\r\n                    }\r\n\r\n                    var response = this.response || [404, {}, ''];\r\n\r\n                    if (this.responses) {\r\n                        for (var l = this.responses.length, i = l - 1; i >= 0; i--) {\r\n                            if (match.call(this, this.responses[i], request)) {\r\n                                response = this.responses[i].response;\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    if (request.readyState !== 4) {\r\n                        this.log(response, request);\r\n\r\n                        request.respond(response[0], response[1], response[2]);\r\n                    }\r\n                } catch (e) {\r\n                    sinon.logError('Fake server request processing', e);\r\n                }\r\n            },\r\n\r\n            restore: function restore() {\r\n                return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);\r\n            }\r\n        };\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./core');\r\n        /* require */('./fake_xdomain_request');\r\n        /* require */('./fake_xml_http_request');\r\n        /* require */('../format');\r\n        makeApi(sinon);\r\n        module.exports = sinon;\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n    } else {\r\n        makeApi(sinon); // eslint-disable-line no-undef\r\n    }\r\n}());\r\n\r\n/**\r\n * depend fake_server.js\r\n * depend fake_timers.js\r\n */\r\n/**\r\n * Add-on for sinon.fakeServer that automatically handles a fake timer along with\r\n * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery\r\n * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,\r\n * it polls the object for completion with setInterval. Dispite the direct\r\n * motivation, there is nothing jQuery-specific in this file, so it can be used\r\n * in any environment where the ajax implementation depends on setInterval or\r\n * setTimeout.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function () {\r\n\r\n    function makeApi(sinon) {\r\n        function Server() {}\r\n        Server.prototype = sinon.fakeServer;\r\n\r\n        sinon.fakeServerWithClock = new Server();\r\n\r\n        sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {\r\n            if (xhr.async) {\r\n                if (typeof setTimeout.clock === 'object') {\r\n                    this.clock = setTimeout.clock;\r\n                } else {\r\n                    this.clock = sinon.useFakeTimers();\r\n                    this.resetClock = true;\r\n                }\r\n\r\n                if (!this.longestTimeout) {\r\n                    var clockSetTimeout = this.clock.setTimeout;\r\n                    var clockSetInterval = this.clock.setInterval;\r\n                    var server = this;\r\n\r\n                    this.clock.setTimeout = function (fn, timeout) {\r\n                        server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);\r\n\r\n                        return clockSetTimeout.apply(this, arguments);\r\n                    };\r\n\r\n                    this.clock.setInterval = function (fn, timeout) {\r\n                        server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);\r\n\r\n                        return clockSetInterval.apply(this, arguments);\r\n                    };\r\n                }\r\n            }\r\n\r\n            return sinon.fakeServer.addRequest.call(this, xhr);\r\n        };\r\n\r\n        sinon.fakeServerWithClock.respond = function respond() {\r\n            var returnVal = sinon.fakeServer.respond.apply(this, arguments);\r\n\r\n            if (this.clock) {\r\n                this.clock.tick(this.longestTimeout || 0);\r\n                this.longestTimeout = 0;\r\n\r\n                if (this.resetClock) {\r\n                    this.clock.restore();\r\n                    this.resetClock = false;\r\n                }\r\n            }\r\n\r\n            return returnVal;\r\n        };\r\n\r\n        sinon.fakeServerWithClock.restore = function restore() {\r\n            if (this.clock) {\r\n                this.clock.restore();\r\n            }\r\n\r\n            return sinon.fakeServer.restore.apply(this, arguments);\r\n        };\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require) {\r\n        var sinon = /* require */('./core');\r\n        /* require */('./fake_server');\r\n        /* require */('./fake_timers');\r\n        makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require);\r\n    } else {\r\n        makeApi(sinon); // eslint-disable-line no-undef\r\n    }\r\n}());\r\n\r\n/**\r\n * depend util/core.js\r\n * depend extend.js\r\n * depend collection.js\r\n * depend util/fake_timers.js\r\n * depend util/fake_server_with_clock.js\r\n */\r\n/**\r\n * Manages fake collections as well as fake utilities such as Sinon's\r\n * timers and fake XHR implementation in one convenient object.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        var push = [].push;\r\n\r\n        function exposeValue(sandbox, config, key, value) {\r\n            if (!value) {\r\n                return;\r\n            }\r\n\r\n            if (config.injectInto && !(key in config.injectInto)) {\r\n                config.injectInto[key] = value;\r\n                sandbox.injectedKeys.push(key);\r\n            } else {\r\n                push.call(sandbox.args, value);\r\n            }\r\n        }\r\n\r\n        function prepareSandboxFromConfig(config) {\r\n            var sandbox = sinon.create(sinon.sandbox);\r\n\r\n            if (config.useFakeServer) {\r\n                if (typeof config.useFakeServer === 'object') {\r\n                    sandbox.serverPrototype = config.useFakeServer;\r\n                }\r\n\r\n                sandbox.useFakeServer();\r\n            }\r\n\r\n            if (config.useFakeTimers) {\r\n                if (typeof config.useFakeTimers === 'object') {\r\n                    sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);\r\n                } else {\r\n                    sandbox.useFakeTimers();\r\n                }\r\n            }\r\n\r\n            return sandbox;\r\n        }\r\n\r\n        sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {\r\n            useFakeTimers: function useFakeTimers() {\r\n                this.clock = sinon.useFakeTimers.apply(sinon, arguments);\r\n\r\n                return this.add(this.clock);\r\n            },\r\n\r\n            serverPrototype: sinon.fakeServer,\r\n\r\n            useFakeServer: function useFakeServer() {\r\n                var proto = this.serverPrototype || sinon.fakeServer;\r\n\r\n                if (!proto || !proto.create) {\r\n                    return null;\r\n                }\r\n\r\n                this.server = proto.create();\r\n                return this.add(this.server);\r\n            },\r\n\r\n            inject: function (obj) {\r\n                sinon.collection.inject.call(this, obj);\r\n\r\n                if (this.clock) {\r\n                    obj.clock = this.clock;\r\n                }\r\n\r\n                if (this.server) {\r\n                    obj.server = this.server;\r\n                    obj.requests = this.server.requests;\r\n                }\r\n\r\n                obj.match = sinon.match;\r\n\r\n                return obj;\r\n            },\r\n\r\n            restore: function () {\r\n                sinon.collection.restore.apply(this, arguments);\r\n                this.restoreContext();\r\n            },\r\n\r\n            restoreContext: function () {\r\n                if (this.injectedKeys) {\r\n                    for (var i = 0, j = this.injectedKeys.length; i < j; i++) {\r\n                        delete this.injectInto[this.injectedKeys[i]];\r\n                    }\r\n                    this.injectedKeys = [];\r\n                }\r\n            },\r\n\r\n            create: function (config) {\r\n                if (!config) {\r\n                    return sinon.create(sinon.sandbox);\r\n                }\r\n\r\n                var sandbox = prepareSandboxFromConfig(config);\r\n                sandbox.args = sandbox.args || [];\r\n                sandbox.injectedKeys = [];\r\n                sandbox.injectInto = config.injectInto;\r\n                var prop,\r\n                    value;\r\n                var exposed = sandbox.inject({});\r\n\r\n                if (config.properties) {\r\n                    for (var i = 0, l = config.properties.length; i < l; i++) {\r\n                        prop = config.properties[i];\r\n                        value = exposed[prop] || prop === 'sandbox' && sandbox;\r\n                        exposeValue(sandbox, config, prop, value);\r\n                    }\r\n                } else {\r\n                    exposeValue(sandbox, config, 'sandbox', value);\r\n                }\r\n\r\n                return sandbox;\r\n            },\r\n\r\n            match: sinon.match\r\n        });\r\n\r\n        sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;\r\n\r\n        return sinon.sandbox;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./extend');\r\n        /* require */('./util/fake_server_with_clock');\r\n        /* require */('./util/fake_timers');\r\n        /* require */('./collection');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend util/core.js\r\n * depend sandbox.js\r\n */\r\n/**\r\n * Test function, sandboxes fakes\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function makeApi(sinon) {\r\n        var slice = Array.prototype.slice;\r\n\r\n        function test(callback) {\r\n            var type = typeof callback;\r\n\r\n            if (type !== 'function') {\r\n                throw new TypeError('sinon.test needs to wrap a test function, got ' + type);\r\n            }\r\n\r\n            function sinonSandboxedTest() {\r\n                var config = sinon.getConfig(sinon.config);\r\n                config.injectInto = config.injectIntoThis && this || config.injectInto;\r\n                var sandbox = sinon.sandbox.create(config);\r\n                var args = slice.call(arguments);\r\n                var oldDone = args.length && args[args.length - 1];\r\n                var exception, result;\r\n\r\n                if (typeof oldDone === 'function') {\r\n                    args[args.length - 1] = function sinonDone(res) {\r\n                        if (res) {\r\n                            sandbox.restore();\r\n                        } else {\r\n                            sandbox.verifyAndRestore();\r\n                        }\r\n                        oldDone(res);\r\n                    };\r\n                }\r\n\r\n                try {\r\n                    result = callback.apply(this, args.concat(sandbox.args));\r\n                } catch (e) {\r\n                    exception = e;\r\n                }\r\n\r\n                if (typeof oldDone !== 'function') {\r\n                    if (typeof exception !== 'undefined') {\r\n                        sandbox.restore();\r\n                        throw exception;\r\n                    } else {\r\n                        sandbox.verifyAndRestore();\r\n                    }\r\n                }\r\n\r\n                return result;\r\n            }\r\n\r\n            if (callback.length) {\r\n                return function sinonAsyncSandboxedTest(done) { // eslint-disable-line no-unused-vars\r\n                    return sinonSandboxedTest.apply(this, arguments);\r\n                };\r\n            }\r\n\r\n            return sinonSandboxedTest;\r\n        }\r\n\r\n        test.config = {\r\n            injectIntoThis: true,\r\n            injectInto: null,\r\n            properties: ['spy', 'stub', 'mock', 'clock', 'server', 'requests'],\r\n            useFakeTimers: true,\r\n            useFakeServer: true\r\n        };\r\n\r\n        sinon.test = test;\r\n        return test;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var core = /* require */('./util/core');\r\n        /* require */('./sandbox');\r\n        module.exports = makeApi(core);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n    } else if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n    } else if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(typeof sinon === 'object' && sinon || null)); // eslint-disable-line no-undef\r\n\r\n/**\r\n * depend util/core.js\r\n * depend test.js\r\n */\r\n/**\r\n * Test case, sandboxes all test functions\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal) {\r\n\r\n    function createTest(property, setUp, tearDown) {\r\n        return function () {\r\n            if (setUp) {\r\n                setUp.apply(this, arguments);\r\n            }\r\n\r\n            var exception, result;\r\n\r\n            try {\r\n                result = property.apply(this, arguments);\r\n            } catch (e) {\r\n                exception = e;\r\n            }\r\n\r\n            if (tearDown) {\r\n                tearDown.apply(this, arguments);\r\n            }\r\n\r\n            if (exception) {\r\n                throw exception;\r\n            }\r\n\r\n            return result;\r\n        };\r\n    }\r\n\r\n    function makeApi(sinon) {\r\n        function testCase(tests, prefix) {\r\n            if (!tests || typeof tests !== 'object') {\r\n                throw new TypeError('sinon.testCase needs an object with test functions');\r\n            }\r\n\r\n            prefix = prefix || 'test';\r\n            var rPrefix = new RegExp('^' + prefix);\r\n            var methods = {};\r\n            var setUp = tests.setUp;\r\n            var tearDown = tests.tearDown;\r\n            var testName,\r\n                property,\r\n                method;\r\n\r\n            for (testName in tests) {\r\n                if (tests.hasOwnProperty(testName) && !/^(setUp|tearDown)$/.test(testName)) {\r\n                    property = tests[testName];\r\n\r\n                    if (typeof property === 'function' && rPrefix.test(testName)) {\r\n                        method = property;\r\n\r\n                        if (setUp || tearDown) {\r\n                            method = createTest(property, setUp, tearDown);\r\n                        }\r\n\r\n                        methods[testName] = sinon.test(method);\r\n                    } else {\r\n                        methods[testName] = tests[testName];\r\n                    }\r\n                }\r\n            }\r\n\r\n            return methods;\r\n        }\r\n\r\n        sinon.testCase = testCase;\r\n        return testCase;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var core = /* require */('./util/core');\r\n        /* require */('./test');\r\n        module.exports = makeApi(core);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon // eslint-disable-line no-undef\r\n));\r\n\r\n/**\r\n * depend times_in_words.js\r\n * depend util/core.js\r\n * depend match.js\r\n * depend format.js\r\n */\r\n/**\r\n * Assertions matching the test spy retrieval interface.\r\n *\r\n * @author Christian Johansen (christian@cjohansen.no)\r\n * @license BSD\r\n *\r\n * Copyright (c) 2010-2013 Christian Johansen\r\n */\r\n(function (sinonGlobal, global) {\r\n\r\n    var slice = Array.prototype.slice;\r\n\r\n    function makeApi(sinon) {\r\n        var assert;\r\n\r\n        function verifyIsStub() {\r\n            var method;\r\n\r\n            for (var i = 0, l = arguments.length; i < l; ++i) {\r\n                method = arguments[i];\r\n\r\n                if (!method) {\r\n                    assert.fail('fake is not a spy');\r\n                }\r\n\r\n                if (method.proxy && method.proxy.isSinonProxy) {\r\n                    verifyIsStub(method.proxy);\r\n                } else {\r\n                    if (typeof method !== 'function') {\r\n                        assert.fail(method + ' is not a function');\r\n                    }\r\n\r\n                    if (typeof method.getCall !== 'function') {\r\n                        assert.fail(method + ' is not stubbed');\r\n                    }\r\n                }\r\n\r\n            }\r\n        }\r\n\r\n        function failAssertion(object, msg) {\r\n            object = object || global;\r\n            var failMethod = object.fail || assert.fail;\r\n            failMethod.call(object, msg);\r\n        }\r\n\r\n        function mirrorPropAsAssertion(name, method, message) {\r\n            if (arguments.length === 2) {\r\n                message = method;\r\n                method = name;\r\n            }\r\n\r\n            assert[name] = function (fake) {\r\n                verifyIsStub(fake);\r\n\r\n                var args = slice.call(arguments, 1);\r\n                var failed = false;\r\n\r\n                if (typeof method === 'function') {\r\n                    failed = !method(fake);\r\n                } else {\r\n                    failed = typeof fake[method] === 'function' ?\r\n                        !fake[method].apply(fake, args) : !fake[method];\r\n                }\r\n\r\n                if (failed) {\r\n                    failAssertion(this, (fake.printf || fake.proxy.printf).apply(fake, [message].concat(args)));\r\n                } else {\r\n                    assert.pass(name);\r\n                }\r\n            };\r\n        }\r\n\r\n        function exposedName(prefix, prop) {\r\n            return !prefix || /^fail/.test(prop) ? prop :\r\n                prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);\r\n        }\r\n\r\n        assert = {\r\n            failException: 'AssertError',\r\n\r\n            fail: function fail(message) {\r\n                var error = new Error(message);\r\n                error.name = this.failException || assert.failException;\r\n\r\n                throw error;\r\n            },\r\n\r\n            pass: function pass() {},\r\n\r\n            callOrder: function assertCallOrder() {\r\n                verifyIsStub.apply(null, arguments);\r\n                var expected = '';\r\n                var actual = '';\r\n\r\n                if (!sinon.calledInOrder(arguments)) {\r\n                    try {\r\n                        expected = [].join.call(arguments, ', ');\r\n                        var calls = slice.call(arguments);\r\n                        var i = calls.length;\r\n                        while (i) {\r\n                            if (!calls[--i].called) {\r\n                                calls.splice(i, 1);\r\n                            }\r\n                        }\r\n                        actual = sinon.orderByFirstCall(calls).join(', ');\r\n                    } catch (e) {\r\n                        // If this fails, we'll just fall back to the blank string\r\n                    }\r\n\r\n                    failAssertion(this, 'expected ' + expected + ' to be ' +\r\n                                'called in order but were called as ' + actual);\r\n                } else {\r\n                    assert.pass('callOrder');\r\n                }\r\n            },\r\n\r\n            callCount: function assertCallCount(method, count) {\r\n                verifyIsStub(method);\r\n\r\n                if (method.callCount !== count) {\r\n                    var msg = 'expected %n to be called ' + sinon.timesInWords(count) +\r\n                        ' but was called %c%C';\r\n                    failAssertion(this, method.printf(msg));\r\n                } else {\r\n                    assert.pass('callCount');\r\n                }\r\n            },\r\n\r\n            expose: function expose(target, options) {\r\n                if (!target) {\r\n                    throw new TypeError('target is null or undefined');\r\n                }\r\n\r\n                var o = options || {};\r\n                var prefix = typeof o.prefix === 'undefined' && 'assert' || o.prefix;\r\n                var includeFail = typeof o.includeFail === 'undefined' || !!o.includeFail;\r\n\r\n                for (var method in this) {\r\n                    if (method !== 'expose' && (includeFail || !/^(fail)/.test(method))) {\r\n                        target[exposedName(prefix, method)] = this[method];\r\n                    }\r\n                }\r\n\r\n                return target;\r\n            },\r\n\r\n            match: function match(actual, expectation) {\r\n                var matcher = sinon.match(expectation);\r\n                if (matcher.test(actual)) {\r\n                    assert.pass('match');\r\n                } else {\r\n                    var formatted = [\r\n                        'expected value to match',\r\n                        '    expected = ' + sinon.format(expectation),\r\n                        '    actual = ' + sinon.format(actual)\r\n                    ];\r\n\r\n                    failAssertion(this, formatted.join('\\n'));\r\n                }\r\n            }\r\n        };\r\n\r\n        mirrorPropAsAssertion('called', 'expected %n to have been called at least once but was never called');\r\n        mirrorPropAsAssertion('notCalled', function (spy) {\r\n            return !spy.called;\r\n        }, 'expected %n to not have been called but was called %c%C');\r\n        mirrorPropAsAssertion('calledOnce', 'expected %n to be called once but was called %c%C');\r\n        mirrorPropAsAssertion('calledTwice', 'expected %n to be called twice but was called %c%C');\r\n        mirrorPropAsAssertion('calledThrice', 'expected %n to be called thrice but was called %c%C');\r\n        mirrorPropAsAssertion('calledOn', 'expected %n to be called with %1 as this but was called with %t');\r\n        mirrorPropAsAssertion(\r\n            'alwaysCalledOn',\r\n            'expected %n to always be called with %1 as this but was called with %t'\r\n        );\r\n        mirrorPropAsAssertion('calledWithNew', 'expected %n to be called with new');\r\n        mirrorPropAsAssertion('alwaysCalledWithNew', 'expected %n to always be called with new');\r\n        mirrorPropAsAssertion('calledWith', 'expected %n to be called with arguments %*%C');\r\n        mirrorPropAsAssertion('calledWithMatch', 'expected %n to be called with match %*%C');\r\n        mirrorPropAsAssertion('alwaysCalledWith', 'expected %n to always be called with arguments %*%C');\r\n        mirrorPropAsAssertion('alwaysCalledWithMatch', 'expected %n to always be called with match %*%C');\r\n        mirrorPropAsAssertion('calledWithExactly', 'expected %n to be called with exact arguments %*%C');\r\n        mirrorPropAsAssertion('alwaysCalledWithExactly', 'expected %n to always be called with exact arguments %*%C');\r\n        mirrorPropAsAssertion('neverCalledWith', 'expected %n to never be called with arguments %*%C');\r\n        mirrorPropAsAssertion('neverCalledWithMatch', 'expected %n to never be called with match %*%C');\r\n        mirrorPropAsAssertion('threw', '%n did not throw exception%C');\r\n        mirrorPropAsAssertion('alwaysThrew', '%n did not always throw exception%C');\r\n\r\n        sinon.assert = assert;\r\n        return assert;\r\n    }\r\n\r\n    var isNode = false && typeof module !== 'undefined' && module.exports && typeof require === 'function';\r\n    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd && false;\r\n\r\n    function loadDependencies(require, exports, module) {\r\n        var sinon = /* require */('./util/core');\r\n        /* require */('./match');\r\n        /* require */('./format');\r\n        module.exports = makeApi(sinon);\r\n    }\r\n\r\n    if (isAMD) {\r\n        define(loadDependencies);\r\n        return;\r\n    }\r\n\r\n    if (isNode) {\r\n        loadDependencies(require, module.exports, module);\r\n        return;\r\n    }\r\n\r\n    if (sinonGlobal) {\r\n        makeApi(sinonGlobal);\r\n    }\r\n}(\r\n    typeof sinon === 'object' && sinon, // eslint-disable-line no-undef\r\n    typeof global !== 'undefined' ? global : self\r\n));\r\n\r\n  return sinon;\r\n}));\r\n"],"names":["lolexModule","require","root","factory","module","exports","this","samsam","formatio","lolex","define","mod","deps","fn","length","e","amd","m","match","o","Object","prototype","div","document","createElement","isNaN","value","getClass","toString","call","split","isArguments","object","callee","isElement","nodeType","appendChild","removeChild","keys","prop","ks","hasOwnProperty","push","isDate","getTime","valueOf","isNegZero","Infinity","identical","obj1","obj2","arrayContains","array","subset","i","l","j","k","deepEqual","objects1","objects2","paths1","paths2","compared","isObject","Boolean","Date","Number","RegExp","String","getIndex","objects","obj","path1","path2","type1","type2","isDate1","isDate2","key","value1","value2","isObject1","isObject2","index1","index2","newPath1","newPath2","class1","class2","keys1","keys2","JSON","stringify","matcher","test","toLowerCase","indexOf","getAttribute","Error","excludeConstructors","quoteStrings","limitChildrenCount","specialObjects","functionName","func","displayName","name","matches","constructorName","f","constructor","excludes","isCircular","ascii","processed","indent","qs","element","Formatio","options","opt","global","window","pieces","Math","min","join","str","properties","sort","cons","prefix","is","attr","attrName","val","tagName","attrs","attributes","pairs","item","nodeName","replace","nodeValue","formatted","content","innerHTML","substr","configure","t","n","r","s","u","code","glbl","setTimeout","clearTimeout","setInterval","clearInterval","setImmediate","clearImmediate","NOOP","timeoutResult","addTimerReturnsObject","NativeDate","uniqueTimerId","parseTime","parsed","strings","ms","parseInt","pow","getEpoch","epoch","TypeError","inRange","from","to","timer","callAt","mirrorDateProperties","target","source","now","clock","toSource","parse","UTC","toUTCString","createDate","ClockDate","year","month","date","hour","minute","second","arguments","addTimer","undefined","timers","id","createdAt","delay","duringTick","ref","unref","compareTimers","a","b","immediate","firstTimerInRange","callTimer","exception","interval","apply","args","eval","timerType","clearTimer","timerId","ttype","uninstall","method","methods","hadOwnProperty","ignore","hijackMethod","createClock","timeouts","timeout","Array","slice","tick","oldNow","firstException","tickFrom","tickTo","previous","reset","setSystemTime","newNow","difference","install","toFake","self","sinon","sinonGlobal","hasOwn","success","parentNode","isDOMNode","isReallyNaN","mirrorProperties","isRestorable","restore","hasES5Support","makeApi","wrapMethod","property","checkWrappedMethod","wrappedMethod","error","calledBefore","verb","returns","stackTrace","stack","owned","methodDesc","wrappedMethodDesc","getPropertyDescriptor","types","objectKeys","defineProperty","create","proto","F","isMatcher","ignoreCase","multiline","aString","aLength","bLength","functionToString","getCall","callCount","thisValue","descriptor","getOwnPropertyDescriptor","getPrototypeOf","getConfig","custom","config","defaults","defaultConfig","injectIntoThis","injectInto","useFakeTimers","useFakeServer","timesInWords","count","calledInOrder","spies","called","orderByFirstCall","aCall","bCall","callId","createStubInstance","stub","hasDontEnumBug","toLocaleString","isPrototypeOf","propertyIsEnumerable","unique","result","extend","sources","loadDependencies","typeOf","string","substring","assertType","type","actual","message","matchObject","expectation","exp","act","createPropertyMatcher","propertyTest","messagePrefix","onlyProperty","or","m2","m1","and","any","defined","truthy","falsy","same","instanceOf","has","bool","number","regexp","valueFormatter","formatter","getFormatioFormatter","format","throwYieldError","proxy","text","msg","callProto","calledOn","calledWith","calledWithMatch","calledWithExactly","notCalledWith","notCalledWithMatch","returned","returnValue","threw","calledWithNew","other","calledAfter","callArg","pos","callArgOn","callArgWith","callArgOnWith","concat","yieldOn","yieldTo","yieldToOn","getStackFrames","callStr","createSpyCall","spy","proxyCall","invokeCallback","yield","spyCall","matchingFake","fakes","strict","incrementCallCount","notCalled","calledOnce","calledTwice","calledThrice","createCallProperties","firstCall","secondCall","thirdCall","lastCall","vars","createProxy","proxyLength","p","invoke","isSinonProxy","uuid","spyApi","invoking","err","returnValues","thisValues","exceptions","callIds","stacks","spyLength","instantiateFake","matching","named","getCalls","calls","spyFn","withArgs","original","fake","matchingAguments","parent","margs","printf","spyInstance","specifyer","formatters","delegateToCalls","matchAny","currentCall","c","C","stringifiedCall","isNode","isAMD","nextTick","process","callback","throwsException","callCallback","behavior","callArgAt","argumentList","reverse","callArgProp","getCallback","getCallbackError","callbackAsync","callbackContext","callbackArguments","isPresent","returnArgAt","returnThis","returnValueDefined","context","onCall","index","onFirstCall","onSecondCall","onThirdCall","callsArg","callsArgOn","callsArgWith","callsArgOnWith","yields","yieldsRight","yieldsOn","yieldsTo","yieldsToOn","throws","returnsArg","returnsThis","createAsyncVersion","syncFnName","walkInternal","iterator","originalObj","seen","getOwnPropertyNames","forEach","get","walk","wrapper","stubLength","propOwner","getDefaultBehavior","stubInstance","defaultBehavior","getCurrentBehavior","getParentBehaviour","behaviors","functionStub","orig","resetBehavior","createBehavior","behaviorMethod","mock","each","collection","arrayEquals","arr1","arr2","compareLength","mockObject","expects","expectations","proxies","invokeMethod","verify","messages","met","fail","pass","available","expectationsWithMatchingArgs","currentArgs","expectedArguments","expectsExactArgCount","allowsCall","exhausted","unshift","times","receivedMaxCalls","maxCalls","verifyMatcher","possibleMatcher","arg","minCalls","methodName","verifyCallAllowed","atLeast","num","limitsSet","atMost","never","exactly","once","twice","thrice","failed","expectedThis","withExactArgs","on","max","expectedCallCountInWords","assert","getFakes","fakeCollection","splice","compact","verifyAndRestore","add","stubbedObj","inject","col","lol","llx","shift","epxorts","core","Event","bubbles","cancelable","initEvent","stopPropagation","preventDefault","defaultPrevented","ProgressEvent","progressEventRaw","loaded","total","lengthComputable","CustomEvent","customData","detail","EventTarget","addEventListener","event","listener","eventListeners","removeEventListener","listeners","dispatchEvent","handleEvent","realSetTimeout","logError","label","throwLoggedError","log","useImmediateExceptions","xdr","XDomainRequest","FakeXDomainRequest","readyState","UNSENT","requestBody","requestHeaders","status","onCreate","open","url","responseText","sendFlag","readyStateChange","OPENED","state","eventName","LOADING","DONE","isTimeout","errorFlag","send","data","x","verifyState","onSend","abort","aborted","setResponseBody","body","verifyRequestSent","verifyResponseBodyType","chunkSize","respond","contentType","simulatetimeout","useFakeXDomainRequest","keepOnCreate","supportsXDR","GlobalXDomainRequest","workingXDR","globalScope","supportsProgress","supportsCustomEvent","supportsFormData","FormData","supportsArrayBuffer","ArrayBuffer","supportsBlob","Blob","sinonXhr","XMLHttpRequest","GlobalXMLHttpRequest","GlobalActiveXObject","ActiveXObject","supportsActiveX","supportsXHR","workingXHR","supportsCORS","unsafeHeaders","Connection","Cookie","Cookie2","Expect","Host","Referer","TE","Trailer","Upgrade","Via","UploadProgress","progress","load","FakeXMLHttpRequest","statusText","upload","responseType","response","withCredentials","xhr","events","getHeader","headers","header","h","filters","addFilter","IE6Re","convertToArrayBuffer","buffer","view","Uint8Array","charCode","charCodeAt","isXmlContentType","clearResponse","responseXML","async","username","password","useFilters","xhrArgs","some","filter","defake","readyStateChangeEvent","onreadystatechange","setRequestHeader","setResponseHeaders","verifyRequestOpened","responseHeaders","HEADERS_RECEIVED","onerror","getResponseHeader","getAllResponseHeaders","verifyHeadersReceived","isTextResponse","blobOptions","parseXML","convertResponseBody","statusCodes","uploadProgress","downloadProgress","uploadError","useFakeXMLHttpRequest","objId","fakeXhr","copyAttrs","navigator","userAgent","stateChange","handler","DOMParser","parseFromString","xmlDoc","loadXML","responseArray","wloc","location","rCurrLoc","protocol","host","request","requestUrl","reqMethod","reqUrl","rmeth","matchMethod","matchUrl","matchOne","getHTTPMethod","ru","exec","fakeServer","server","requests","xhrObj","addRequest","setting","whitelist","handleRequest","respondImmediately","autoRespond","responding","autoRespondAfter","fakeHTTPMethods","queue","processRequest","respondWith","responses","Server","fakeServerWithClock","resetClock","longestTimeout","clockSetTimeout","clockSetInterval","returnVal","exposeValue","sandbox","injectedKeys","serverPrototype","restoreContext","prepareSandboxFromConfig","exposed","sinonSandboxedTest","oldDone","res","done","createTest","setUp","tearDown","testCase","tests","testName","rPrefix","verifyIsStub","failAssertion","mirrorPropAsAssertion","exposedName","toUpperCase","failException","callOrder","expected","expose","includeFail"],"sourceRoot":""}