http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/collections/shuffle.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/collections/shuffle.js b/node_modules/lodash-node/compat/collections/shuffle.js new file mode 100644 index 0000000..d37777c --- /dev/null +++ b/node_modules/lodash-node/compat/collections/shuffle.js @@ -0,0 +1,39 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseRandom = require('../internals/baseRandom'), + forEach = require('./forEach'); + +/** + * Creates an array of shuffled values, using a version of the Fisher-Yates + * shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. + * + * @static + * @memberOf _ + * @category Collections + * @param {Array|Object|string} collection The collection to shuffle. + * @returns {Array} Returns a new shuffled collection. + * @example + * + * _.shuffle([1, 2, 3, 4, 5, 6]); + * // => [4, 1, 6, 3, 5, 2] + */ +function shuffle(collection) { + var index = -1, + length = collection ? collection.length : 0, + result = Array(typeof length == 'number' ? length : 0); + + forEach(collection, function(value) { + var rand = baseRandom(0, ++index); + result[index] = result[rand]; + result[rand] = value; + }); + return result; +} + +module.exports = shuffle;
http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/collections/size.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/collections/size.js b/node_modules/lodash-node/compat/collections/size.js new file mode 100644 index 0000000..bfc821f --- /dev/null +++ b/node_modules/lodash-node/compat/collections/size.js @@ -0,0 +1,36 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var keys = require('../objects/keys'); + +/** + * Gets the size of the `collection` by returning `collection.length` for arrays + * and array-like objects or the number of own enumerable properties for objects. + * + * @static + * @memberOf _ + * @category Collections + * @param {Array|Object|string} collection The collection to inspect. + * @returns {number} Returns `collection.length` or number of own enumerable properties. + * @example + * + * _.size([1, 2]); + * // => 2 + * + * _.size({ 'one': 1, 'two': 2, 'three': 3 }); + * // => 3 + * + * _.size('pebbles'); + * // => 7 + */ +function size(collection) { + var length = collection ? collection.length : 0; + return typeof length == 'number' ? length : keys(collection).length; +} + +module.exports = size; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/collections/some.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/collections/some.js b/node_modules/lodash-node/compat/collections/some.js new file mode 100644 index 0000000..c8d7ee5 --- /dev/null +++ b/node_modules/lodash-node/compat/collections/some.js @@ -0,0 +1,76 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseEach = require('../internals/baseEach'), + createCallback = require('../functions/createCallback'), + isArray = require('../objects/isArray'); + +/** + * Checks if the callback returns a truey value for **any** element of a + * collection. The function returns as soon as it finds a passing value and + * does not iterate over the entire collection. The callback is bound to + * `thisArg` and invoked with three arguments; (value, index|key, collection). + * + * If a property name is provided for `callback` the created "_.pluck" style + * callback will return the property value of the given element. + * + * If an object is provided for `callback` the created "_.where" style callback + * will return `true` for elements that have the properties of the given object, + * else `false`. + * + * @static + * @memberOf _ + * @alias any + * @category Collections + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function|Object|string} [callback=identity] The function called + * per iteration. If a property name or object is provided it will be used + * to create a "_.pluck" or "_.where" style callback, respectively. + * @param {*} [thisArg] The `this` binding of `callback`. + * @returns {boolean} Returns `true` if any element passed the callback check, + * else `false`. + * @example + * + * _.some([null, 0, 'yes', false], Boolean); + * // => true + * + * var characters = [ + * { 'name': 'barney', 'age': 36, 'blocked': false }, + * { 'name': 'fred', 'age': 40, 'blocked': true } + * ]; + * + * // using "_.pluck" callback shorthand + * _.some(characters, 'blocked'); + * // => true + * + * // using "_.where" callback shorthand + * _.some(characters, { 'age': 1 }); + * // => false + */ +function some(collection, callback, thisArg) { + var result; + callback = createCallback(callback, thisArg, 3); + + if (isArray(collection)) { + var index = -1, + length = collection.length; + + while (++index < length) { + if ((result = callback(collection[index], index, collection))) { + break; + } + } + } else { + baseEach(collection, function(value, index, collection) { + return !(result = callback(value, index, collection)); + }); + } + return !!result; +} + +module.exports = some; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/collections/sortBy.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/collections/sortBy.js b/node_modules/lodash-node/compat/collections/sortBy.js new file mode 100644 index 0000000..777b152 --- /dev/null +++ b/node_modules/lodash-node/compat/collections/sortBy.js @@ -0,0 +1,101 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var compareAscending = require('../internals/compareAscending'), + createCallback = require('../functions/createCallback'), + forEach = require('./forEach'), + getArray = require('../internals/getArray'), + getObject = require('../internals/getObject'), + isArray = require('../objects/isArray'), + map = require('./map'), + releaseArray = require('../internals/releaseArray'), + releaseObject = require('../internals/releaseObject'); + +/** + * Creates an array of elements, sorted in ascending order by the results of + * running each element in a collection through the callback. This method + * performs a stable sort, that is, it will preserve the original sort order + * of equal elements. The callback is bound to `thisArg` and invoked with + * three arguments; (value, index|key, collection). + * + * If a property name is provided for `callback` the created "_.pluck" style + * callback will return the property value of the given element. + * + * If an array of property names is provided for `callback` the collection + * will be sorted by each property value. + * + * If an object is provided for `callback` the created "_.where" style callback + * will return `true` for elements that have the properties of the given object, + * else `false`. + * + * @static + * @memberOf _ + * @category Collections + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Array|Function|Object|string} [callback=identity] The function called + * per iteration. If a property name or object is provided it will be used + * to create a "_.pluck" or "_.where" style callback, respectively. + * @param {*} [thisArg] The `this` binding of `callback`. + * @returns {Array} Returns a new array of sorted elements. + * @example + * + * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); + * // => [3, 1, 2] + * + * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); + * // => [3, 1, 2] + * + * var characters = [ + * { 'name': 'barney', 'age': 36 }, + * { 'name': 'fred', 'age': 40 }, + * { 'name': 'barney', 'age': 26 }, + * { 'name': 'fred', 'age': 30 } + * ]; + * + * // using "_.pluck" callback shorthand + * _.map(_.sortBy(characters, 'age'), _.values); + * // => [['barney', 26], ['fred', 30], ['barney', 36], ['fred', 40]] + * + * // sorting by multiple properties + * _.map(_.sortBy(characters, ['name', 'age']), _.values); + * // = > [['barney', 26], ['barney', 36], ['fred', 30], ['fred', 40]] + */ +function sortBy(collection, callback, thisArg) { + var index = -1, + isArr = isArray(callback), + length = collection ? collection.length : 0, + result = Array(typeof length == 'number' ? length : 0); + + if (!isArr) { + callback = createCallback(callback, thisArg, 3); + } + forEach(collection, function(value, key, collection) { + var object = result[++index] = getObject(); + if (isArr) { + object.criteria = map(callback, function(key) { return value[key]; }); + } else { + (object.criteria = getArray())[0] = callback(value, key, collection); + } + object.index = index; + object.value = value; + }); + + length = result.length; + result.sort(compareAscending); + while (length--) { + var object = result[length]; + result[length] = object.value; + if (!isArr) { + releaseArray(object.criteria); + } + releaseObject(object); + } + return result; +} + +module.exports = sortBy; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/collections/toArray.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/collections/toArray.js b/node_modules/lodash-node/compat/collections/toArray.js new file mode 100644 index 0000000..223cf21 --- /dev/null +++ b/node_modules/lodash-node/compat/collections/toArray.js @@ -0,0 +1,36 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isString = require('../objects/isString'), + slice = require('../internals/slice'), + support = require('../support'), + values = require('../objects/values'); + +/** + * Converts the `collection` to an array. + * + * @static + * @memberOf _ + * @category Collections + * @param {Array|Object|string} collection The collection to convert. + * @returns {Array} Returns the new converted array. + * @example + * + * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); + * // => [2, 3, 4] + */ +function toArray(collection) { + if (collection && typeof collection.length == 'number') { + return (support.unindexedChars && isString(collection)) + ? collection.split('') + : slice(collection); + } + return values(collection); +} + +module.exports = toArray; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/collections/where.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/collections/where.js b/node_modules/lodash-node/compat/collections/where.js new file mode 100644 index 0000000..c035b72 --- /dev/null +++ b/node_modules/lodash-node/compat/collections/where.js @@ -0,0 +1,38 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var filter = require('./filter'); + +/** + * Performs a deep comparison of each element in a `collection` to the given + * `properties` object, returning an array of all elements that have equivalent + * property values. + * + * @static + * @memberOf _ + * @type Function + * @category Collections + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Object} props The object of property values to filter by. + * @returns {Array} Returns a new array of elements that have the given properties. + * @example + * + * var characters = [ + * { 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }, + * { 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] } + * ]; + * + * _.where(characters, { 'age': 36 }); + * // => [{ 'name': 'barney', 'age': 36, 'pets': ['hoppy'] }] + * + * _.where(characters, { 'pets': ['dino'] }); + * // => [{ 'name': 'fred', 'age': 40, 'pets': ['baby puss', 'dino'] }] + */ +var where = filter; + +module.exports = where; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions.js b/node_modules/lodash-node/compat/functions.js new file mode 100644 index 0000000..084bdd4 --- /dev/null +++ b/node_modules/lodash-node/compat/functions.js @@ -0,0 +1,27 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ + +module.exports = { + 'after': require('./functions/after'), + 'bind': require('./functions/bind'), + 'bindAll': require('./functions/bindAll'), + 'bindKey': require('./functions/bindKey'), + 'compose': require('./functions/compose'), + 'createCallback': require('./functions/createCallback'), + 'curry': require('./functions/curry'), + 'debounce': require('./functions/debounce'), + 'defer': require('./functions/defer'), + 'delay': require('./functions/delay'), + 'memoize': require('./functions/memoize'), + 'once': require('./functions/once'), + 'partial': require('./functions/partial'), + 'partialRight': require('./functions/partialRight'), + 'throttle': require('./functions/throttle'), + 'wrap': require('./functions/wrap') +}; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/after.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/after.js b/node_modules/lodash-node/compat/functions/after.js new file mode 100644 index 0000000..48ef88e --- /dev/null +++ b/node_modules/lodash-node/compat/functions/after.js @@ -0,0 +1,46 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'); + +/** + * Creates a function that executes `func`, with the `this` binding and + * arguments of the created function, only after being called `n` times. + * + * @static + * @memberOf _ + * @category Functions + * @param {number} n The number of times the function must be called before + * `func` is executed. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var saves = ['profile', 'settings']; + * + * var done = _.after(saves.length, function() { + * console.log('Done saving!'); + * }); + * + * _.forEach(saves, function(type) { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => logs 'Done saving!', after all saves have completed + */ +function after(n, func) { + if (!isFunction(func)) { + throw new TypeError; + } + return function() { + if (--n < 1) { + return func.apply(this, arguments); + } + }; +} + +module.exports = after; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/bind.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/bind.js b/node_modules/lodash-node/compat/functions/bind.js new file mode 100644 index 0000000..42284b3 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/bind.js @@ -0,0 +1,41 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createWrapper = require('../internals/createWrapper'), + slice = require('../internals/slice'), + support = require('../support'); + +/** + * Creates a function that, when called, invokes `func` with the `this` + * binding of `thisArg` and prepends any additional `bind` arguments to those + * provided to the bound function. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to bind. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {...*} [arg] Arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var func = function(greeting) { + * return greeting + ' ' + this.name; + * }; + * + * func = _.bind(func, { 'name': 'fred' }, 'hi'); + * func(); + * // => 'hi fred' + */ +function bind(func, thisArg) { + return arguments.length > 2 + ? createWrapper(func, 17, slice(arguments, 2), null, thisArg) + : createWrapper(func, 1, null, null, thisArg); +} + +module.exports = bind; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/bindAll.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/bindAll.js b/node_modules/lodash-node/compat/functions/bindAll.js new file mode 100644 index 0000000..f62d906 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/bindAll.js @@ -0,0 +1,49 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseFlatten = require('../internals/baseFlatten'), + createWrapper = require('../internals/createWrapper'), + functions = require('../objects/functions'); + +/** + * Binds methods of an object to the object itself, overwriting the existing + * method. Method names may be specified as individual arguments or as arrays + * of method names. If no method names are provided all the function properties + * of `object` will be bound. + * + * @static + * @memberOf _ + * @category Functions + * @param {Object} object The object to bind and assign the bound methods to. + * @param {...string} [methodName] The object method names to + * bind, specified as individual method names or arrays of method names. + * @returns {Object} Returns `object`. + * @example + * + * var view = { + * 'label': 'docs', + * 'onClick': function() { console.log('clicked ' + this.label); } + * }; + * + * _.bindAll(view); + * jQuery('#docs').on('click', view.onClick); + * // => logs 'clicked docs', when the button is clicked + */ +function bindAll(object) { + var funcs = arguments.length > 1 ? baseFlatten(arguments, true, false, 1) : functions(object), + index = -1, + length = funcs.length; + + while (++index < length) { + var key = funcs[index]; + object[key] = createWrapper(object[key], 1, null, null, object); + } + return object; +} + +module.exports = bindAll; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/bindKey.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/bindKey.js b/node_modules/lodash-node/compat/functions/bindKey.js new file mode 100644 index 0000000..7e07139 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/bindKey.js @@ -0,0 +1,52 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createWrapper = require('../internals/createWrapper'), + slice = require('../internals/slice'); + +/** + * Creates a function that, when called, invokes the method at `object[key]` + * and prepends any additional `bindKey` arguments to those provided to the bound + * function. This method differs from `_.bind` by allowing bound functions to + * reference methods that will be redefined or don't yet exist. + * See http://michaux.ca/articles/lazy-function-definition-pattern. + * + * @static + * @memberOf _ + * @category Functions + * @param {Object} object The object the method belongs to. + * @param {string} key The key of the method. + * @param {...*} [arg] Arguments to be partially applied. + * @returns {Function} Returns the new bound function. + * @example + * + * var object = { + * 'name': 'fred', + * 'greet': function(greeting) { + * return greeting + ' ' + this.name; + * } + * }; + * + * var func = _.bindKey(object, 'greet', 'hi'); + * func(); + * // => 'hi fred' + * + * object.greet = function(greeting) { + * return greeting + 'ya ' + this.name + '!'; + * }; + * + * func(); + * // => 'hiya fred!' + */ +function bindKey(object, key) { + return arguments.length > 2 + ? createWrapper(key, 19, slice(arguments, 2), null, object) + : createWrapper(key, 3, null, null, object); +} + +module.exports = bindKey; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/compose.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/compose.js b/node_modules/lodash-node/compat/functions/compose.js new file mode 100644 index 0000000..2a70d65 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/compose.js @@ -0,0 +1,61 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'); + +/** + * Creates a function that is the composition of the provided functions, + * where each function consumes the return value of the function that follows. + * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`. + * Each function is executed with the `this` binding of the composed function. + * + * @static + * @memberOf _ + * @category Functions + * @param {...Function} [func] Functions to compose. + * @returns {Function} Returns the new composed function. + * @example + * + * var realNameMap = { + * 'pebbles': 'penelope' + * }; + * + * var format = function(name) { + * name = realNameMap[name.toLowerCase()] || name; + * return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase(); + * }; + * + * var greet = function(formatted) { + * return 'Hiya ' + formatted + '!'; + * }; + * + * var welcome = _.compose(greet, format); + * welcome('pebbles'); + * // => 'Hiya Penelope!' + */ +function compose() { + var funcs = arguments, + length = funcs.length; + + while (length--) { + if (!isFunction(funcs[length])) { + throw new TypeError; + } + } + return function() { + var args = arguments, + length = funcs.length; + + while (length--) { + args = [funcs[length].apply(this, args)]; + } + return args[0]; + }; +} + +module.exports = compose; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/createCallback.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/createCallback.js b/node_modules/lodash-node/compat/functions/createCallback.js new file mode 100644 index 0000000..460b80e --- /dev/null +++ b/node_modules/lodash-node/compat/functions/createCallback.js @@ -0,0 +1,81 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseCreateCallback = require('../internals/baseCreateCallback'), + baseIsEqual = require('../internals/baseIsEqual'), + isObject = require('../objects/isObject'), + keys = require('../objects/keys'), + property = require('../utilities/property'); + +/** + * Produces a callback bound to an optional `thisArg`. If `func` is a property + * name the created callback will return the property value for a given element. + * If `func` is an object the created callback will return `true` for elements + * that contain the equivalent object properties, otherwise it will return `false`. + * + * @static + * @memberOf _ + * @category Utilities + * @param {*} [func=identity] The value to convert to a callback. + * @param {*} [thisArg] The `this` binding of the created callback. + * @param {number} [argCount] The number of arguments the callback accepts. + * @returns {Function} Returns a callback function. + * @example + * + * var characters = [ + * { 'name': 'barney', 'age': 36 }, + * { 'name': 'fred', 'age': 40 } + * ]; + * + * // wrap to create custom callback shorthands + * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) { + * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback); + * return !match ? func(callback, thisArg) : function(object) { + * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3]; + * }; + * }); + * + * _.filter(characters, 'age__gt38'); + * // => [{ 'name': 'fred', 'age': 40 }] + */ +function createCallback(func, thisArg, argCount) { + var type = typeof func; + if (func == null || type == 'function') { + return baseCreateCallback(func, thisArg, argCount); + } + // handle "_.pluck" style callback shorthands + if (type != 'object') { + return property(func); + } + var props = keys(func), + key = props[0], + a = func[key]; + + // handle "_.where" style callback shorthands + if (props.length == 1 && a === a && !isObject(a)) { + // fast path the common case of providing an object with a single + // property containing a primitive value + return function(object) { + var b = object[key]; + return a === b && (a !== 0 || (1 / a == 1 / b)); + }; + } + return function(object) { + var length = props.length, + result = false; + + while (length--) { + if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) { + break; + } + } + return result; + }; +} + +module.exports = createCallback; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/curry.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/curry.js b/node_modules/lodash-node/compat/functions/curry.js new file mode 100644 index 0000000..77fb780 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/curry.js @@ -0,0 +1,44 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createWrapper = require('../internals/createWrapper'); + +/** + * Creates a function which accepts one or more arguments of `func` that when + * invoked either executes `func` returning its result, if all `func` arguments + * have been provided, or returns a function that accepts one or more of the + * remaining `func` arguments, and so on. The arity of `func` can be specified + * if `func.length` is not sufficient. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to curry. + * @param {number} [arity=func.length] The arity of `func`. + * @returns {Function} Returns the new curried function. + * @example + * + * var curried = _.curry(function(a, b, c) { + * console.log(a + b + c); + * }); + * + * curried(1)(2)(3); + * // => 6 + * + * curried(1, 2)(3); + * // => 6 + * + * curried(1, 2, 3); + * // => 6 + */ +function curry(func, arity) { + arity = typeof arity == 'number' ? arity : (+arity || func.length); + return createWrapper(func, 4, null, null, null, arity); +} + +module.exports = curry; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/debounce.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/debounce.js b/node_modules/lodash-node/compat/functions/debounce.js new file mode 100644 index 0000000..6bc27f4 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/debounce.js @@ -0,0 +1,156 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'), + isObject = require('../objects/isObject'), + now = require('../utilities/now'); + +/* Native method shortcuts for methods with the same name as other `lodash` methods */ +var nativeMax = Math.max; + +/** + * Creates a function that will delay the execution of `func` until after + * `wait` milliseconds have elapsed since the last time it was invoked. + * Provide an options object to indicate that `func` should be invoked on + * the leading and/or trailing edge of the `wait` timeout. Subsequent calls + * to the debounced function will return the result of the last `func` call. + * + * Note: If `leading` and `trailing` options are `true` `func` will be called + * on the trailing edge of the timeout only if the the debounced function is + * invoked more than once during the `wait` timeout. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to debounce. + * @param {number} wait The number of milliseconds to delay. + * @param {Object} [options] The options object. + * @param {boolean} [options.leading=false] Specify execution on the leading edge of the timeout. + * @param {number} [options.maxWait] The maximum time `func` is allowed to be delayed before it's called. + * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // avoid costly calculations while the window size is in flux + * var lazyLayout = _.debounce(calculateLayout, 150); + * jQuery(window).on('resize', lazyLayout); + * + * // execute `sendMail` when the click event is fired, debouncing subsequent calls + * jQuery('#postbox').on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * }); + * + * // ensure `batchLog` is executed once after 1 second of debounced calls + * var source = new EventSource('/stream'); + * source.addEventListener('message', _.debounce(batchLog, 250, { + * 'maxWait': 1000 + * }, false); + */ +function debounce(func, wait, options) { + var args, + maxTimeoutId, + result, + stamp, + thisArg, + timeoutId, + trailingCall, + lastCalled = 0, + maxWait = false, + trailing = true; + + if (!isFunction(func)) { + throw new TypeError; + } + wait = nativeMax(0, wait) || 0; + if (options === true) { + var leading = true; + trailing = false; + } else if (isObject(options)) { + leading = options.leading; + maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0); + trailing = 'trailing' in options ? options.trailing : trailing; + } + var delayed = function() { + var remaining = wait - (now() - stamp); + if (remaining <= 0) { + if (maxTimeoutId) { + clearTimeout(maxTimeoutId); + } + var isCalled = trailingCall; + maxTimeoutId = timeoutId = trailingCall = undefined; + if (isCalled) { + lastCalled = now(); + result = func.apply(thisArg, args); + if (!timeoutId && !maxTimeoutId) { + args = thisArg = null; + } + } + } else { + timeoutId = setTimeout(delayed, remaining); + } + }; + + var maxDelayed = function() { + if (timeoutId) { + clearTimeout(timeoutId); + } + maxTimeoutId = timeoutId = trailingCall = undefined; + if (trailing || (maxWait !== wait)) { + lastCalled = now(); + result = func.apply(thisArg, args); + if (!timeoutId && !maxTimeoutId) { + args = thisArg = null; + } + } + }; + + return function() { + args = arguments; + stamp = now(); + thisArg = this; + trailingCall = trailing && (timeoutId || !leading); + + if (maxWait === false) { + var leadingCall = leading && !timeoutId; + } else { + if (!maxTimeoutId && !leading) { + lastCalled = stamp; + } + var remaining = maxWait - (stamp - lastCalled), + isCalled = remaining <= 0; + + if (isCalled) { + if (maxTimeoutId) { + maxTimeoutId = clearTimeout(maxTimeoutId); + } + lastCalled = stamp; + result = func.apply(thisArg, args); + } + else if (!maxTimeoutId) { + maxTimeoutId = setTimeout(maxDelayed, remaining); + } + } + if (isCalled && timeoutId) { + timeoutId = clearTimeout(timeoutId); + } + else if (!timeoutId && wait !== maxWait) { + timeoutId = setTimeout(delayed, wait); + } + if (leadingCall) { + isCalled = true; + result = func.apply(thisArg, args); + } + if (isCalled && !timeoutId && !maxTimeoutId) { + args = thisArg = null; + } + return result; + }; +} + +module.exports = debounce; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/defer.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/defer.js b/node_modules/lodash-node/compat/functions/defer.js new file mode 100644 index 0000000..7a7bf32 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/defer.js @@ -0,0 +1,35 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'), + slice = require('../internals/slice'); + +/** + * Defers executing the `func` function until the current call stack has cleared. + * Additional arguments will be provided to `func` when it is invoked. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to defer. + * @param {...*} [arg] Arguments to invoke the function with. + * @returns {number} Returns the timer id. + * @example + * + * _.defer(function(text) { console.log(text); }, 'deferred'); + * // logs 'deferred' after one or more milliseconds + */ +function defer(func) { + if (!isFunction(func)) { + throw new TypeError; + } + var args = slice(arguments, 1); + return setTimeout(function() { func.apply(undefined, args); }, 1); +} + +module.exports = defer; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/delay.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/delay.js b/node_modules/lodash-node/compat/functions/delay.js new file mode 100644 index 0000000..5a466ae --- /dev/null +++ b/node_modules/lodash-node/compat/functions/delay.js @@ -0,0 +1,36 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'), + slice = require('../internals/slice'); + +/** + * Executes the `func` function after `wait` milliseconds. Additional arguments + * will be provided to `func` when it is invoked. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to delay. + * @param {number} wait The number of milliseconds to delay execution. + * @param {...*} [arg] Arguments to invoke the function with. + * @returns {number} Returns the timer id. + * @example + * + * _.delay(function(text) { console.log(text); }, 1000, 'later'); + * // => logs 'later' after one second + */ +function delay(func, wait) { + if (!isFunction(func)) { + throw new TypeError; + } + var args = slice(arguments, 2); + return setTimeout(function() { func.apply(undefined, args); }, wait); +} + +module.exports = delay; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/memoize.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/memoize.js b/node_modules/lodash-node/compat/functions/memoize.js new file mode 100644 index 0000000..4ba8192 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/memoize.js @@ -0,0 +1,71 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'), + keyPrefix = require('../internals/keyPrefix'); + +/** Used for native method references */ +var objectProto = Object.prototype; + +/** Native method shortcuts */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided it will be used to determine the cache key for storing the result + * based on the arguments provided to the memoized function. By default, the + * first argument provided to the memoized function is used as the cache key. + * The `func` is executed with the `this` binding of the memoized function. + * The result cache is exposed as the `cache` property on the memoized function. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] A function used to resolve the cache key. + * @returns {Function} Returns the new memoizing function. + * @example + * + * var fibonacci = _.memoize(function(n) { + * return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); + * }); + * + * fibonacci(9) + * // => 34 + * + * var data = { + * 'fred': { 'name': 'fred', 'age': 40 }, + * 'pebbles': { 'name': 'pebbles', 'age': 1 } + * }; + * + * // modifying the result cache + * var get = _.memoize(function(name) { return data[name]; }, _.identity); + * get('pebbles'); + * // => { 'name': 'pebbles', 'age': 1 } + * + * get.cache.pebbles.name = 'penelope'; + * get('pebbles'); + * // => { 'name': 'penelope', 'age': 1 } + */ +function memoize(func, resolver) { + if (!isFunction(func)) { + throw new TypeError; + } + var memoized = function() { + var cache = memoized.cache, + key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0]; + + return hasOwnProperty.call(cache, key) + ? cache[key] + : (cache[key] = func.apply(this, arguments)); + } + memoized.cache = {}; + return memoized; +} + +module.exports = memoize; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/once.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/once.js b/node_modules/lodash-node/compat/functions/once.js new file mode 100644 index 0000000..6409810 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/once.js @@ -0,0 +1,48 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isFunction = require('../objects/isFunction'); + +/** + * Creates a function that is restricted to execute `func` once. Repeat calls to + * the function will return the value of the first call. The `func` is executed + * with the `this` binding of the created function. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new restricted function. + * @example + * + * var initialize = _.once(createApplication); + * initialize(); + * initialize(); + * // `initialize` executes `createApplication` once + */ +function once(func) { + var ran, + result; + + if (!isFunction(func)) { + throw new TypeError; + } + return function() { + if (ran) { + return result; + } + ran = true; + result = func.apply(this, arguments); + + // clear the `func` variable so the function may be garbage collected + func = null; + return result; + }; +} + +module.exports = once; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/partial.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/partial.js b/node_modules/lodash-node/compat/functions/partial.js new file mode 100644 index 0000000..64ff0ee --- /dev/null +++ b/node_modules/lodash-node/compat/functions/partial.js @@ -0,0 +1,34 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createWrapper = require('../internals/createWrapper'), + slice = require('../internals/slice'); + +/** + * Creates a function that, when called, invokes `func` with any additional + * `partial` arguments prepended to those provided to the new function. This + * method is similar to `_.bind` except it does **not** alter the `this` binding. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [arg] Arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * var greet = function(greeting, name) { return greeting + ' ' + name; }; + * var hi = _.partial(greet, 'hi'); + * hi('fred'); + * // => 'hi fred' + */ +function partial(func) { + return createWrapper(func, 16, slice(arguments, 1)); +} + +module.exports = partial; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/partialRight.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/partialRight.js b/node_modules/lodash-node/compat/functions/partialRight.js new file mode 100644 index 0000000..3028819 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/partialRight.js @@ -0,0 +1,43 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createWrapper = require('../internals/createWrapper'), + slice = require('../internals/slice'); + +/** + * This method is like `_.partial` except that `partial` arguments are + * appended to those provided to the new function. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to partially apply arguments to. + * @param {...*} [arg] Arguments to be partially applied. + * @returns {Function} Returns the new partially applied function. + * @example + * + * var defaultsDeep = _.partialRight(_.merge, _.defaults); + * + * var options = { + * 'variable': 'data', + * 'imports': { 'jq': $ } + * }; + * + * defaultsDeep(options, _.templateSettings); + * + * options.variable + * // => 'data' + * + * options.imports + * // => { '_': _, 'jq': $ } + */ +function partialRight(func) { + return createWrapper(func, 32, null, slice(arguments, 1)); +} + +module.exports = partialRight; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/throttle.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/throttle.js b/node_modules/lodash-node/compat/functions/throttle.js new file mode 100644 index 0000000..8300c65 --- /dev/null +++ b/node_modules/lodash-node/compat/functions/throttle.js @@ -0,0 +1,71 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var debounce = require('./debounce'), + isFunction = require('../objects/isFunction'), + isObject = require('../objects/isObject'); + +/** Used as an internal `_.debounce` options object */ +var debounceOptions = { + 'leading': false, + 'maxWait': 0, + 'trailing': false +}; + +/** + * Creates a function that, when executed, will only call the `func` function + * at most once per every `wait` milliseconds. Provide an options object to + * indicate that `func` should be invoked on the leading and/or trailing edge + * of the `wait` timeout. Subsequent calls to the throttled function will + * return the result of the last `func` call. + * + * Note: If `leading` and `trailing` options are `true` `func` will be called + * on the trailing edge of the timeout only if the the throttled function is + * invoked more than once during the `wait` timeout. + * + * @static + * @memberOf _ + * @category Functions + * @param {Function} func The function to throttle. + * @param {number} wait The number of milliseconds to throttle executions to. + * @param {Object} [options] The options object. + * @param {boolean} [options.leading=true] Specify execution on the leading edge of the timeout. + * @param {boolean} [options.trailing=true] Specify execution on the trailing edge of the timeout. + * @returns {Function} Returns the new throttled function. + * @example + * + * // avoid excessively updating the position while scrolling + * var throttled = _.throttle(updatePosition, 100); + * jQuery(window).on('scroll', throttled); + * + * // execute `renewToken` when the click event is fired, but not more than once every 5 minutes + * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, { + * 'trailing': false + * })); + */ +function throttle(func, wait, options) { + var leading = true, + trailing = true; + + if (!isFunction(func)) { + throw new TypeError; + } + if (options === false) { + leading = false; + } else if (isObject(options)) { + leading = 'leading' in options ? options.leading : leading; + trailing = 'trailing' in options ? options.trailing : trailing; + } + debounceOptions.leading = leading; + debounceOptions.maxWait = wait; + debounceOptions.trailing = trailing; + + return debounce(func, wait, debounceOptions); +} + +module.exports = throttle; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/functions/wrap.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/functions/wrap.js b/node_modules/lodash-node/compat/functions/wrap.js new file mode 100644 index 0000000..9168ffc --- /dev/null +++ b/node_modules/lodash-node/compat/functions/wrap.js @@ -0,0 +1,36 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createWrapper = require('../internals/createWrapper'); + +/** + * Creates a function that provides `value` to the wrapper function as its + * first argument. Additional arguments provided to the function are appended + * to those provided to the wrapper function. The wrapper is executed with + * the `this` binding of the created function. + * + * @static + * @memberOf _ + * @category Functions + * @param {*} value The value to wrap. + * @param {Function} wrapper The wrapper function. + * @returns {Function} Returns the new function. + * @example + * + * var p = _.wrap(_.escape, function(func, text) { + * return '<p>' + func(text) + '</p>'; + * }); + * + * p('Fred, Wilma, & Pebbles'); + * // => '<p>Fred, Wilma, & Pebbles</p>' + */ +function wrap(value, wrapper) { + return createWrapper(wrapper, 16, [value]); +} + +module.exports = wrap; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/index.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/index.js b/node_modules/lodash-node/compat/index.js new file mode 100644 index 0000000..cbea241 --- /dev/null +++ b/node_modules/lodash-node/compat/index.js @@ -0,0 +1,376 @@ +/** + * @license + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var arrays = require('./arrays'), + chaining = require('./chaining'), + collections = require('./collections'), + functions = require('./functions'), + objects = require('./objects'), + utilities = require('./utilities'), + baseEach = require('./internals/baseEach'), + forOwn = require('./objects/forOwn'), + isArray = require('./objects/isArray'), + lodashWrapper = require('./internals/lodashWrapper'), + mixin = require('./utilities/mixin'), + support = require('./support'), + templateSettings = require('./utilities/templateSettings'); + +/** + * Used for `Array` method references. + * + * Normally `Array.prototype` would suffice, however, using an array literal + * avoids issues in Narwhal. + */ +var arrayRef = []; + +/** Used for native method references */ +var objectProto = Object.prototype; + +/** Native method shortcuts */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Creates a `lodash` object which wraps the given value to enable intuitive + * method chaining. + * + * In addition to Lo-Dash methods, wrappers also have the following `Array` methods: + * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`, + * and `unshift` + * + * Chaining is supported in custom builds as long as the `value` method is + * implicitly or explicitly included in the build. + * + * The chainable wrapper functions are: + * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, + * `compose`, `concat`, `countBy`, `create`, `createCallback`, `curry`, + * `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`, + * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`, + * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`, + * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`, + * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `pull`, `push`, + * `range`, `reject`, `remove`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, + * `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `transform`, + * `union`, `uniq`, `unshift`, `unzip`, `values`, `where`, `without`, `wrap`, + * and `zip` + * + * The non-chainable wrapper functions are: + * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `findIndex`, + * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `has`, `identity`, + * `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, + * `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`, + * `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, + * `lastIndexOf`, `mixin`, `noConflict`, `parseInt`, `pop`, `random`, `reduce`, + * `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `runInContext`, + * `template`, `unescape`, `uniqueId`, and `value` + * + * The wrapper functions `first` and `last` return wrapped values when `n` is + * provided, otherwise they return unwrapped values. + * + * Explicit chaining can be enabled by using the `_.chain` method. + * + * @name _ + * @constructor + * @category Chaining + * @param {*} value The value to wrap in a `lodash` instance. + * @returns {Object} Returns a `lodash` instance. + * @example + * + * var wrapped = _([1, 2, 3]); + * + * // returns an unwrapped value + * wrapped.reduce(function(sum, num) { + * return sum + num; + * }); + * // => 6 + * + * // returns a wrapped value + * var squares = wrapped.map(function(num) { + * return num * num; + * }); + * + * _.isArray(squares); + * // => false + * + * _.isArray(squares.value()); + * // => true + */ +function lodash(value) { + // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor + return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__')) + ? value + : new lodashWrapper(value); +} +// ensure `new lodashWrapper` is an instance of `lodash` +lodashWrapper.prototype = lodash.prototype; + +// wrap `_.mixin` so it works when provided only one argument +mixin = (function(fn) { + var functions = objects.functions; + return function(object, source, options) { + if (!source || (!options && !functions(source).length)) { + if (options == null) { + options = source; + } + source = object; + object = lodash; + } + return fn(object, source, options); + }; +}(mixin)); + +// add functions that return wrapped values when chaining +lodash.after = functions.after; +lodash.assign = objects.assign; +lodash.at = collections.at; +lodash.bind = functions.bind; +lodash.bindAll = functions.bindAll; +lodash.bindKey = functions.bindKey; +lodash.chain = chaining.chain; +lodash.compact = arrays.compact; +lodash.compose = functions.compose; +lodash.constant = utilities.constant; +lodash.countBy = collections.countBy; +lodash.create = objects.create; +lodash.createCallback = functions.createCallback; +lodash.curry = functions.curry; +lodash.debounce = functions.debounce; +lodash.defaults = objects.defaults; +lodash.defer = functions.defer; +lodash.delay = functions.delay; +lodash.difference = arrays.difference; +lodash.filter = collections.filter; +lodash.flatten = arrays.flatten; +lodash.forEach = collections.forEach; +lodash.forEachRight = collections.forEachRight; +lodash.forIn = objects.forIn; +lodash.forInRight = objects.forInRight; +lodash.forOwn = forOwn; +lodash.forOwnRight = objects.forOwnRight; +lodash.functions = objects.functions; +lodash.groupBy = collections.groupBy; +lodash.indexBy = collections.indexBy; +lodash.initial = arrays.initial; +lodash.intersection = arrays.intersection; +lodash.invert = objects.invert; +lodash.invoke = collections.invoke; +lodash.keys = objects.keys; +lodash.map = collections.map; +lodash.mapValues = objects.mapValues; +lodash.max = collections.max; +lodash.memoize = functions.memoize; +lodash.merge = objects.merge; +lodash.min = collections.min; +lodash.omit = objects.omit; +lodash.once = functions.once; +lodash.pairs = objects.pairs; +lodash.partial = functions.partial; +lodash.partialRight = functions.partialRight; +lodash.pick = objects.pick; +lodash.pluck = collections.pluck; +lodash.property = utilities.property; +lodash.pull = arrays.pull; +lodash.range = arrays.range; +lodash.reject = collections.reject; +lodash.remove = arrays.remove; +lodash.rest = arrays.rest; +lodash.shuffle = collections.shuffle; +lodash.sortBy = collections.sortBy; +lodash.tap = chaining.tap; +lodash.throttle = functions.throttle; +lodash.times = utilities.times; +lodash.toArray = collections.toArray; +lodash.transform = objects.transform; +lodash.union = arrays.union; +lodash.uniq = arrays.uniq; +lodash.values = objects.values; +lodash.where = collections.where; +lodash.without = arrays.without; +lodash.wrap = functions.wrap; +lodash.xor = arrays.xor; +lodash.zip = arrays.zip; +lodash.zipObject = arrays.zipObject; + +// add aliases +lodash.collect = collections.map; +lodash.drop = arrays.rest; +lodash.each = collections.forEach; +lodash.eachRight = collections.forEachRight; +lodash.extend = objects.assign; +lodash.methods = objects.functions; +lodash.object = arrays.zipObject; +lodash.select = collections.filter; +lodash.tail = arrays.rest; +lodash.unique = arrays.uniq; +lodash.unzip = arrays.zip; + +// add functions to `lodash.prototype` +mixin(lodash); + +// add functions that return unwrapped values when chaining +lodash.clone = objects.clone; +lodash.cloneDeep = objects.cloneDeep; +lodash.contains = collections.contains; +lodash.escape = utilities.escape; +lodash.every = collections.every; +lodash.find = collections.find; +lodash.findIndex = arrays.findIndex; +lodash.findKey = objects.findKey; +lodash.findLast = collections.findLast; +lodash.findLastIndex = arrays.findLastIndex; +lodash.findLastKey = objects.findLastKey; +lodash.has = objects.has; +lodash.identity = utilities.identity; +lodash.indexOf = arrays.indexOf; +lodash.isArguments = objects.isArguments; +lodash.isArray = isArray; +lodash.isBoolean = objects.isBoolean; +lodash.isDate = objects.isDate; +lodash.isElement = objects.isElement; +lodash.isEmpty = objects.isEmpty; +lodash.isEqual = objects.isEqual; +lodash.isFinite = objects.isFinite; +lodash.isFunction = objects.isFunction; +lodash.isNaN = objects.isNaN; +lodash.isNull = objects.isNull; +lodash.isNumber = objects.isNumber; +lodash.isObject = objects.isObject; +lodash.isPlainObject = objects.isPlainObject; +lodash.isRegExp = objects.isRegExp; +lodash.isString = objects.isString; +lodash.isUndefined = objects.isUndefined; +lodash.lastIndexOf = arrays.lastIndexOf; +lodash.mixin = mixin; +lodash.noConflict = utilities.noConflict; +lodash.noop = utilities.noop; +lodash.now = utilities.now; +lodash.parseInt = utilities.parseInt; +lodash.random = utilities.random; +lodash.reduce = collections.reduce; +lodash.reduceRight = collections.reduceRight; +lodash.result = utilities.result; +lodash.size = collections.size; +lodash.some = collections.some; +lodash.sortedIndex = arrays.sortedIndex; +lodash.template = utilities.template; +lodash.unescape = utilities.unescape; +lodash.uniqueId = utilities.uniqueId; + +// add aliases +lodash.all = collections.every; +lodash.any = collections.some; +lodash.detect = collections.find; +lodash.findWhere = collections.find; +lodash.foldl = collections.reduce; +lodash.foldr = collections.reduceRight; +lodash.include = collections.contains; +lodash.inject = collections.reduce; + +mixin(function() { + var source = {} + forOwn(lodash, function(func, methodName) { + if (!lodash.prototype[methodName]) { + source[methodName] = func; + } + }); + return source; +}(), false); + +// add functions capable of returning wrapped and unwrapped values when chaining +lodash.first = arrays.first; +lodash.last = arrays.last; +lodash.sample = collections.sample; + +// add aliases +lodash.take = arrays.first; +lodash.head = arrays.first; + +forOwn(lodash, function(func, methodName) { + var callbackable = methodName !== 'sample'; + if (!lodash.prototype[methodName]) { + lodash.prototype[methodName]= function(n, guard) { + var chainAll = this.__chain__, + result = func(this.__wrapped__, n, guard); + + return !chainAll && (n == null || (guard && !(callbackable && typeof n == 'function'))) + ? result + : new lodashWrapper(result, chainAll); + }; + } +}); + +/** + * The semantic version number. + * + * @static + * @memberOf _ + * @type string + */ +lodash.VERSION = '2.4.1'; + +// add "Chaining" functions to the wrapper +lodash.prototype.chain = chaining.wrapperChain; +lodash.prototype.toString = chaining.wrapperToString; +lodash.prototype.value = chaining.wrapperValueOf; +lodash.prototype.valueOf = chaining.wrapperValueOf; + +// add `Array` functions that return unwrapped values +baseEach(['join', 'pop', 'shift'], function(methodName) { + var func = arrayRef[methodName]; + lodash.prototype[methodName] = function() { + var chainAll = this.__chain__, + result = func.apply(this.__wrapped__, arguments); + + return chainAll + ? new lodashWrapper(result, chainAll) + : result; + }; +}); + +// add `Array` functions that return the existing wrapped value +baseEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) { + var func = arrayRef[methodName]; + lodash.prototype[methodName] = function() { + func.apply(this.__wrapped__, arguments); + return this; + }; +}); + +// add `Array` functions that return new wrapped values +baseEach(['concat', 'slice', 'splice'], function(methodName) { + var func = arrayRef[methodName]; + lodash.prototype[methodName] = function() { + return new lodashWrapper(func.apply(this.__wrapped__, arguments), this.__chain__); + }; +}); + +// avoid array-like object bugs with `Array#shift` and `Array#splice` +// in IE < 9, Firefox < 10, Narwhal, and RingoJS +if (!support.spliceObjects) { + baseEach(['pop', 'shift', 'splice'], function(methodName) { + var func = arrayRef[methodName], + isSplice = methodName == 'splice'; + + lodash.prototype[methodName] = function() { + var chainAll = this.__chain__, + value = this.__wrapped__, + result = func.apply(value, arguments); + + if (value.length === 0) { + delete value[0]; + } + return (chainAll || isSplice) + ? new lodashWrapper(result, chainAll) + : result; + }; + }); +} + +lodash.support = support; +(lodash.templateSettings = utilities.templateSettings).imports._ = lodash; +module.exports = lodash; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/arrayPool.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/arrayPool.js b/node_modules/lodash-node/compat/internals/arrayPool.js new file mode 100644 index 0000000..56e34e5 --- /dev/null +++ b/node_modules/lodash-node/compat/internals/arrayPool.js @@ -0,0 +1,13 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ + +/** Used to pool arrays and objects used internally */ +var arrayPool = []; + +module.exports = arrayPool; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseBind.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseBind.js b/node_modules/lodash-node/compat/internals/baseBind.js new file mode 100644 index 0000000..5e328f7 --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseBind.js @@ -0,0 +1,62 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseCreate = require('./baseCreate'), + isObject = require('../objects/isObject'), + setBindData = require('./setBindData'), + slice = require('./slice'); + +/** + * Used for `Array` method references. + * + * Normally `Array.prototype` would suffice, however, using an array literal + * avoids issues in Narwhal. + */ +var arrayRef = []; + +/** Native method shortcuts */ +var push = arrayRef.push; + +/** + * The base implementation of `_.bind` that creates the bound function and + * sets its meta data. + * + * @private + * @param {Array} bindData The bind data array. + * @returns {Function} Returns the new bound function. + */ +function baseBind(bindData) { + var func = bindData[0], + partialArgs = bindData[2], + thisArg = bindData[4]; + + function bound() { + // `Function#bind` spec + // http://es5.github.io/#x15.3.4.5 + if (partialArgs) { + // avoid `arguments` object deoptimizations by using `slice` instead + // of `Array.prototype.slice.call` and not assigning `arguments` to a + // variable as a ternary expression + var args = slice(partialArgs); + push.apply(args, arguments); + } + // mimic the constructor's `return` behavior + // http://es5.github.io/#x13.2.2 + if (this instanceof bound) { + // ensure `new bound` is an instance of `func` + var thisBinding = baseCreate(func.prototype), + result = func.apply(thisBinding, args || arguments); + return isObject(result) ? result : thisBinding; + } + return func.apply(thisArg, args || arguments); + } + setBindData(bound, bindData); + return bound; +} + +module.exports = baseBind; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseClone.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseClone.js b/node_modules/lodash-node/compat/internals/baseClone.js new file mode 100644 index 0000000..fa262bf --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseClone.js @@ -0,0 +1,154 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var assign = require('../objects/assign'), + baseEach = require('./baseEach'), + forOwn = require('../objects/forOwn'), + getArray = require('./getArray'), + isArray = require('../objects/isArray'), + isNode = require('./isNode'), + isObject = require('../objects/isObject'), + releaseArray = require('./releaseArray'), + slice = require('./slice'), + support = require('../support'); + +/** Used to match regexp flags from their coerced string values */ +var reFlags = /\w*$/; + +/** `Object#toString` result shortcuts */ +var argsClass = '[object Arguments]', + arrayClass = '[object Array]', + boolClass = '[object Boolean]', + dateClass = '[object Date]', + funcClass = '[object Function]', + numberClass = '[object Number]', + objectClass = '[object Object]', + regexpClass = '[object RegExp]', + stringClass = '[object String]'; + +/** Used to identify object classifications that `_.clone` supports */ +var cloneableClasses = {}; +cloneableClasses[funcClass] = false; +cloneableClasses[argsClass] = cloneableClasses[arrayClass] = +cloneableClasses[boolClass] = cloneableClasses[dateClass] = +cloneableClasses[numberClass] = cloneableClasses[objectClass] = +cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true; + +/** Used for native method references */ +var objectProto = Object.prototype; + +/** Used to resolve the internal [[Class]] of values */ +var toString = objectProto.toString; + +/** Native method shortcuts */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** Used to lookup a built-in constructor by [[Class]] */ +var ctorByClass = {}; +ctorByClass[arrayClass] = Array; +ctorByClass[boolClass] = Boolean; +ctorByClass[dateClass] = Date; +ctorByClass[funcClass] = Function; +ctorByClass[objectClass] = Object; +ctorByClass[numberClass] = Number; +ctorByClass[regexpClass] = RegExp; +ctorByClass[stringClass] = String; + +/** + * The base implementation of `_.clone` without argument juggling or support + * for `thisArg` binding. + * + * @private + * @param {*} value The value to clone. + * @param {boolean} [isDeep=false] Specify a deep clone. + * @param {Function} [callback] The function to customize cloning values. + * @param {Array} [stackA=[]] Tracks traversed source objects. + * @param {Array} [stackB=[]] Associates clones with source counterparts. + * @returns {*} Returns the cloned value. + */ +function baseClone(value, isDeep, callback, stackA, stackB) { + if (callback) { + var result = callback(value); + if (typeof result != 'undefined') { + return result; + } + } + // inspect [[Class]] + var isObj = isObject(value); + if (isObj) { + var className = toString.call(value); + if (!cloneableClasses[className] || (!support.nodeClass && isNode(value))) { + return value; + } + var ctor = ctorByClass[className]; + switch (className) { + case boolClass: + case dateClass: + return new ctor(+value); + + case numberClass: + case stringClass: + return new ctor(value); + + case regexpClass: + result = ctor(value.source, reFlags.exec(value)); + result.lastIndex = value.lastIndex; + return result; + } + } else { + return value; + } + var isArr = isArray(value); + if (isDeep) { + // check for circular references and return corresponding clone + var initedStack = !stackA; + stackA || (stackA = getArray()); + stackB || (stackB = getArray()); + + var length = stackA.length; + while (length--) { + if (stackA[length] == value) { + return stackB[length]; + } + } + result = isArr ? ctor(value.length) : {}; + } + else { + result = isArr ? slice(value) : assign({}, value); + } + // add array properties assigned by `RegExp#exec` + if (isArr) { + if (hasOwnProperty.call(value, 'index')) { + result.index = value.index; + } + if (hasOwnProperty.call(value, 'input')) { + result.input = value.input; + } + } + // exit for shallow clone + if (!isDeep) { + return result; + } + // add the source value to the stack of traversed objects + // and associate it with its clone + stackA.push(value); + stackB.push(result); + + // recursively populate clone (susceptible to call stack limits) + (isArr ? baseEach : forOwn)(value, function(objValue, key) { + result[key] = baseClone(objValue, isDeep, callback, stackA, stackB); + }); + + if (initedStack) { + releaseArray(stackA); + releaseArray(stackB); + } + return result; +} + +module.exports = baseClone; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseCreate.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseCreate.js b/node_modules/lodash-node/compat/internals/baseCreate.js new file mode 100644 index 0000000..90fcd68 --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseCreate.js @@ -0,0 +1,42 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var isNative = require('./isNative'), + isObject = require('../objects/isObject'), + noop = require('../utilities/noop'); + +/* Native method shortcuts for methods with the same name as other `lodash` methods */ +var nativeCreate = isNative(nativeCreate = Object.create) && nativeCreate; + +/** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} prototype The object to inherit from. + * @returns {Object} Returns the new object. + */ +function baseCreate(prototype, properties) { + return isObject(prototype) ? nativeCreate(prototype) : {}; +} +// fallback for browsers without `Object.create` +if (!nativeCreate) { + baseCreate = (function() { + function Object() {} + return function(prototype) { + if (isObject(prototype)) { + Object.prototype = prototype; + var result = new Object; + Object.prototype = null; + } + return result || global.Object(); + }; + }()); +} + +module.exports = baseCreate; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseCreateCallback.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseCreateCallback.js b/node_modules/lodash-node/compat/internals/baseCreateCallback.js new file mode 100644 index 0000000..cb9657b --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseCreateCallback.js @@ -0,0 +1,80 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var bind = require('../functions/bind'), + identity = require('../utilities/identity'), + setBindData = require('./setBindData'), + support = require('../support'); + +/** Used to detected named functions */ +var reFuncName = /^\s*function[ \n\r\t]+\w/; + +/** Used to detect functions containing a `this` reference */ +var reThis = /\bthis\b/; + +/** Native method shortcuts */ +var fnToString = Function.prototype.toString; + +/** + * The base implementation of `_.createCallback` without support for creating + * "_.pluck" or "_.where" style callbacks. + * + * @private + * @param {*} [func=identity] The value to convert to a callback. + * @param {*} [thisArg] The `this` binding of the created callback. + * @param {number} [argCount] The number of arguments the callback accepts. + * @returns {Function} Returns a callback function. + */ +function baseCreateCallback(func, thisArg, argCount) { + if (typeof func != 'function') { + return identity; + } + // exit early for no `thisArg` or already bound by `Function#bind` + if (typeof thisArg == 'undefined' || !('prototype' in func)) { + return func; + } + var bindData = func.__bindData__; + if (typeof bindData == 'undefined') { + if (support.funcNames) { + bindData = !func.name; + } + bindData = bindData || !support.funcDecomp; + if (!bindData) { + var source = fnToString.call(func); + if (!support.funcNames) { + bindData = !reFuncName.test(source); + } + if (!bindData) { + // checks if `func` references the `this` keyword and stores the result + bindData = reThis.test(source); + setBindData(func, bindData); + } + } + } + // exit early if there are no `this` references or `func` is bound + if (bindData === false || (bindData !== true && bindData[1] & 1)) { + return func; + } + switch (argCount) { + case 1: return function(value) { + return func.call(thisArg, value); + }; + case 2: return function(a, b) { + return func.call(thisArg, a, b); + }; + case 3: return function(value, index, collection) { + return func.call(thisArg, value, index, collection); + }; + case 4: return function(accumulator, value, index, collection) { + return func.call(thisArg, accumulator, value, index, collection); + }; + } + return bind(func, thisArg); +} + +module.exports = baseCreateCallback; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseCreateWrapper.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseCreateWrapper.js b/node_modules/lodash-node/compat/internals/baseCreateWrapper.js new file mode 100644 index 0000000..41bb35f --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseCreateWrapper.js @@ -0,0 +1,78 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseCreate = require('./baseCreate'), + isObject = require('../objects/isObject'), + setBindData = require('./setBindData'), + slice = require('./slice'); + +/** + * Used for `Array` method references. + * + * Normally `Array.prototype` would suffice, however, using an array literal + * avoids issues in Narwhal. + */ +var arrayRef = []; + +/** Native method shortcuts */ +var push = arrayRef.push; + +/** + * The base implementation of `createWrapper` that creates the wrapper and + * sets its meta data. + * + * @private + * @param {Array} bindData The bind data array. + * @returns {Function} Returns the new function. + */ +function baseCreateWrapper(bindData) { + var func = bindData[0], + bitmask = bindData[1], + partialArgs = bindData[2], + partialRightArgs = bindData[3], + thisArg = bindData[4], + arity = bindData[5]; + + var isBind = bitmask & 1, + isBindKey = bitmask & 2, + isCurry = bitmask & 4, + isCurryBound = bitmask & 8, + key = func; + + function bound() { + var thisBinding = isBind ? thisArg : this; + if (partialArgs) { + var args = slice(partialArgs); + push.apply(args, arguments); + } + if (partialRightArgs || isCurry) { + args || (args = slice(arguments)); + if (partialRightArgs) { + push.apply(args, partialRightArgs); + } + if (isCurry && args.length < arity) { + bitmask |= 16 & ~32; + return baseCreateWrapper([func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity]); + } + } + args || (args = arguments); + if (isBindKey) { + func = thisBinding[key]; + } + if (this instanceof bound) { + thisBinding = baseCreate(func.prototype); + var result = func.apply(thisBinding, args); + return isObject(result) ? result : thisBinding; + } + return func.apply(thisBinding, args); + } + setBindData(bound, bindData); + return bound; +} + +module.exports = baseCreateWrapper; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseDifference.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseDifference.js b/node_modules/lodash-node/compat/internals/baseDifference.js new file mode 100644 index 0000000..cc32c28 --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseDifference.js @@ -0,0 +1,52 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var baseIndexOf = require('./baseIndexOf'), + cacheIndexOf = require('./cacheIndexOf'), + createCache = require('./createCache'), + largeArraySize = require('./largeArraySize'), + releaseObject = require('./releaseObject'); + +/** + * The base implementation of `_.difference` that accepts a single array + * of values to exclude. + * + * @private + * @param {Array} array The array to process. + * @param {Array} [values] The array of values to exclude. + * @returns {Array} Returns a new array of filtered values. + */ +function baseDifference(array, values) { + var index = -1, + indexOf = baseIndexOf, + length = array ? array.length : 0, + isLarge = length >= largeArraySize, + result = []; + + if (isLarge) { + var cache = createCache(values); + if (cache) { + indexOf = cacheIndexOf; + values = cache; + } else { + isLarge = false; + } + } + while (++index < length) { + var value = array[index]; + if (indexOf(values, value) < 0) { + result.push(value); + } + } + if (isLarge) { + releaseObject(values); + } + return result; +} + +module.exports = baseDifference; http://git-wip-us.apache.org/repos/asf/cordova-osx/blob/7a58a67b/node_modules/lodash-node/compat/internals/baseEach.js ---------------------------------------------------------------------- diff --git a/node_modules/lodash-node/compat/internals/baseEach.js b/node_modules/lodash-node/compat/internals/baseEach.js new file mode 100644 index 0000000..0c833bc --- /dev/null +++ b/node_modules/lodash-node/compat/internals/baseEach.js @@ -0,0 +1,28 @@ +/** + * Lo-Dash 2.4.1 (Custom Build) <http://lodash.com/> + * Build: `lodash modularize exports="node" -o ./compat/` + * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/> + * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE> + * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + * Available under MIT license <http://lodash.com/license> + */ +var createIterator = require('./createIterator'), + eachIteratorOptions = require('./eachIteratorOptions'); + +/** + * A function compiled to iterate `arguments` objects, arrays, objects, and + * strings consistenly across environments, executing the callback for each + * element in the collection. The callback is bound to `thisArg` and invoked + * with three arguments; (value, index|key, collection). Callbacks may exit + * iteration early by explicitly returning `false`. + * + * @private + * @type Function + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function} [callback=identity] The function called per iteration. + * @param {*} [thisArg] The `this` binding of `callback`. + * @returns {Array|Object|string} Returns `collection`. + */ +var baseEach = createIterator(eachIteratorOptions); + +module.exports = baseEach; --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
