{"version":3,"file":"3469-0da72.js","mappings":"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","sources":["/home/vsts/work/1/s/node_modules/underscore/underscore.js"],"sourcesContent":["// Underscore.js 1.8.3\n// http://underscorejs.org\n// (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n// Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n // Baseline setup\n // --------------\n\n // Establish the root object, `window` in the browser, or `exports` on the server.\n var root = this;\n\n // Save the previous value of the `_` variable.\n var previousUnderscore = root._;\n\n // Save bytes in the minified (but not gzipped) version:\n var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n // Create quick reference variables for speed access to core prototypes.\n var\n push = ArrayProto.push,\n slice = ArrayProto.slice,\n toString = ObjProto.toString,\n hasOwnProperty = ObjProto.hasOwnProperty;\n\n // All **ECMAScript 5** native function implementations that we hope to use\n // are declared here.\n var\n nativeIsArray = Array.isArray,\n nativeKeys = Object.keys,\n nativeBind = FuncProto.bind,\n nativeCreate = Object.create;\n\n // Naked function reference for surrogate-prototype-swapping.\n var Ctor = function(){};\n\n // Create a safe reference to the Underscore object for use below.\n var _ = function(obj) {\n if (obj instanceof _) return obj;\n if (!(this instanceof _)) return new _(obj);\n this._wrapped = obj;\n };\n\n // Export the Underscore object for **Node.js**, with\n // backwards-compatibility for the old `require()` API. If we're in\n // the browser, add `_` as a global object.\n if (typeof exports !== 'undefined') {\n if (typeof module !== 'undefined' && module.exports) {\n exports = module.exports = _;\n }\n exports._ = _;\n } else {\n root._ = _;\n }\n\n // Current version.\n _.VERSION = '1.8.3';\n\n // Internal function that returns an efficient (for current engines) version\n // of the passed-in callback, to be repeatedly applied in other Underscore\n // functions.\n var optimizeCb = function(func, context, argCount) {\n if (context === void 0) return func;\n switch (argCount == null ? 3 : argCount) {\n case 1: return function(value) {\n return func.call(context, value);\n };\n case 2: return function(value, other) {\n return func.call(context, value, other);\n };\n case 3: return function(value, index, collection) {\n return func.call(context, value, index, collection);\n };\n case 4: return function(accumulator, value, index, collection) {\n return func.call(context, accumulator, value, index, collection);\n };\n }\n return function() {\n return func.apply(context, arguments);\n };\n };\n\n // A mostly-internal function to generate callbacks that can be applied\n // to each element in a collection, returning the desired result — either\n // identity, an arbitrary callback, a property matcher, or a property accessor.\n var cb = function(value, context, argCount) {\n if (value == null) return _.identity;\n if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n if (_.isObject(value)) return _.matcher(value);\n return _.property(value);\n };\n _.iteratee = function(value, context) {\n return cb(value, context, Infinity);\n };\n\n // An internal function for creating assigner functions.\n var createAssigner = function(keysFunc, undefinedOnly) {\n return function(obj) {\n var length = arguments.length;\n if (length < 2 || obj == null) return obj;\n for (var index = 1; index < length; index++) {\n var source = arguments[index],\n keys = keysFunc(source),\n l = keys.length;\n for (var i = 0; i < l; i++) {\n var key = keys[i];\n if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n }\n }\n return obj;\n };\n };\n\n // An internal function for creating a new object that inherits from another.\n var baseCreate = function(prototype) {\n if (!_.isObject(prototype)) return {};\n if (nativeCreate) return nativeCreate(prototype);\n Ctor.prototype = prototype;\n var result = new Ctor;\n Ctor.prototype = null;\n return result;\n };\n\n var property = function(key) {\n return function(obj) {\n return obj == null ? void 0 : obj[key];\n };\n };\n\n // Helper for collection methods to determine whether a collection\n // should be iterated as an array or as an object\n // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n var getLength = property('length');\n var isArrayLike = function(collection) {\n var length = getLength(collection);\n return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n };\n\n // Collection Functions\n // --------------------\n\n // The cornerstone, an `each` implementation, aka `forEach`.\n // Handles raw objects in addition to array-likes. Treats all\n // sparse array-likes as if they were dense.\n _.each = _.forEach = function(obj, iteratee, context) {\n iteratee = optimizeCb(iteratee, context);\n var i, length;\n if (isArrayLike(obj)) {\n for (i = 0, length = obj.length; i < length; i++) {\n iteratee(obj[i], i, obj);\n }\n } else {\n var keys = _.keys(obj);\n for (i = 0, length = keys.length; i < length; i++) {\n iteratee(obj[keys[i]], keys[i], obj);\n }\n }\n return obj;\n };\n\n // Return the results of applying the iteratee to each element.\n _.map = _.collect = function(obj, iteratee, context) {\n iteratee = cb(iteratee, context);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length,\n results = Array(length);\n for (var index = 0; index < length; index++) {\n var currentKey = keys ? keys[index] : index;\n results[index] = iteratee(obj[currentKey], currentKey, obj);\n }\n return results;\n };\n\n // Create a reducing function iterating left or right.\n function createReduce(dir) {\n // Optimized iterator function as using arguments.length\n // in the main function will deoptimize the, see #1991.\n function iterator(obj, iteratee, memo, keys, index, length) {\n for (; index >= 0 && index < length; index += dir) {\n var currentKey = keys ? keys[index] : index;\n memo = iteratee(memo, obj[currentKey], currentKey, obj);\n }\n return memo;\n }\n\n return function(obj, iteratee, memo, context) {\n iteratee = optimizeCb(iteratee, context, 4);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length,\n index = dir > 0 ? 0 : length - 1;\n // Determine the initial value if none is provided.\n if (arguments.length < 3) {\n memo = obj[keys ? keys[index] : index];\n index += dir;\n }\n return iterator(obj, iteratee, memo, keys, index, length);\n };\n }\n\n // **Reduce** builds up a single result from a list of values, aka `inject`,\n // or `foldl`.\n _.reduce = _.foldl = _.inject = createReduce(1);\n\n // The right-associative version of reduce, also known as `foldr`.\n _.reduceRight = _.foldr = createReduce(-1);\n\n // Return the first value which passes a truth test. Aliased as `detect`.\n _.find = _.detect = function(obj, predicate, context) {\n var key;\n if (isArrayLike(obj)) {\n key = _.findIndex(obj, predicate, context);\n } else {\n key = _.findKey(obj, predicate, context);\n }\n if (key !== void 0 && key !== -1) return obj[key];\n };\n\n // Return all the elements that pass a truth test.\n // Aliased as `select`.\n _.filter = _.select = function(obj, predicate, context) {\n var results = [];\n predicate = cb(predicate, context);\n _.each(obj, function(value, index, list) {\n if (predicate(value, index, list)) results.push(value);\n });\n return results;\n };\n\n // Return all the elements for which a truth test fails.\n _.reject = function(obj, predicate, context) {\n return _.filter(obj, _.negate(cb(predicate)), context);\n };\n\n // Determine whether all of the elements match a truth test.\n // Aliased as `all`.\n _.every = _.all = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length;\n for (var index = 0; index < length; index++) {\n var currentKey = keys ? keys[index] : index;\n if (!predicate(obj[currentKey], currentKey, obj)) return false;\n }\n return true;\n };\n\n // Determine if at least one element in the object matches a truth test.\n // Aliased as `any`.\n _.some = _.any = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length;\n for (var index = 0; index < length; index++) {\n var currentKey = keys ? keys[index] : index;\n if (predicate(obj[currentKey], currentKey, obj)) return true;\n }\n return false;\n };\n\n // Determine if the array or object contains a given item (using `===`).\n // Aliased as `includes` and `include`.\n _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n if (!isArrayLike(obj)) obj = _.values(obj);\n if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n return _.indexOf(obj, item, fromIndex) >= 0;\n };\n\n // Invoke a method (with arguments) on every item in a collection.\n _.invoke = function(obj, method) {\n var args = slice.call(arguments, 2);\n var isFunc = _.isFunction(method);\n return _.map(obj, function(value) {\n var func = isFunc ? method : value[method];\n return func == null ? func : func.apply(value, args);\n });\n };\n\n // Convenience version of a common use case of `map`: fetching a property.\n _.pluck = function(obj, key) {\n return _.map(obj, _.property(key));\n };\n\n // Convenience version of a common use case of `filter`: selecting only objects\n // containing specific `key:value` pairs.\n _.where = function(obj, attrs) {\n return _.filter(obj, _.matcher(attrs));\n };\n\n // Convenience version of a common use case of `find`: getting the first object\n // containing specific `key:value` pairs.\n _.findWhere = function(obj, attrs) {\n return _.find(obj, _.matcher(attrs));\n };\n\n // Return the maximum element (or element-based computation).\n _.max = function(obj, iteratee, context) {\n var result = -Infinity, lastComputed = -Infinity,\n value, computed;\n if (iteratee == null && obj != null) {\n obj = isArrayLike(obj) ? obj : _.values(obj);\n for (var i = 0, length = obj.length; i < length; i++) {\n value = obj[i];\n if (value > result) {\n result = value;\n }\n }\n } else {\n iteratee = cb(iteratee, context);\n _.each(obj, function(value, index, list) {\n computed = iteratee(value, index, list);\n if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n result = value;\n lastComputed = computed;\n }\n });\n }\n return result;\n };\n\n // Return the minimum element (or element-based computation).\n _.min = function(obj, iteratee, context) {\n var result = Infinity, lastComputed = Infinity,\n value, computed;\n if (iteratee == null && obj != null) {\n obj = isArrayLike(obj) ? obj : _.values(obj);\n for (var i = 0, length = obj.length; i < length; i++) {\n value = obj[i];\n if (value < result) {\n result = value;\n }\n }\n } else {\n iteratee = cb(iteratee, context);\n _.each(obj, function(value, index, list) {\n computed = iteratee(value, index, list);\n if (computed < lastComputed || computed === Infinity && result === Infinity) {\n result = value;\n lastComputed = computed;\n }\n });\n }\n return result;\n };\n\n // Shuffle a collection, using the modern version of the\n // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n _.shuffle = function(obj) {\n var set = isArrayLike(obj) ? obj : _.values(obj);\n var length = set.length;\n var shuffled = Array(length);\n for (var index = 0, rand; index < length; index++) {\n rand = _.random(0, index);\n if (rand !== index) shuffled[index] = shuffled[rand];\n shuffled[rand] = set[index];\n }\n return shuffled;\n };\n\n // Sample **n** random values from a collection.\n // If **n** is not specified, returns a single random element.\n // The internal `guard` argument allows it to work with `map`.\n _.sample = function(obj, n, guard) {\n if (n == null || guard) {\n if (!isArrayLike(obj)) obj = _.values(obj);\n return obj[_.random(obj.length - 1)];\n }\n return _.shuffle(obj).slice(0, Math.max(0, n));\n };\n\n // Sort the object's values by a criterion produced by an iteratee.\n _.sortBy = function(obj, iteratee, context) {\n iteratee = cb(iteratee, context);\n return _.pluck(_.map(obj, function(value, index, list) {\n return {\n value: value,\n index: index,\n criteria: iteratee(value, index, list)\n };\n }).sort(function(left, right) {\n var a = left.criteria;\n var b = right.criteria;\n if (a !== b) {\n if (a > b || a === void 0) return 1;\n if (a < b || b === void 0) return -1;\n }\n return left.index - right.index;\n }), 'value');\n };\n\n // An internal function used for aggregate \"group by\" operations.\n var group = function(behavior) {\n return function(obj, iteratee, context) {\n var result = {};\n iteratee = cb(iteratee, context);\n _.each(obj, function(value, index) {\n var key = iteratee(value, index, obj);\n behavior(result, value, key);\n });\n return result;\n };\n };\n\n // Groups the object's values by a criterion. Pass either a string attribute\n // to group by, or a function that returns the criterion.\n _.groupBy = group(function(result, value, key) {\n if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n });\n\n // Indexes the object's values by a criterion, similar to `groupBy`, but for\n // when you know that your index values will be unique.\n _.indexBy = group(function(result, value, key) {\n result[key] = value;\n });\n\n // Counts instances of an object that group by a certain criterion. Pass\n // either a string attribute to count by, or a function that returns the\n // criterion.\n _.countBy = group(function(result, value, key) {\n if (_.has(result, key)) result[key]++; else result[key] = 1;\n });\n\n // Safely create a real, live array from anything iterable.\n _.toArray = function(obj) {\n if (!obj) return [];\n if (_.isArray(obj)) return slice.call(obj);\n if (isArrayLike(obj)) return _.map(obj, _.identity);\n return _.values(obj);\n };\n\n // Return the number of elements in an object.\n _.size = function(obj) {\n if (obj == null) return 0;\n return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n };\n\n // Split a collection into two arrays: one whose elements all satisfy the given\n // predicate, and one whose elements all do not satisfy the predicate.\n _.partition = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var pass = [], fail = [];\n _.each(obj, function(value, key, obj) {\n (predicate(value, key, obj) ? pass : fail).push(value);\n });\n return [pass, fail];\n };\n\n // Array Functions\n // ---------------\n\n // Get the first element of an array. Passing **n** will return the first N\n // values in the array. Aliased as `head` and `take`. The **guard** check\n // allows it to work with `_.map`.\n _.first = _.head = _.take = function(array, n, guard) {\n if (array == null) return void 0;\n if (n == null || guard) return array[0];\n return _.initial(array, array.length - n);\n };\n\n // Returns everything but the last entry of the array. Especially useful on\n // the arguments object. Passing **n** will return all the values in\n // the array, excluding the last N.\n _.initial = function(array, n, guard) {\n return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n };\n\n // Get the last element of an array. Passing **n** will return the last N\n // values in the array.\n _.last = function(array, n, guard) {\n if (array == null) return void 0;\n if (n == null || guard) return array[array.length - 1];\n return _.rest(array, Math.max(0, array.length - n));\n };\n\n // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n // Especially useful on the arguments object. Passing an **n** will return\n // the rest N values in the array.\n _.rest = _.tail = _.drop = function(array, n, guard) {\n return slice.call(array, n == null || guard ? 1 : n);\n };\n\n // Trim out all falsy values from an array.\n _.compact = function(array) {\n return _.filter(array, _.identity);\n };\n\n // Internal implementation of a recursive `flatten` function.\n var flatten = function(input, shallow, strict, startIndex) {\n var output = [], idx = 0;\n for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n var value = input[i];\n if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n //flatten current level of array or arguments object\n if (!shallow) value = flatten(value, shallow, strict);\n var j = 0, len = value.length;\n output.length += len;\n while (j < len) {\n output[idx++] = value[j++];\n }\n } else if (!strict) {\n output[idx++] = value;\n }\n }\n return output;\n };\n\n // Flatten out an array, either recursively (by default), or just one level.\n _.flatten = function(array, shallow) {\n return flatten(array, shallow, false);\n };\n\n // Return a version of the array that does not contain the specified value(s).\n _.without = function(array) {\n return _.difference(array, slice.call(arguments, 1));\n };\n\n // Produce a duplicate-free version of the array. If the array has already\n // been sorted, you have the option of using a faster algorithm.\n // Aliased as `unique`.\n _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n if (!_.isBoolean(isSorted)) {\n context = iteratee;\n iteratee = isSorted;\n isSorted = false;\n }\n if (iteratee != null) iteratee = cb(iteratee, context);\n var result = [];\n var seen = [];\n for (var i = 0, length = getLength(array); i < length; i++) {\n var value = array[i],\n computed = iteratee ? iteratee(value, i, array) : value;\n if (isSorted) {\n if (!i || seen !== computed) result.push(value);\n seen = computed;\n } else if (iteratee) {\n if (!_.contains(seen, computed)) {\n seen.push(computed);\n result.push(value);\n }\n } else if (!_.contains(result, value)) {\n result.push(value);\n }\n }\n return result;\n };\n\n // Produce an array that contains the union: each distinct element from all of\n // the passed-in arrays.\n _.union = function() {\n return _.uniq(flatten(arguments, true, true));\n };\n\n // Produce an array that contains every item shared between all the\n // passed-in arrays.\n _.intersection = function(array) {\n var result = [];\n var argsLength = arguments.length;\n for (var i = 0, length = getLength(array); i < length; i++) {\n var item = array[i];\n if (_.contains(result, item)) continue;\n for (var j = 1; j < argsLength; j++) {\n if (!_.contains(arguments[j], item)) break;\n }\n if (j === argsLength) result.push(item);\n }\n return result;\n };\n\n // Take the difference between one array and a number of other arrays.\n // Only the elements present in just the first array will remain.\n _.difference = function(array) {\n var rest = flatten(arguments, true, true, 1);\n return _.filter(array, function(value){\n return !_.contains(rest, value);\n });\n };\n\n // Zip together multiple lists into a single array -- elements that share\n // an index go together.\n _.zip = function() {\n return _.unzip(arguments);\n };\n\n // Complement of _.zip. Unzip accepts an array of arrays and groups\n // each array's elements on shared indices\n _.unzip = function(array) {\n var length = array && _.max(array, getLength).length || 0;\n var result = Array(length);\n\n for (var index = 0; index < length; index++) {\n result[index] = _.pluck(array, index);\n }\n return result;\n };\n\n // Converts lists into objects. Pass either a single array of `[key, value]`\n // pairs, or two parallel arrays of the same length -- one of keys, and one of\n // the corresponding values.\n _.object = function(list, values) {\n var result = {};\n for (var i = 0, length = getLength(list); i < length; i++) {\n if (values) {\n result[list[i]] = values[i];\n } else {\n result[list[i][0]] = list[i][1];\n }\n }\n return result;\n };\n\n // Generator function to create the findIndex and findLastIndex functions\n function createPredicateIndexFinder(dir) {\n return function(array, predicate, context) {\n predicate = cb(predicate, context);\n var length = getLength(array);\n var index = dir > 0 ? 0 : length - 1;\n for (; index >= 0 && index < length; index += dir) {\n if (predicate(array[index], index, array)) return index;\n }\n return -1;\n };\n }\n\n // Returns the first index on an array-like that passes a predicate test\n _.findIndex = createPredicateIndexFinder(1);\n _.findLastIndex = createPredicateIndexFinder(-1);\n\n // Use a comparator function to figure out the smallest index at which\n // an object should be inserted so as to maintain order. Uses binary search.\n _.sortedIndex = function(array, obj, iteratee, context) {\n iteratee = cb(iteratee, context, 1);\n var value = iteratee(obj);\n var low = 0, high = getLength(array);\n while (low < high) {\n var mid = Math.floor((low + high) / 2);\n if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n }\n return low;\n };\n\n // Generator function to create the indexOf and lastIndexOf functions\n function createIndexFinder(dir, predicateFind, sortedIndex) {\n return function(array, item, idx) {\n var i = 0, length = getLength(array);\n if (typeof idx == 'number') {\n if (dir > 0) {\n i = idx >= 0 ? idx : Math.max(idx + length, i);\n } else {\n length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n }\n } else if (sortedIndex && idx && length) {\n idx = sortedIndex(array, item);\n return array[idx] === item ? idx : -1;\n }\n if (item !== item) {\n idx = predicateFind(slice.call(array, i, length), _.isNaN);\n return idx >= 0 ? idx + i : -1;\n }\n for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n if (array[idx] === item) return idx;\n }\n return -1;\n };\n }\n\n // Return the position of the first occurrence of an item in an array,\n // or -1 if the item is not included in the array.\n // If the array is large and already in sort order, pass `true`\n // for **isSorted** to use binary search.\n _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n // Generate an integer Array containing an arithmetic progression. A port of\n // the native Python `range()` function. See\n // [the Python documentation](http://docs.python.org/library/functions.html#range).\n _.range = function(start, stop, step) {\n if (stop == null) {\n stop = start || 0;\n start = 0;\n }\n step = step || 1;\n\n var length = Math.max(Math.ceil((stop - start) / step), 0);\n var range = Array(length);\n\n for (var idx = 0; idx < length; idx++, start += step) {\n range[idx] = start;\n }\n\n return range;\n };\n\n // Function (ahem) Functions\n // ------------------\n\n // Determines whether to execute a function as a constructor\n // or a normal function with the provided arguments\n var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n var self = baseCreate(sourceFunc.prototype);\n var result = sourceFunc.apply(self, args);\n if (_.isObject(result)) return result;\n return self;\n };\n\n // Create a function bound to a given object (assigning `this`, and arguments,\n // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n // available.\n _.bind = function(func, context) {\n if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n var args = slice.call(arguments, 2);\n var bound = function() {\n return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n };\n return bound;\n };\n\n // Partially apply a function by creating a version that has had some of its\n // arguments pre-filled, without changing its dynamic `this` context. _ acts\n // as a placeholder, allowing any combination of arguments to be pre-filled.\n _.partial = function(func) {\n var boundArgs = slice.call(arguments, 1);\n var bound = function() {\n var position = 0, length = boundArgs.length;\n var args = Array(length);\n for (var i = 0; i < length; i++) {\n args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n }\n while (position < arguments.length) args.push(arguments[position++]);\n return executeBound(func, bound, this, this, args);\n };\n return bound;\n };\n\n // Bind a number of an object's methods to that object. Remaining arguments\n // are the method names to be bound. Useful for ensuring that all callbacks\n // defined on an object belong to it.\n _.bindAll = function(obj) {\n var i, length = arguments.length, key;\n if (length <= 1) throw new Error('bindAll must be passed function names');\n for (i = 1; i < length; i++) {\n key = arguments[i];\n obj[key] = _.bind(obj[key], obj);\n }\n return obj;\n };\n\n // Memoize an expensive function by storing its results.\n _.memoize = function(func, hasher) {\n var memoize = function(key) {\n var cache = memoize.cache;\n var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n return cache[address];\n };\n memoize.cache = {};\n return memoize;\n };\n\n // Delays a function for the given number of milliseconds, and then calls\n // it with the arguments supplied.\n _.delay = function(func, wait) {\n var args = slice.call(arguments, 2);\n return setTimeout(function(){\n return func.apply(null, args);\n }, wait);\n };\n\n // Defers a function, scheduling it to run after the current call stack has\n // cleared.\n _.defer = _.partial(_.delay, _, 1);\n\n // Returns a function, that, when invoked, will only be triggered at most once\n // during a given window of time. Normally, the throttled function will run\n // as much as it can, without ever going more than once per `wait` duration;\n // but if you'd like to disable the execution on the leading edge, pass\n // `{leading: false}`. To disable execution on the trailing edge, ditto.\n _.throttle = function(func, wait, options) {\n var context, args, result;\n var timeout = null;\n var previous = 0;\n if (!options) options = {};\n var later = function() {\n previous = options.leading === false ? 0 : _.now();\n timeout = null;\n result = func.apply(context, args);\n if (!timeout) context = args = null;\n };\n return function() {\n var now = _.now();\n if (!previous && options.leading === false) previous = now;\n var remaining = wait - (now - previous);\n context = this;\n args = arguments;\n if (remaining <= 0 || remaining > wait) {\n if (timeout) {\n clearTimeout(timeout);\n timeout = null;\n }\n previous = now;\n result = func.apply(context, args);\n if (!timeout) context = args = null;\n } else if (!timeout && options.trailing !== false) {\n timeout = setTimeout(later, remaining);\n }\n return result;\n };\n };\n\n // Returns a function, that, as long as it continues to be invoked, will not\n // be triggered. The function will be called after it stops being called for\n // N milliseconds. If `immediate` is passed, trigger the function on the\n // leading edge, instead of the trailing.\n _.debounce = function(func, wait, immediate) {\n var timeout, args, context, timestamp, result;\n\n var later = function() {\n var last = _.now() - timestamp;\n\n if (last < wait && last >= 0) {\n timeout = setTimeout(later, wait - last);\n } else {\n timeout = null;\n if (!immediate) {\n result = func.apply(context, args);\n if (!timeout) context = args = null;\n }\n }\n };\n\n return function() {\n context = this;\n args = arguments;\n timestamp = _.now();\n var callNow = immediate && !timeout;\n if (!timeout) timeout = setTimeout(later, wait);\n if (callNow) {\n result = func.apply(context, args);\n context = args = null;\n }\n\n return result;\n };\n };\n\n // Returns the first function passed as an argument to the second,\n // allowing you to adjust arguments, run code before and after, and\n // conditionally execute the original function.\n _.wrap = function(func, wrapper) {\n return _.partial(wrapper, func);\n };\n\n // Returns a negated version of the passed-in predicate.\n _.negate = function(predicate) {\n return function() {\n return !predicate.apply(this, arguments);\n };\n };\n\n // Returns a function that is the composition of a list of functions, each\n // consuming the return value of the function that follows.\n _.compose = function() {\n var args = arguments;\n var start = args.length - 1;\n return function() {\n var i = start;\n var result = args[start].apply(this, arguments);\n while (i--) result = args[i].call(this, result);\n return result;\n };\n };\n\n // Returns a function that will only be executed on and after the Nth call.\n _.after = function(times, func) {\n return function() {\n if (--times < 1) {\n return func.apply(this, arguments);\n }\n };\n };\n\n // Returns a function that will only be executed up to (but not including) the Nth call.\n _.before = function(times, func) {\n var memo;\n return function() {\n if (--times > 0) {\n memo = func.apply(this, arguments);\n }\n if (times <= 1) func = null;\n return memo;\n };\n };\n\n // Returns a function that will be executed at most one time, no matter how\n // often you call it. Useful for lazy initialization.\n _.once = _.partial(_.before, 2);\n\n // Object Functions\n // ----------------\n\n // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n function collectNonEnumProps(obj, keys) {\n var nonEnumIdx = nonEnumerableProps.length;\n var constructor = obj.constructor;\n var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n // Constructor is a special case.\n var prop = 'constructor';\n if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n while (nonEnumIdx--) {\n prop = nonEnumerableProps[nonEnumIdx];\n if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n keys.push(prop);\n }\n }\n }\n\n // Retrieve the names of an object's own properties.\n // Delegates to **ECMAScript 5**'s native `Object.keys`\n _.keys = function(obj) {\n if (!_.isObject(obj)) return [];\n if (nativeKeys) return nativeKeys(obj);\n var keys = [];\n for (var key in obj) if (_.has(obj, key)) keys.push(key);\n // Ahem, IE < 9.\n if (hasEnumBug) collectNonEnumProps(obj, keys);\n return keys;\n };\n\n // Retrieve all the property names of an object.\n _.allKeys = function(obj) {\n if (!_.isObject(obj)) return [];\n var keys = [];\n for (var key in obj) keys.push(key);\n // Ahem, IE < 9.\n if (hasEnumBug) collectNonEnumProps(obj, keys);\n return keys;\n };\n\n // Retrieve the values of an object's properties.\n _.values = function(obj) {\n var keys = _.keys(obj);\n var length = keys.length;\n var values = Array(length);\n for (var i = 0; i < length; i++) {\n values[i] = obj[keys[i]];\n }\n return values;\n };\n\n // Returns the results of applying the iteratee to each element of the object\n // In contrast to _.map it returns an object\n _.mapObject = function(obj, iteratee, context) {\n iteratee = cb(iteratee, context);\n var keys = _.keys(obj),\n length = keys.length,\n results = {},\n currentKey;\n for (var index = 0; index < length; index++) {\n currentKey = keys[index];\n results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n }\n return results;\n };\n\n // Convert an object into a list of `[key, value]` pairs.\n _.pairs = function(obj) {\n var keys = _.keys(obj);\n var length = keys.length;\n var pairs = Array(length);\n for (var i = 0; i < length; i++) {\n pairs[i] = [keys[i], obj[keys[i]]];\n }\n return pairs;\n };\n\n // Invert the keys and values of an object. The values must be serializable.\n _.invert = function(obj) {\n var result = {};\n var keys = _.keys(obj);\n for (var i = 0, length = keys.length; i < length; i++) {\n result[obj[keys[i]]] = keys[i];\n }\n return result;\n };\n\n // Return a sorted list of the function names available on the object.\n // Aliased as `methods`\n _.functions = _.methods = function(obj) {\n var names = [];\n for (var key in obj) {\n if (_.isFunction(obj[key])) names.push(key);\n }\n return names.sort();\n };\n\n // Extend a given object with all the properties in passed-in object(s).\n _.extend = createAssigner(_.allKeys);\n\n // Assigns a given object with all the own properties in the passed-in object(s)\n // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n _.extendOwn = _.assign = createAssigner(_.keys);\n\n // Returns the first key on an object that passes a predicate test\n _.findKey = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var keys = _.keys(obj), key;\n for (var i = 0, length = keys.length; i < length; i++) {\n key = keys[i];\n if (predicate(obj[key], key, obj)) return key;\n }\n };\n\n // Return a copy of the object only containing the whitelisted properties.\n _.pick = function(object, oiteratee, context) {\n var result = {}, obj = object, iteratee, keys;\n if (obj == null) return result;\n if (_.isFunction(oiteratee)) {\n keys = _.allKeys(obj);\n iteratee = optimizeCb(oiteratee, context);\n } else {\n keys = flatten(arguments, false, false, 1);\n iteratee = function(value, key, obj) { return key in obj; };\n obj = Object(obj);\n }\n for (var i = 0, length = keys.length; i < length; i++) {\n var key = keys[i];\n var value = obj[key];\n if (iteratee(value, key, obj)) result[key] = value;\n }\n return result;\n };\n\n // Return a copy of the object without the blacklisted properties.\n _.omit = function(obj, iteratee, context) {\n if (_.isFunction(iteratee)) {\n iteratee = _.negate(iteratee);\n } else {\n var keys = _.map(flatten(arguments, false, false, 1), String);\n iteratee = function(value, key) {\n return !_.contains(keys, key);\n };\n }\n return _.pick(obj, iteratee, context);\n };\n\n // Fill in a given object with default properties.\n _.defaults = createAssigner(_.allKeys, true);\n\n // Creates an object that inherits from the given prototype object.\n // If additional properties are provided then they will be added to the\n // created object.\n _.create = function(prototype, props) {\n var result = baseCreate(prototype);\n if (props) _.extendOwn(result, props);\n return result;\n };\n\n // Create a (shallow-cloned) duplicate of an object.\n _.clone = function(obj) {\n if (!_.isObject(obj)) return obj;\n return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n };\n\n // Invokes interceptor with the obj, and then returns obj.\n // The primary purpose of this method is to \"tap into\" a method chain, in\n // order to perform operations on intermediate results within the chain.\n _.tap = function(obj, interceptor) {\n interceptor(obj);\n return obj;\n };\n\n // Returns whether an object has a given set of `key:value` pairs.\n _.isMatch = function(object, attrs) {\n var keys = _.keys(attrs), length = keys.length;\n if (object == null) return !length;\n var obj = Object(object);\n for (var i = 0; i < length; i++) {\n var key = keys[i];\n if (attrs[key] !== obj[key] || !(key in obj)) return false;\n }\n return true;\n };\n\n\n // Internal recursive comparison function for `isEqual`.\n var eq = function(a, b, aStack, bStack) {\n // Identical objects are equal. `0 === -0`, but they aren't identical.\n // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n if (a === b) return a !== 0 || 1 / a === 1 / b;\n // A strict comparison is necessary because `null == undefined`.\n if (a == null || b == null) return a === b;\n // Unwrap any wrapped objects.\n if (a instanceof _) a = a._wrapped;\n if (b instanceof _) b = b._wrapped;\n // Compare `[[Class]]` names.\n var className = toString.call(a);\n if (className !== toString.call(b)) return false;\n switch (className) {\n // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n case '[object RegExp]':\n // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n case '[object String]':\n // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n // equivalent to `new String(\"5\")`.\n return '' + a === '' + b;\n case '[object Number]':\n // `NaN`s are equivalent, but non-reflexive.\n // Object(NaN) is equivalent to NaN\n if (+a !== +a) return +b !== +b;\n // An `egal` comparison is performed for other numeric values.\n return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n case '[object Date]':\n case '[object Boolean]':\n // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n // millisecond representations. Note that invalid dates with millisecond representations\n // of `NaN` are not equivalent.\n return +a === +b;\n }\n\n var areArrays = className === '[object Array]';\n if (!areArrays) {\n if (typeof a != 'object' || typeof b != 'object') return false;\n\n // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n // from different frames are.\n var aCtor = a.constructor, bCtor = b.constructor;\n if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n _.isFunction(bCtor) && bCtor instanceof bCtor)\n && ('constructor' in a && 'constructor' in b)) {\n return false;\n }\n }\n // Assume equality for cyclic structures. The algorithm for detecting cyclic\n // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n // Initializing stack of traversed objects.\n // It's done here since we only need them for objects and arrays comparison.\n aStack = aStack || [];\n bStack = bStack || [];\n var length = aStack.length;\n while (length--) {\n // Linear search. Performance is inversely proportional to the number of\n // unique nested structures.\n if (aStack[length] === a) return bStack[length] === b;\n }\n\n // Add the first object to the stack of traversed objects.\n aStack.push(a);\n bStack.push(b);\n\n // Recursively compare objects and arrays.\n if (areArrays) {\n // Compare array lengths to determine if a deep comparison is necessary.\n length = a.length;\n if (length !== b.length) return false;\n // Deep compare the contents, ignoring non-numeric properties.\n while (length--) {\n if (!eq(a[length], b[length], aStack, bStack)) return false;\n }\n } else {\n // Deep compare objects.\n var keys = _.keys(a), key;\n length = keys.length;\n // Ensure that both objects contain the same number of properties before comparing deep equality.\n if (_.keys(b).length !== length) return false;\n while (length--) {\n // Deep compare each member\n key = keys[length];\n if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n }\n }\n // Remove the first object from the stack of traversed objects.\n aStack.pop();\n bStack.pop();\n return true;\n };\n\n // Perform a deep comparison to check if two objects are equal.\n _.isEqual = function(a, b) {\n return eq(a, b);\n };\n\n // Is a given array, string, or object empty?\n // An \"empty\" object has no enumerable own-properties.\n _.isEmpty = function(obj) {\n if (obj == null) return true;\n if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n return _.keys(obj).length === 0;\n };\n\n // Is a given value a DOM element?\n _.isElement = function(obj) {\n return !!(obj && obj.nodeType === 1);\n };\n\n // Is a given value an array?\n // Delegates to ECMA5's native Array.isArray\n _.isArray = nativeIsArray || function(obj) {\n return toString.call(obj) === '[object Array]';\n };\n\n // Is a given variable an object?\n _.isObject = function(obj) {\n var type = typeof obj;\n return type === 'function' || type === 'object' && !!obj;\n };\n\n // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n _['is' + name] = function(obj) {\n return toString.call(obj) === '[object ' + name + ']';\n };\n });\n\n // Define a fallback version of the method in browsers (ahem, IE < 9), where\n // there isn't any inspectable \"Arguments\" type.\n if (!_.isArguments(arguments)) {\n _.isArguments = function(obj) {\n return _.has(obj, 'callee');\n };\n }\n\n // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n // IE 11 (#1621), and in Safari 8 (#1929).\n if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n _.isFunction = function(obj) {\n return typeof obj == 'function' || false;\n };\n }\n\n // Is a given object a finite number?\n _.isFinite = function(obj) {\n return isFinite(obj) && !isNaN(parseFloat(obj));\n };\n\n // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n _.isNaN = function(obj) {\n return _.isNumber(obj) && obj !== +obj;\n };\n\n // Is a given value a boolean?\n _.isBoolean = function(obj) {\n return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n };\n\n // Is a given value equal to null?\n _.isNull = function(obj) {\n return obj === null;\n };\n\n // Is a given variable undefined?\n _.isUndefined = function(obj) {\n return obj === void 0;\n };\n\n // Shortcut function for checking if an object has a given property directly\n // on itself (in other words, not on a prototype).\n _.has = function(obj, key) {\n return obj != null && hasOwnProperty.call(obj, key);\n };\n\n // Utility Functions\n // -----------------\n\n // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n // previous owner. Returns a reference to the Underscore object.\n _.noConflict = function() {\n root._ = previousUnderscore;\n return this;\n };\n\n // Keep the identity function around for default iteratees.\n _.identity = function(value) {\n return value;\n };\n\n // Predicate-generating functions. Often useful outside of Underscore.\n _.constant = function(value) {\n return function() {\n return value;\n };\n };\n\n _.noop = function(){};\n\n _.property = property;\n\n // Generates a function for a given object that returns a given property.\n _.propertyOf = function(obj) {\n return obj == null ? function(){} : function(key) {\n return obj[key];\n };\n };\n\n // Returns a predicate for checking whether an object has a given set of\n // `key:value` pairs.\n _.matcher = _.matches = function(attrs) {\n attrs = _.extendOwn({}, attrs);\n return function(obj) {\n return _.isMatch(obj, attrs);\n };\n };\n\n // Run a function **n** times.\n _.times = function(n, iteratee, context) {\n var accum = Array(Math.max(0, n));\n iteratee = optimizeCb(iteratee, context, 1);\n for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n return accum;\n };\n\n // Return a random integer between min and max (inclusive).\n _.random = function(min, max) {\n if (max == null) {\n max = min;\n min = 0;\n }\n return min + Math.floor(Math.random() * (max - min + 1));\n };\n\n // A (possibly faster) way to get the current timestamp as an integer.\n _.now = Date.now || function() {\n return new Date().getTime();\n };\n\n // List of HTML entities for escaping.\n var escapeMap = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n '`': '`'\n };\n var unescapeMap = _.invert(escapeMap);\n\n // Functions for escaping and unescaping strings to/from HTML interpolation.\n var createEscaper = function(map) {\n var escaper = function(match) {\n return map[match];\n };\n // Regexes for identifying a key that needs to be escaped\n var source = '(?:' + _.keys(map).join('|') + ')';\n var testRegexp = RegExp(source);\n var replaceRegexp = RegExp(source, 'g');\n return function(string) {\n string = string == null ? '' : '' + string;\n return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n };\n };\n _.escape = createEscaper(escapeMap);\n _.unescape = createEscaper(unescapeMap);\n\n // If the value of the named `property` is a function then invoke it with the\n // `object` as context; otherwise, return it.\n _.result = function(object, property, fallback) {\n var value = object == null ? void 0 : object[property];\n if (value === void 0) {\n value = fallback;\n }\n return _.isFunction(value) ? value.call(object) : value;\n };\n\n // Generate a unique integer id (unique within the entire client session).\n // Useful for temporary DOM ids.\n var idCounter = 0;\n _.uniqueId = function(prefix) {\n var id = ++idCounter + '';\n return prefix ? prefix + id : id;\n };\n\n // By default, Underscore uses ERB-style template delimiters, change the\n // following template settings to use alternative delimiters.\n _.templateSettings = {\n evaluate : /<%([\\s\\S]+?)%>/g,\n interpolate : /<%=([\\s\\S]+?)%>/g,\n escape : /<%-([\\s\\S]+?)%>/g\n };\n\n // When customizing `templateSettings`, if you don't want to define an\n // interpolation, evaluation or escaping regex, we need one that is\n // guaranteed not to match.\n var noMatch = /(.)^/;\n\n // Certain characters need to be escaped so that they can be put into a\n // string literal.\n var escapes = {\n \"'\": \"'\",\n '\\\\': '\\\\',\n '\\r': 'r',\n '\\n': 'n',\n '\\u2028': 'u2028',\n '\\u2029': 'u2029'\n };\n\n var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n var escapeChar = function(match) {\n return '\\\\' + escapes[match];\n };\n\n // JavaScript micro-templating, similar to John Resig's implementation.\n // Underscore templating handles arbitrary delimiters, preserves whitespace,\n // and correctly escapes quotes within interpolated code.\n // NB: `oldSettings` only exists for backwards compatibility.\n _.template = function(text, settings, oldSettings) {\n if (!settings && oldSettings) settings = oldSettings;\n settings = _.defaults({}, settings, _.templateSettings);\n\n // Combine delimiters into one regular expression via alternation.\n var matcher = RegExp([\n (settings.escape || noMatch).source,\n (settings.interpolate || noMatch).source,\n (settings.evaluate || noMatch).source\n ].join('|') + '|$', 'g');\n\n // Compile the template source, escaping string literals appropriately.\n var index = 0;\n var source = \"__p+='\";\n text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n source += text.slice(index, offset).replace(escaper, escapeChar);\n index = offset + match.length;\n\n if (escape) {\n source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n } else if (interpolate) {\n source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n } else if (evaluate) {\n source += \"';\\n\" + evaluate + \"\\n__p+='\";\n }\n\n // Adobe VMs need the match returned to produce the correct offest.\n return match;\n });\n source += \"';\\n\";\n\n // If a variable is not specified, place data values in local scope.\n if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n source = \"var __t,__p='',__j=Array.prototype.join,\" +\n \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n source + 'return __p;\\n';\n\n try {\n var render = new Function(settings.variable || 'obj', '_', source);\n } catch (e) {\n e.source = source;\n throw e;\n }\n\n var template = function(data) {\n return render.call(this, data, _);\n };\n\n // Provide the compiled source as a convenience for precompilation.\n var argument = settings.variable || 'obj';\n template.source = 'function(' + argument + '){\\n' + source + '}';\n\n return template;\n };\n\n // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n _.chain = function(obj) {\n var instance = _(obj);\n instance._chain = true;\n return instance;\n };\n\n // OOP\n // ---------------\n // If Underscore is called as a function, it returns a wrapped object that\n // can be used OO-style. This wrapper holds altered versions of all the\n // underscore functions. Wrapped objects may be chained.\n\n // Helper function to continue chaining intermediate results.\n var result = function(instance, obj) {\n return instance._chain ? _(obj).chain() : obj;\n };\n\n // Add your own custom functions to the Underscore object.\n _.mixin = function(obj) {\n _.each(_.functions(obj), function(name) {\n var func = _[name] = obj[name];\n _.prototype[name] = function() {\n var args = [this._wrapped];\n push.apply(args, arguments);\n return result(this, func.apply(_, args));\n };\n });\n };\n\n // Add all of the Underscore functions to the wrapper object.\n _.mixin(_);\n\n // Add all mutator Array functions to the wrapper.\n _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n var method = ArrayProto[name];\n _.prototype[name] = function() {\n var obj = this._wrapped;\n method.apply(obj, arguments);\n if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n return result(this, obj);\n };\n });\n\n // Add all accessor Array functions to the wrapper.\n _.each(['concat', 'join', 'slice'], function(name) {\n var method = ArrayProto[name];\n _.prototype[name] = function() {\n return result(this, method.apply(this._wrapped, arguments));\n };\n });\n\n // Extracts the result from a wrapped and chained object.\n _.prototype.value = function() {\n return this._wrapped;\n };\n\n // Provide unwrapping proxy for some methods used in engine operations\n // such as arithmetic and JSON stringification.\n _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n _.prototype.toString = function() {\n return '' + this._wrapped;\n };\n\n // AMD registration happens at the end for compatibility with AMD loaders\n // that may not enforce next-turn semantics on modules. Even though general\n // practice for AMD registration is to be anonymous, underscore registers\n // as a named module because, like jQuery, it is a base library that is\n // popular enough to be bundled in a third party lib, but not be part of\n // an AMD load request. Those cases could generate an error when an\n // anonymous define() is called outside of a loader request.\n if (typeof define === 'function' && define.amd) {\n define('underscore', [], function() {\n return _;\n });\n }\n}.call(this));\n"],"names":["root","this","previousUnderscore","_","ArrayProto","Array","prototype","ObjProto","Object","FuncProto","Function","push","slice","toString","hasOwnProperty","nativeIsArray","isArray","nativeKeys","keys","nativeBind","bind","nativeCreate","create","Ctor","obj","_wrapped","module","exports","VERSION","optimizeCb","func","context","argCount","value","call","other","index","collection","accumulator","apply","arguments","cb","identity","isFunction","isObject","matcher","property","iteratee","Infinity","createAssigner","keysFunc","undefinedOnly","length","source","l","i","key","baseCreate","result","MAX_ARRAY_INDEX","Math","pow","getLength","isArrayLike","createReduce","dir","iterator","memo","currentKey","each","forEach","map","collect","results","reduce","foldl","inject","reduceRight","foldr","find","detect","predicate","findIndex","findKey","filter","select","list","reject","negate","every","all","some","any","contains","includes","include","item","fromIndex","guard","values","indexOf","invoke","method","args","isFunc","pluck","where","attrs","findWhere","max","computed","lastComputed","min","shuffle","rand","set","shuffled","random","sample","n","sortBy","criteria","sort","left","right","a","b","group","behavior","groupBy","has","indexBy","countBy","toArray","size","partition","pass","fail","first","head","take","array","initial","last","rest","tail","drop","compact","flatten","input","shallow","strict","startIndex","output","idx","isArguments","j","len","createPredicateIndexFinder","createIndexFinder","predicateFind","sortedIndex","isNaN","without","difference","uniq","unique","isSorted","isBoolean","seen","union","intersection","argsLength","zip","unzip","object","findLastIndex","low","high","mid","floor","lastIndexOf","range","start","stop","step","ceil","executeBound","sourceFunc","boundFunc","callingContext","self","TypeError","bound","concat","partial","boundArgs","position","bindAll","Error","memoize","hasher","cache","address","delay","wait","setTimeout","defer","throttle","options","timeout","previous","later","leading","now","remaining","clearTimeout","trailing","debounce","immediate","timestamp","callNow","wrap","wrapper","compose","after","times","before","once","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","collectNonEnumProps","nonEnumIdx","constructor","proto","prop","allKeys","mapObject","pairs","invert","functions","methods","names","extend","extendOwn","assign","pick","oiteratee","omit","String","defaults","props","clone","tap","interceptor","isMatch","eq","aStack","bStack","className","areArrays","aCtor","bCtor","pop","isEqual","isEmpty","isString","isElement","nodeType","type","name","Int8Array","isFinite","parseFloat","isNumber","isNull","isUndefined","noConflict","constant","noop","propertyOf","matches","accum","Date","getTime","escapeMap","unescapeMap","createEscaper","escaper","match","join","testRegexp","RegExp","replaceRegexp","string","test","replace","escape","unescape","fallback","idCounter","uniqueId","prefix","id","templateSettings","evaluate","interpolate","noMatch","escapes","escapeChar","template","text","settings","oldSettings","offset","variable","render","e","data","argument","chain","instance","_chain","mixin","valueOf","toJSON"],"sourceRoot":""}