diff --git a/.gitattributes b/.gitattributes
index 724b13111e..d7ea4954ec 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,5 +1,5 @@
* text=auto
+*.html text eol=lf
*.js text eol=lf
-*.jst text eol=lf
+*.md text eol=lf
*.sh text eol=lf
-*.tpl text eol=lf
diff --git a/.gitignore b/.gitignore
index 150de05ff2..d415f6fe22 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,10 @@
.DS_Store
*.custom.*
+*.min.*
*.template.*
-*.d.ts
*.map
+modularize
node_modules
-vendor/closure-compiler
-vendor/uglifyjs
+dist/*.backbone.*
+dist/*.legacy.*
+dist/*.mobile.*
diff --git a/.jamignore b/.jamignore
index dfb9ed2d4a..20ea2891e3 100644
--- a/.jamignore
+++ b/.jamignore
@@ -1,17 +1,11 @@
.*
-*.custom.*
-*.template.*
-*.d.ts
-*.map
*.md
-*.txt
-build.js
-lodash.js
+/lodash.js
index.js
bower.json
component.json
-build
doc
+modularize
node_modules
perf
test
diff --git a/.npmignore b/.npmignore
deleted file mode 100644
index c9ec59ceff..0000000000
--- a/.npmignore
+++ /dev/null
@@ -1,25 +0,0 @@
-.*
-*.custom.*
-*.template.*
-*.d.ts
-*.map
-*.md
-bower.json
-component.json
-doc
-perf
-test
-vendor/*.gz
-vendor/backbone
-vendor/benchmark.js
-vendor/closure-compiler
-vendor/docdown
-vendor/firebug-lite
-vendor/jquery
-vendor/json3
-vendor/platform.js
-vendor/qunit
-vendor/qunit-clib
-vendor/requirejs
-vendor/uglifyjs
-vendor/underscore
diff --git a/.travis.yml b/.travis.yml
index 458651f2a6..a2028d32cb 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,23 +1,19 @@
language: node_js
node_js:
- - 0.6
- - 0.9
- - 0.10
+ - "0.6"
+ - "0.10"
env:
- TEST_COMMAND="istanbul cover ./test/test.js"
- TEST_COMMAND="phantomjs ./test/test.js ../dist/lodash.compat.js"
- TEST_COMMAND="phantomjs ./test/test.js ../dist/lodash.compat.min.js"
- TEST_COMMAND="node ./test/test.js ../dist/lodash.js"
- TEST_COMMAND="node ./test/test.js ../dist/lodash.min.js"
- - TEST_COMMAND="node ./test/test-build.js --time-limit 48m"
git:
depth: 1
branches:
only:
- master
before_script:
- - "tar -xzvf vendor/closure-compiler.tar.gz -C vendor"
- - "tar -xzvf vendor/uglifyjs.tar.gz -C vendor"
- "npm install -g istanbul"
script:
- $TEST_COMMAND
+ - $TEST_COMMAND
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7ebb5bc1b3..6aee273d89 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,12 +1,12 @@
# Contributing to Lo-Dash
If you’d like to contribute a feature or bug fix, you can [fork](https://help.github.com/articles/fork-a-repo) Lo-Dash, commit your changes, and [send a pull request](https://help.github.com/articles/using-pull-requests).
-Please make sure to [search the issue tracker](https://github.com/bestiejs/lodash/issues) first; your issue may have already been discussed or fixed in `master`.
+Please make sure to [search the issue tracker](https://github.com/lodash/lodash/issues) first; your issue may have already been discussed or fixed in `master`.
## Tests
Include updated unit tests in the `test` directory as part of your pull request.
-You can run the tests from the command line via `npm test`, or open `test/index.html` in a web browser.
+You can run the tests from the command line via `node test/test`, or open `test/index.html` in a web browser.
The `test/run-test.sh` script attempts to run the tests in [Rhino](https://developer.mozilla.org/en-US/docs/Rhino), [Narwhal](https://github.com/280north/narwhal), [RingoJS](http://ringojs.org/), [PhantomJS](http://phantomjs.org/), and [Node](http://nodejs.org/), before running them in your default browser.
The [Backbone](http://backbonejs.org/) and [Underscore](http://http://underscorejs.org/) test suites are included as well.
@@ -15,7 +15,7 @@ The [Backbone](http://backbonejs.org/) and [Underscore](http://http://underscore
Lo-Dash is a member of the [Dojo Foundation](http://dojofoundation.org/).
As such, we request that all contributors sign the Dojo Foundation [contributor license agreement](http://dojofoundation.org/about/claForm).
-For more information about CLAs, please check out Alex Russell’s excellent post, ["Why Do I Need to Sign This?"](http://infrequently.org/2008/06/why-do-i-need-to-sign-this/).
+For more information about CLAs, please check out Alex Russell’s excellent post, [“Why Do I Need to Sign This?”](http://infrequently.org/2008/06/why-do-i-need-to-sign-this/).
## Coding Guidelines
diff --git a/LICENSE.txt b/LICENSE.txt
index cc082396c7..49869bbab3 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,6 +1,6 @@
Copyright 2012-2013 The Dojo Foundation
-Based on Underscore.js 1.4.3, copyright 2009-2013 Jeremy Ashkenas,
-DocumentCloud Inc.
+Based on Underscore.js 1.5.2, copyright 2009-2013 Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
diff --git a/README.md b/README.md
index 3c1993d05d..7207586921 100644
--- a/README.md
+++ b/README.md
@@ -1,194 +1,86 @@
-# Lo-Dash v1.3.1
-
-A low-level utility library delivering consistency, [customization](https://github.com/bestiejs/lodash#custom-builds), [performance](http://lodash.com/benchmarks), and [extra features](https://github.com/bestiejs/lodash#features).
+# Lo-Dash v2.0.0
+A utility library delivering consistency, [customization](http://lodash.com/custom-builds), [performance](http://lodash.com/benchmarks), & [extras](http://lodash.com/#features).
## Download
-* Lo-Dash builds (for modern environments):
-[Development](https://raw.github.com/bestiejs/lodash/v1.3.1/dist/lodash.js) and
-[Production](https://raw.github.com/bestiejs/lodash/v1.3.1/dist/lodash.min.js)
+* Modern builds:
+[Development](https://raw.github.com/lodash/lodash/2.0.0/dist/lodash.js) &
+[Production](https://raw.github.com/lodash/lodash/2.0.0/dist/lodash.min.js)
-* Lo-Dash compatibility builds (for legacy and modern environments):
-[Development](https://raw.github.com/bestiejs/lodash/v1.3.1/dist/lodash.compat.js) and
-[Production](https://raw.github.com/bestiejs/lodash/v1.3.1/dist/lodash.compat.min.js)
+* Compatibility builds:
+[Development](https://raw.github.com/lodash/lodash/2.0.0/dist/lodash.compat.js) &
+[Production](https://raw.github.com/lodash/lodash/2.0.0/dist/lodash.compat.min.js)
-* Underscore compatibility builds:
-[Development](https://raw.github.com/bestiejs/lodash/v1.3.1/dist/lodash.underscore.js) and
-[Production](https://raw.github.com/bestiejs/lodash/v1.3.1/dist/lodash.underscore.min.js)
+* Underscore builds:
+[Development](https://raw.github.com/lodash/lodash/2.0.0/dist/lodash.underscore.js) &
+[Production](https://raw.github.com/lodash/lodash/2.0.0/dist/lodash.underscore.min.js)
-* CDN copies of ≤ v1.3.1’s builds are available on [cdnjs](http://cdnjs.com/) thanks to [CloudFlare](http://www.cloudflare.com/):
-[Lo-Dash dev](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.js),
-[Lo-Dash prod](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.min.js),
-[Lo-Dash compat-dev](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.compat.js),
-[Lo-Dash compat-prod](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.compat.min.js),
-[Underscore compat-dev](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.underscore.js), and
-[Underscore compat-prod](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.3.1/lodash.underscore.min.js)
+Love modules? We’ve got you covered with [lodash-amd](https://npmjs.org/package/lodash-amd), [lodash-node](https://npmjs.org/package/lodash-node), and [npm packages](https://npmjs.org/browse/author/jdalton) per method.
-* For optimal file size, [create a custom build](https://github.com/bestiejs/lodash#custom-builds) with only the features you need
+CDN copies are available on [cdnjs](http://cdnjs.com/) & [jsDelivr](http://www.jsdelivr.com/#!lodash).
+For smaller file sizes, create [custom builds](http://lodash.com/custom-builds) with only the features needed.
## Dive in
-We’ve got [API docs](http://lodash.com/docs), [benchmarks](http://lodash.com/benchmarks), and [unit tests](http://lodash.com/tests).
-
-For a list of upcoming features, check out our [roadmap](https://github.com/bestiejs/lodash/wiki/Roadmap).
-
-## Resources
-
-For more information check out these articles, screencasts, and other videos over Lo-Dash:
+There’s plenty of [documentation](http://lodash.com/docs), [unit tests](http://lodash.com/tests), & [benchmarks](http://lodash.com/benchmarks).
- * Posts
- - [Say “Hello” to Lo-Dash](http://kitcambridge.be/blog/say-hello-to-lo-dash/)
+For a list of upcoming features, check out our [roadmap](https://github.com/lodash/lodash/wiki/Roadmap).
- * Videos
- - [Introducing Lo-Dash](https://vimeo.com/44154599)
- - [Lo-Dash optimizations and custom builds](https://vimeo.com/44154601)
- - [Lo-Dash’s origin and why it’s a better utility belt](https://vimeo.com/44154600)
- - [Unit testing in Lo-Dash](https://vimeo.com/45865290)
- - [Lo-Dash’s approach to native method use](https://vimeo.com/48576012)
- - [CascadiaJS: Lo-Dash for a better utility belt](http://www.youtube.com/watch?v=dpPy4f_SeEk)
+## Features *not* in Underscore
-## Features
-
- * AMD loader support ([RequireJS](http://requirejs.org/), [curl.js](https://github.com/cujojs/curl), etc.)
+ * AMD loader support ([curl](https://github.com/cujojs/curl), [dojo](http://dojotoolkit.org/), [requirejs](http://requirejs.org/), etc.)
* [_(…)](http://lodash.com/docs#_) supports intuitive chaining
* [_.at](http://lodash.com/docs#at) for cherry-picking collection values
- * [_.bindKey](http://lodash.com/docs#bindKey) for binding [*“lazy”* defined](http://michaux.ca/articles/lazy-function-definition-pattern) methods
- * [_.cloneDeep](http://lodash.com/docs#cloneDeep) for deep cloning arrays and objects
- * [_.contains](http://lodash.com/docs#contains) accepts a `fromIndex` argument
- * [_.debounce](http://lodash.com/docs#debounce) and [_.throttle](http://lodash.com/docs#throttle) accept an `options` argument for more control
- * [_.createCallback](http://lodash.com/docs#createCallback) to customize how callback arguments are handled and support callback shorthands in mixins
- * [_.findIndex](http://lodash.com/docs#findIndex) and [_.findKey](http://lodash.com/docs#findKey) for finding indexes and keys of collections
- * [_.forEach](http://lodash.com/docs#forEach) is chainable and supports exiting iteration early
- * [_.forIn](http://lodash.com/docs#forIn) for iterating over an object’s own and inherited properties
- * [_.forOwn](http://lodash.com/docs#forOwn) for iterating over an object’s own properties
- * [_.isPlainObject](http://lodash.com/docs#isPlainObject) checks if values are created by the `Object` constructor
+ * [_.bindKey](http://lodash.com/docs#bindKey) for binding [*“lazy”*](http://michaux.ca/articles/lazy-function-definition-pattern) defined methods
+ * [_.cloneDeep](http://lodash.com/docs#cloneDeep) for deep cloning arrays & objects
+ * [_.contains](http://lodash.com/docs#contains) accepts a `fromIndex`
+ * [_.createCallback](http://lodash.com/docs#createCallback) for extending callbacks in methods & mixins
+ * [_.curry](http://lodash.com/docs#curry) for creating [curried](http://hughfdjackson.com/javascript/2013/07/06/why-curry-helps/) functions
+ * [_.debounce](http://lodash.com/docs#debounce) & [_.throttle](http://lodash.com/docs#throttle) accept `options` for more control
+ * [_.findIndex](http://lodash.com/docs#findIndex) & [_.findKey](http://lodash.com/docs#findKey) for finding indexes & keys
+ * [_.forEach](http://lodash.com/docs#forEach) is chainable & supports exiting early
+ * [_.forIn](http://lodash.com/docs#forIn) for iterating own & inherited properties
+ * [_.forOwn](http://lodash.com/docs#forOwn) for iterating own properties
+ * [_.isPlainObject](http://lodash.com/docs#isPlainObject) for checking if values are created by `Object`
+ * [_.memoize](http://lodash.com/docs#memoize) exposes the `cache` of memoized functions
* [_.merge](http://lodash.com/docs#merge) for a deep [_.extend](http://lodash.com/docs#extend)
- * [_.parseInt](http://lodash.com/docs#parseInt) for consistent cross-environment behavior
- * [_.partial](http://lodash.com/docs#partial) and [_.partialRight](http://lodash.com/docs#partialRight) for partial application without `this` binding
- * [_.runInContext](http://lodash.com/docs#runInContext) for easier mocking and extended environment support
- * [_.support](http://lodash.com/docs#support) to flag environment features
- * [_.template](http://lodash.com/docs#template) supports [*“imports”* options](http://lodash.com/docs#templateSettings_imports), [ES6 template delimiters](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6), and [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
+ * [_.parseInt](http://lodash.com/docs#parseInt) for consistent behavior
+ * [_.partialRight](http://lodash.com/docs#partialRight) for [partial application](http://lodash.com/docs#partial) from the right
+ * [_.pull](http://lodash.com/docs#pull) & [_.remove](http://lodash.com/docs#remove) for mutating arrays
+ * [_.runInContext](http://lodash.com/docs#runInContext) for easier mocking
+ * [_.support](http://lodash.com/docs#support) for flagging environment features
+ * [_.template](http://lodash.com/docs#template) supports [*“imports”*](http://lodash.com/docs#templateSettings_imports) options & [ES6 template delimiters](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6)
* [_.transform](http://lodash.com/docs#transform) as a powerful alternative to [_.reduce](http://lodash.com/docs#reduce) for transforming objects
- * [_.unzip](http://lodash.com/docs#unzip) as the inverse of [_.zip](http://lodash.com/docs#zip)
* [_.where](http://lodash.com/docs#where) supports deep object comparisons
- * [_.clone](http://lodash.com/docs#clone), [_.omit](http://lodash.com/docs#omit), [_.pick](http://lodash.com/docs#pick),
- [and more…](http://lodash.com/docs "_.assign, _.cloneDeep, _.first, _.initial, _.isEqual, _.last, _.merge, _.rest") accept `callback` and `thisArg` arguments
- * [_.contains](http://lodash.com/docs#contains), [_.size](http://lodash.com/docs#size), [_.toArray](http://lodash.com/docs#toArray),
- [and more…](http://lodash.com/docs "_.at, _.countBy, _.every, _.filter, _.find, _.forEach, _.groupBy, _.invoke, _.map, _.max, _.min, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.some, _.sortBy, _.where") accept strings
- * [_.filter](http://lodash.com/docs#filter), [_.find](http://lodash.com/docs#find), [_.map](http://lodash.com/docs#map),
- [and more…](http://lodash.com/docs "_.countBy, _.every, _.first, _.groupBy, _.initial, _.last, _.max, _.min, _.reject, _.rest, _.some, _.sortBy, _.sortedIndex, _.uniq") support *“_.pluck”* and *“_.where”* `callback` shorthands
+ * [_.zip](http://lodash.com/docs#zip) is capable of unzipping values
+ * [_.omit](http://lodash.com/docs#omit), [_.pick](http://lodash.com/docs#pick), &
+ [more](http://lodash.com/docs "_.assign, _.clone, _.cloneDeep, _.first, _.initial, _.isEqual, _.last, _.merge, _.rest") accept callbacks
+ * [_.contains](http://lodash.com/docs#contains), [_.toArray](http://lodash.com/docs#toArray), &
+ [more](http://lodash.com/docs "_.at, _.countBy, _.every, _.filter, _.find, _.forEach, _.forEachRight, _.groupBy, _.invoke, _.map, _.max, _.min, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.size, _.some, _.sortBy, _.where") accept strings
+ * [_.filter](http://lodash.com/docs#filter), [_.map](http://lodash.com/docs#map), &
+ [more](http://lodash.com/docs "_.countBy, _.every, _.find, _.findKey, _.findLast, _.findLastIndex, _.findLastKey, _.first, _.groupBy, _.initial, _.last, _.max, _.min, _.reject, _.rest, _.some, _.sortBy, _.sortedIndex, _.uniq") support *“_.pluck”* & *“_.where”* shorthands
+ * [_.findLast](http://lodash.com/docs#findLast), [_.findLastIndex](http://lodash.com/docs#findLastIndex), &
+ [more](http://lodash.com/docs "_.findLastKey, _.forEachRight, _.forInRight, _.forOwnRight") right-associative methods
-## Support
-
-Lo-Dash has been tested in at least Chrome 5~27, Firefox 2~21, IE 6-10, Opera 9.25~12, Safari 3-6, Node.js 0.4.8-0.10.7 (Node bug [#5622](https://github.com/joyent/node/issues/5622) prevents 0.10.8-0.10.10 from working), Narwhal 0.3.2, PhantomJS 1.9.0, RingoJS 0.9, and Rhino 1.7RC5.
-
-## Custom builds
-
-Custom builds make it easy to create lightweight versions of Lo-Dash containing only the methods you need.
-To top it off, we handle all method dependency and alias mapping for you.
-For a more detailed summary over the differences between various builds, check out the [wiki page](https://github.com/bestiejs/lodash/wiki/build-differences).
-
- * Backbone builds, with only methods required by Backbone, may be created using the `backbone` modifier argument.
-```bash
-lodash backbone
-```
-
- * Legacy builds, tailored for older environments without [ES5 support](http://es5.github.com/), may be created using the `legacy` modifier argument.
-```bash
-lodash legacy
-```
-
- * Modern builds, tailored for newer environments with ES5 support, may be created using the `modern` modifier argument.
-```bash
-lodash modern
-```
-
- * Mobile builds, without method compilation and most bug fixes for old browsers, may be created using the `mobile` modifier argument.
-```bash
-lodash mobile
-```
-
- * Strict builds, with `_.bindAll`, `_.defaults`, and `_.extend` in [strict mode](http://es5.github.com/#C), may be created using the `strict` modifier argument.
-```bash
-lodash strict
-```
-
- * Underscore builds, tailored for projects already using Underscore, may be created using the `underscore` modifier argument.
-```bash
-lodash underscore
-```
-
-Custom builds may be created using the following commands:
-
- * Use the `category` argument to pass comma separated categories of methods to include in the build.
- Valid categories (case-insensitive) are *“arrays”*, *“chaining”*, *“collections”*, *“functions”*, *“objects”*, and *“utilities”*.
-```bash
-lodash category=collections,functions
-lodash category="collections, functions"
-```
-
- * Use the `exports` argument to pass comma separated names of ways to export the `LoDash` function.
- Valid exports are *“amd”*, *“commonjs”*, *“global”*, *“node”*, and *“none”*.
-```bash
-lodash exports=amd,commonjs,node
-lodash exports="amd, commonjs, node"
-```
-
- * Use the `iife` argument to specify code to replace the immediately-invoked function expression that wraps Lo-Dash.
-```bash
-lodash iife="!function(window,undefined){%output%}(this)"
-```
-
- * Use the `include` argument to pass comma separated method/category names to include in the build.
-```bash
-lodash include=each,filter,map
-lodash include="each, filter, map"
-```
-
- * Use the `minus` argument to pass comma separated method/category names to remove from those included in the build.
-```bash
-lodash underscore minus=result,shuffle
-lodash underscore minus="result, shuffle"
-```
-
- * Use the `plus` argument to pass comma separated method/category names to add to those included in the build.
-```bash
-lodash backbone plus=random,template
-lodash backbone plus="random, template"
-```
-
- * Use the `template` argument to pass the file path pattern used to match template files to precompile.
-```bash
-lodash template="./*.jst"
-```
-
- * Use the `settings` argument to pass the template settings used when precompiling templates.
-```bash
-lodash settings="{interpolate:/\{\{([\s\S]+?)\}\}/g}"
-```
-
- * Use the `moduleId` argument to specify the AMD module ID of Lo-Dash, which defaults to “lodash”, used by precompiled templates.
-```bash
-lodash moduleId="underscore"
-```
+## Resources
-All arguments, except `legacy` with `mobile`, `modern`, or `underscore`, may be combined.
-Unless specified by `-o` or `--output`, all files created are saved to the current working directory.
+ * Posts
+ - [Say “Hello” to Lo-Dash](http://kitcambridge.be/blog/say-hello-to-lo-dash/)
+ - [Custom builds in Lo-Dash 2.0](http://kitcambridge.be/blog/custom-builds-in-lo-dash-2-dot-0/)
-The following options are also supported:
+ * Videos
+ - [Introduction](https://vimeo.com/44154599)
+ - [Origins](https://vimeo.com/44154600)
+ - [Optimizations & builds](https://vimeo.com/44154601)
+ - [Native method use](https://vimeo.com/48576012)
+ - [Testing](https://vimeo.com/45865290)
+ - [CascadiaJS ’12](http://www.youtube.com/watch?v=dpPy4f_SeEk)
- * `-c`, `--stdout` ......... Write output to standard output
- * `-d`, `--debug` ........... Write only the non-minified development output
- * `-h`, `--help` ............. Display help information
- * `-m`, `--minify` ......... Write only the minified production output
- * `-o`, `--output` ......... Write output to a given path/filename
- * `-p`, `--source-map` .. Generate a source map for the minified output, using an optional source map URL
- * `-s`, `--silent` ......... Skip status updates normally logged to the console
- * `-V`, `--version` ....... Output current version of Lo-Dash
+## Support
-The `lodash` command-line utility is available when Lo-Dash is installed as a global package (i.e. `npm install -g lodash`).
+Tested in Chrome 5~29, Firefox 2~23, IE 6-10, Opera 9.25~15, Safari 3-6, Node.js 0.6.8-0.10.18, Narwhal 0.3.2, PhantomJS 1.9.1, RingoJS 0.9, & Rhino 1.7RC5.
-## Installation and usage
+## Installation & usage
In browsers:
@@ -199,34 +91,24 @@ In browsers:
Using [`npm`](http://npmjs.org/):
```bash
-npm install lodash
+npm i lodash
-npm install -g lodash
+{sudo} npm i -g lodash
npm link lodash
```
-To avoid potential issues, update `npm` before installing Lo-Dash:
-
-```bash
-npm install npm -g
-```
-
-In [Node.js](http://nodejs.org/) and [RingoJS ≥ v0.8.0](http://ringojs.org/):
+In [Node.js](http://nodejs.org/) & [Ringo](http://ringojs.org/):
```js
var _ = require('lodash');
-
-// or as a drop-in replacement for Underscore
+// or as Underscore
var _ = require('lodash/dist/lodash.underscore');
```
-**Note:** If Lo-Dash is installed globally, run [`npm link lodash`](http://blog.nodejs.org/2011/03/23/npm-1-0-global-vs-local-installation/) in your project’s root directory before requiring it.
-
-In [RingoJS ≤ v0.7.0](http://ringojs.org/):
-
-```js
-var _ = require('lodash')._;
-```
+**Notes:**
+ * Don’t assign values to [special variable](http://nodejs.org/api/repl.html#repl_repl_features) `_` when in the REPL
+ * If Lo-Dash is installed globally, run [`npm link lodash`](http://blog.nodejs.org/2011/03/23/npm-1-0-global-vs-local-installation/) in your project’s root directory *before* requiring it
+ * Node.js 0.10.8-0.10.11 [have](https://github.com/joyent/node/issues/5622) [bugs](https://github.com/joyent/node/issues/5688) preventing minified builds
In [Rhino](http://www.mozilla.org/rhino/):
@@ -234,67 +116,72 @@ In [Rhino](http://www.mozilla.org/rhino/):
load('lodash.js');
```
-In an AMD loader like [RequireJS](http://requirejs.org/):
+In an AMD loader:
```js
require({
- 'paths': {
- 'underscore': 'path/to/lodash'
- }
+ 'packages': [
+ { 'name': 'lodash', 'location': 'path/to/lodash', 'main': 'lodash' }
+ ]
},
-['underscore'], function(_) {
+['lodash'], function(_) {
console.log(_.VERSION);
});
```
## Release Notes
-### v1.3.1
-
- * Added missing `cache` property to the objects returned by `getObject`
- * Ensured `maxWait` unit tests pass in Ringo
- * Increased the `maxPoolSize` value
- * Optimized `releaseArray` and `releaseObject`
-
-### v1.3.0
-
- * Added `_.transform` method
- * Added `_.chain` and `_.findWhere` aliases
- * Added internal array and object pooling
- * Added Istanbul test coverage reports to Travis CI
- * Added `maxWait` option to `_.debounce`
- * Added support for floating point numbers to `_.random`
- * Added Volo configuration to package.json
- * Adjusted UMD for `component build`
- * Allowed more stable mixing of `lodash` and `underscore` build methods
- * Ensured debounced function with, `leading` and `trailing` options, works as expected
- * Ensured minified builds work with the Dojo builder
- * Ensured minification avoids deoptimizing expressions containing boolean values
- * Ensured unknown types return `false` in `_.isObject` and `_.isRegExp`
- * Ensured `_.clone`, `_.flatten`, and `_.uniq` can be used as a `callback` for methods like `_.map`
- * Ensured `_.forIn` works on objects with longer inheritance chains in IE < 9
- * Ensured `_.isPlainObject` returns `true` for empty objects in IE < 9
- * Ensured `_.max` and `_.min` chain correctly
- * Ensured `clearTimeout` use doesn’t cause errors in Titanium
- * Ensured that the `--stdout` build option doesn't write to a file
- * Exposed memoized function’s `cache`
- * Fixed `Error.prototype` iteration bugs
- * Fixed "scripts" paths in component.json
- * Made methods support customizing `_.indexOf`
- * Made the build track dependencies of private functions
- * Made the `template` pre-compiler build option avoid escaping non-ascii characters
- * Made `_.createCallback` avoid binding functions if they don’t reference `this`
- * Optimized the Closure Compiler minification process
- * Optimized the large array cache for `_.difference`, `_.intersection`, and `_.uniq`
- * Optimized internal `_.flatten` and `_.indexOf` use
- * Reduced `_.unzip` and `_.zip`
- * Removed special handling of arrays in `_.assign` and `_.defaults`
-
-The full changelog is available [here](https://github.com/bestiejs/lodash/wiki/Changelog).
+### v2.0.0
+
+#### Compatibility Warnings
+
+ * Aligned `_.after` with Underscore 1.5.0, making it always return a function
+
+#### Noteable Changes
+
+ * Created Lo-Dash methods as `npm` packages & AMD/Node.js modules
+ * Made `_.chain` force chaining for all methods, even those that normally return unwrapped values
+ * Moved the build utility to [lodash-cli](https://npmjs.org/package/lodash-cli)
+ * Optimized `_.contains`, `_.debounce`, `_.isArguments`, `_.throttle`, `_.where`,
+ & functions created by `_.bind`, `_.bindKey`, `_.curry`, `_.partial`, & `_.partialRight`
+ * Added [`_.curry`](http://lodash.com/docs#curry), [`_.forEachRight`](http://lodash.com/docs#forEachRight),
+ [`_.indexBy`](http://lodash.com/docs#indexBy), [`_.findLast`](http://lodash.com/docs#findLast),
+ [`_.findLastIndex`](http://lodash.com/docs#findLastIndex),
+ [`_.findLastKey`](http://lodash.com/docs#findLastKey), [`_.forInRight`](http://lodash.com/docs#forInRight),
+ [`_.forOwnRight`](http://lodash.com/docs#forOwnRight), [`_.pull`](http://lodash.com/docs#pull),
+ [`_.remove`](http://lodash.com/docs#remove), & [`_.sample`](http://lodash.com/docs#sample)
+
+#### Other Changes
+
+ * Added Curl & Dojo module loaders to the unit tests
+ * Added the `modularize` build option
+ * Added support for the `iife` command to be used without an `%output%` token
+ * Added support for `_.mixin` to accept a destination object
+ * Added support for `_.range` to accept a `step` of `0`
+ * Added `_.eachRight` as an alias for `_.forEachRight`
+ * Ensured *“Arrays”* methods support `arguments` objects
+ * Ensured *“Functions”* methods throw when not passed functions
+ * Ensured `_.at` works as a `callback` for `_.map`
+ * Ensured `_.createCallback` works when no `argCount` is specified
+ * Ensured `_.first` & `_.last` return arrays when passed a falsey `array` with an `n` value
+ * Ensured `_.flatten` works with `arguments` objects
+ * Ensured minified files work with Dojo’s builder
+ * Ensured `_.zipObject` skips falsey elements
+ * Improved dead code removal from builds
+ * Improved JSDoc syntax
+ * Made `_.memoize` avoid prefixing `cache` keys when using a `resolver` function
+ * Made `_.unzip` an alias of `_.zip`
+ * Removed local `clearTimeout` & `setTimeout` variables from the `underscore` build
+ * Reduced the size of the repo & `npm` package
+ * Simplified the bailout in `createCache`
+ * Updated sourceURL & sourceMappingURL syntax
+ * Updated `underscore` build compatibility to v1.5.2
+
+The full changelog is available [here](https://github.com/lodash/lodash/wiki/Changelog).
## BestieJS
-Lo-Dash is part of the BestieJS *“Best in Class”* module collection. This means we promote solid browser/environment support, ES5+ precedents, unit testing, and plenty of documentation.
+Lo-Dash is part of the [BestieJS](https://github.com/bestiejs) *“Best in Class”* module collection. This means it promotes solid environment support, ES5+ precedents, unit testing, & plenty of documentation.
## Author
@@ -304,6 +191,6 @@ Lo-Dash is part of the BestieJS *“Best in Class”* module collection. This me
## Contributors
-| [](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [](http://twitter.com/mathias "Follow @mathias on Twitter") |
-|---|---|
-| [Kit Cambridge](http://kitcambridge.github.io/) | [Mathias Bynens](http://mathiasbynens.be/) |
+| [](http://twitter.com/blainebublitz "Follow @BlaineBublitz on Twitter") | [](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") | [](http://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|---|---|
+| [Blaine Bublitz](http://iceddev.com/) | [Kit Cambridge](http://kitcambridge.github.io/) | [Mathias Bynens](http://mathiasbynens.be/) |
diff --git a/bower.json b/bower.json
index 4122c56ee4..1af2905f1e 100644
--- a/bower.json
+++ b/bower.json
@@ -1,21 +1,20 @@
{
"name": "lodash",
- "version": "1.3.1",
+ "version": "2.0.0",
"main": "./dist/lodash.compat.js",
"ignore": [
".*",
"*.custom.*",
"*.template.*",
- "*.d.ts",
"*.map",
"*.md",
- "*.txt",
- "build.js",
+ "/*.min.*",
+ "/lodash.js",
"index.js",
"component.json",
"package.json",
- "build",
"doc",
+ "modularize",
"node_modules",
"perf",
"test",
diff --git a/build.js b/build.js
deleted file mode 100755
index 0be61ba029..0000000000
--- a/build.js
+++ /dev/null
@@ -1,3531 +0,0 @@
-#!/usr/bin/env node
-;(function() {
- 'use strict';
-
- /** Load Node.js modules */
- var vm = require('vm');
-
- /** Load other modules */
- var _ = require('./lodash.js'),
- minify = require('./build/minify.js'),
- util = require('./build/util.js');
-
- /** Module shortcuts */
- var fs = util.fs,
- path = util.path;
-
- /** The current working directory */
- var cwd = process.cwd();
-
- /** Used for array method references */
- var arrayRef = Array.prototype;
-
- /** Shortcut used to push arrays of values to an array */
- var push = arrayRef.push;
-
- /** Used to create regexes that may detect multi-line comment blocks */
- var multilineComment = '(?:\\n +/\\*[^*]*\\*+(?:[^/][^*]*\\*+)*/)?\\n';
-
- /** Used to detect the Node.js executable in command-line arguments */
- var reNode = RegExp('(?:^|' + path.sepEscaped + ')node(?:\\.exe)?$');
-
- /** Shortcut used to convert array-like objects to arrays */
- var slice = arrayRef.slice;
-
- /** Shortcut to the `stdout` object */
- var stdout = process.stdout;
-
- /** Used to associate aliases with their real names */
- var aliasToRealMap = {
- 'all': 'every',
- 'any': 'some',
- 'collect': 'map',
- 'detect': 'find',
- 'drop': 'rest',
- 'each': 'forEach',
- 'extend': 'assign',
- 'findWhere': 'find',
- 'foldl': 'reduce',
- 'foldr': 'reduceRight',
- 'head': 'first',
- 'include': 'contains',
- 'inject': 'reduce',
- 'methods': 'functions',
- 'object': 'zipObject',
- 'select': 'filter',
- 'tail': 'rest',
- 'take': 'first',
- 'unique': 'uniq'
- };
-
- /** Used to associate real names with their aliases */
- var realToAliasMap = {
- 'assign': ['extend'],
- 'contains': ['include'],
- 'every': ['all'],
- 'filter': ['select'],
- 'find': ['detect', 'findWhere'],
- 'first': ['head', 'take'],
- 'forEach': ['each'],
- 'functions': ['methods'],
- 'map': ['collect'],
- 'reduce': ['foldl', 'inject'],
- 'reduceRight': ['foldr'],
- 'rest': ['drop', 'tail'],
- 'some': ['any'],
- 'uniq': ['unique'],
- 'zipObject': ['object']
- };
-
- /** Used to track function dependencies */
- var dependencyMap = {
- 'after': [],
- 'assign': ['createIterator', 'isArguments', 'keys'],
- 'at': ['isString'],
- 'bind': ['createBound'],
- 'bindAll': ['bind', 'functions'],
- 'bindKey': ['createBound'],
- 'clone': ['assign', 'forEach', 'forOwn', 'getArray', 'isArray', 'isObject', 'isNode', 'releaseArray', 'slice'],
- 'cloneDeep': ['clone'],
- 'compact': [],
- 'compose': [],
- 'contains': ['basicEach', 'getIndexOf', 'isString'],
- 'countBy': ['createCallback', 'forEach'],
- 'createCallback': ['identity', 'isEqual', 'keys'],
- 'debounce': ['isObject'],
- 'defaults': ['createIterator', 'isArguments', 'keys'],
- 'defer': ['bind'],
- 'delay': [],
- 'difference': ['cacheIndexOf', 'createCache', 'getIndexOf', 'releaseObject'],
- 'escape': ['escapeHtmlChar'],
- 'every': ['basicEach', 'createCallback', 'isArray'],
- 'filter': ['basicEach', 'createCallback', 'isArray'],
- 'find': ['basicEach', 'createCallback', 'isArray'],
- 'findIndex': ['createCallback'],
- 'findKey': ['createCallback', 'forOwn'],
- 'first': ['slice'],
- 'flatten': ['isArray', 'overloadWrapper'],
- 'forEach': ['basicEach', 'createCallback', 'isArguments', 'isArray', 'isString', 'keys'],
- 'forIn': ['createCallback', 'createIterator', 'isArguments'],
- 'forOwn': ['createCallback', 'createIterator', 'isArguments', 'keys'],
- 'functions': ['forIn', 'isFunction'],
- 'groupBy': ['createCallback', 'forEach'],
- 'has': [],
- 'identity': [],
- 'indexOf': ['basicIndexOf', 'sortedIndex'],
- 'initial': ['slice'],
- 'intersection': ['cacheIndexOf', 'createCache', 'getArray', 'getIndexOf', 'releaseArray', 'releaseObject'],
- 'invert': ['keys'],
- 'invoke': ['forEach'],
- 'isArguments': [],
- 'isArray': [],
- 'isBoolean': [],
- 'isDate': [],
- 'isElement': [],
- 'isEmpty': ['forOwn', 'isArguments', 'isFunction'],
- 'isEqual': ['forIn', 'getArray', 'isArguments', 'isFunction', 'isNode', 'releaseArray'],
- 'isFinite': [],
- 'isFunction': [],
- 'isNaN': ['isNumber'],
- 'isNull': [],
- 'isNumber': [],
- 'isObject': [],
- 'isPlainObject': ['isArguments', 'shimIsPlainObject'],
- 'isRegExp': [],
- 'isString': [],
- 'isUndefined': [],
- 'keys': ['isArguments', 'isObject', 'shimKeys'],
- 'last': ['slice'],
- 'lastIndexOf': [],
- 'map': ['basicEach', 'createCallback', 'isArray'],
- 'max': ['basicEach', 'charAtCallback', 'createCallback', 'isArray', 'isString'],
- 'memoize': [],
- 'merge': ['forEach', 'forOwn', 'getArray', 'isArray', 'isObject', 'isPlainObject', 'releaseArray'],
- 'min': ['basicEach', 'charAtCallback', 'createCallback', 'isArray', 'isString'],
- 'mixin': ['forEach', 'functions'],
- 'noConflict': [],
- 'omit': ['forIn', 'getIndexOf'],
- 'once': [],
- 'pairs': ['keys'],
- 'parseInt': ['isString'],
- 'partial': ['createBound'],
- 'partialRight': ['createBound'],
- 'pick': ['forIn', 'isObject'],
- 'pluck': ['map'],
- 'random': [],
- 'range': [],
- 'reduce': ['basicEach', 'createCallback', 'isArray'],
- 'reduceRight': ['createCallback', 'forEach', 'isString', 'keys'],
- 'reject': ['createCallback', 'filter'],
- 'rest': ['slice'],
- 'result': ['isFunction'],
- 'runInContext': ['defaults', 'pick'],
- 'shuffle': ['forEach'],
- 'size': ['keys'],
- 'some': ['basicEach', 'createCallback', 'isArray'],
- 'sortBy': ['compareAscending', 'createCallback', 'forEach', 'getObject', 'releaseObject'],
- 'sortedIndex': ['createCallback', 'identity'],
- 'tap': ['value'],
- 'template': ['defaults', 'escape', 'escapeStringChar', 'keys', 'values'],
- 'throttle': ['debounce', 'getObject', 'isObject', 'releaseObject'],
- 'times': ['createCallback'],
- 'toArray': ['isString', 'slice', 'values'],
- 'transform': ['createCallback', 'createObject', 'forOwn', 'isArray'],
- 'unescape': ['unescapeHtmlChar'],
- 'union': ['isArray', 'uniq'],
- 'uniq': ['cacheIndexOf', 'createCache', 'getArray', 'getIndexOf', 'overloadWrapper', 'releaseArray', 'releaseObject'],
- 'uniqueId': [],
- 'unzip': ['max', 'pluck'],
- 'value': ['basicEach', 'forOwn', 'isArray', 'lodashWrapper'],
- 'values': ['keys'],
- 'where': ['filter'],
- 'without': ['difference'],
- 'wrap': [],
- 'zip': ['unzip'],
- 'zipObject': [],
-
- // private methods
- 'basicEach': ['createIterator', 'isArguments', 'isArray', 'isString', 'keys'],
- 'basicIndexOf': [],
- 'cacheIndexOf': ['basicIndexOf'],
- 'cachePush': [],
- 'charAtCallback': [],
- 'compareAscending': [],
- 'createBound': ['createObject', 'isFunction', 'isObject'],
- 'createCache': ['cachePush', 'getObject', 'releaseObject'],
- 'createIterator': ['getObject', 'iteratorTemplate', 'releaseObject'],
- 'createObject': [ 'isObject', 'noop'],
- 'escapeHtmlChar': [],
- 'escapeStringChar': [],
- 'getArray': [],
- 'getIndexOf': ['basicIndexOf', 'indexOf'],
- 'getObject': [],
- 'iteratorTemplate': [],
- 'isNode': [],
- 'lodashWrapper': [],
- 'noop': [],
- 'overloadWrapper': ['createCallback'],
- 'releaseArray': [],
- 'releaseObject': [],
- 'shimIsPlainObject': ['forIn', 'isArguments', 'isFunction', 'isNode'],
- 'shimKeys': ['createIterator', 'isArguments'],
- 'slice': [],
- 'unescapeHtmlChar': [],
-
- // method used by the `backbone` and `underscore` builds
- 'chain': ['value'],
- 'findWhere': ['where']
- };
-
- /** Used to inline `iteratorTemplate` */
- var iteratorOptions = [
- 'args',
- 'array',
- 'bottom',
- 'firstArg',
- 'init',
- 'loop',
- 'shadowedProps',
- 'support',
- 'top',
- 'useHas',
- 'useKeys'
- ];
-
- /** List of all methods */
- var allMethods = _.keys(dependencyMap);
-
- /** List of Lo-Dash methods */
- var lodashMethods = _.without(allMethods, 'findWhere');
-
- /** List of Backbone's Lo-Dash dependencies */
- var backboneDependencies = [
- 'bind',
- 'bindAll',
- 'chain',
- 'clone',
- 'contains',
- 'countBy',
- 'defaults',
- 'escape',
- 'every',
- 'extend',
- 'filter',
- 'find',
- 'first',
- 'forEach',
- 'groupBy',
- 'has',
- 'indexOf',
- 'initial',
- 'invert',
- 'invoke',
- 'isArray',
- 'isEmpty',
- 'isEqual',
- 'isFunction',
- 'isObject',
- 'isRegExp',
- 'isString',
- 'keys',
- 'last',
- 'lastIndexOf',
- 'map',
- 'max',
- 'min',
- 'mixin',
- 'omit',
- 'once',
- 'pairs',
- 'pick',
- 'reduce',
- 'reduceRight',
- 'reject',
- 'rest',
- 'result',
- 'shuffle',
- 'size',
- 'some',
- 'sortBy',
- 'sortedIndex',
- 'toArray',
- 'uniqueId',
- 'value',
- 'values',
- 'without'
- ];
-
- /** List of Lo-Dash only methods */
- var lodashOnlyMethods = [
- 'at',
- 'bindKey',
- 'cloneDeep',
- 'createCallback',
- 'findIndex',
- 'findKey',
- 'forIn',
- 'forOwn',
- 'isPlainObject',
- 'merge',
- 'parseInt',
- 'partialRight',
- 'runInContext',
- 'transform',
- 'unzip'
- ];
-
- /** List of ways to export the `lodash` function */
- var exportsAll = [
- 'amd',
- 'commonjs',
- 'global',
- 'node'
- ];
-
- /** List of valid method categories */
- var methodCategories = [
- 'Arrays',
- 'Chaining',
- 'Collections',
- 'Functions',
- 'Objects',
- 'Utilities'
- ];
-
- /** List of private methods */
- var privateMethods = [
- 'basicEach',
- 'basicIndex',
- 'cacheIndexOf',
- 'cachePush',
- 'charAtCallback',
- 'compareAscending',
- 'createBound',
- 'createCache',
- 'createIterator',
- 'escapeHtmlChar',
- 'escapeStringChar',
- 'getArray',
- 'getObject',
- 'isNode',
- 'iteratorTemplate',
- 'lodashWrapper',
- 'overloadWrapper',
- 'releaseArray',
- 'releaseObject',
- 'shimIsPlainObject',
- 'shimKeys',
- 'slice',
- 'unescapeHtmlChar'
- ];
-
- /** List of Underscore methods */
- var underscoreMethods = _.without.apply(_, [allMethods].concat(lodashOnlyMethods, privateMethods));
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Adds support for Underscore style chaining to the `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function addChainMethods(source) {
- // add `_.chain`
- source = source.replace(matchFunction(source, 'tap'), function(match) {
- var indent = getIndent(match);
- return match && (indent + [
- '',
- '/**',
- ' * Creates a `lodash` object that wraps the given `value`.',
- ' *',
- ' * @static',
- ' * @memberOf _',
- ' * @category Chaining',
- ' * @param {Mixed} value The value to wrap.',
- ' * @returns {Object} Returns the wrapper object.',
- ' * @example',
- ' *',
- ' * var stooges = [',
- " * { 'name': 'moe', 'age': 40 },",
- " * { 'name': 'larry', 'age': 50 },",
- " * { 'name': 'curly', 'age': 60 }",
- ' * ];',
- ' *',
- ' * var youngest = _.chain(stooges)',
- ' * .sortBy(function(stooge) { return stooge.age; })',
- " * .map(function(stooge) { return stooge.name + ' is ' + stooge.age; })",
- ' * .first();',
- " * // => 'moe is 40'",
- ' */',
- 'function chain(value) {',
- ' value = new lodashWrapper(value);',
- ' value.__chain__ = true;',
- ' return value;',
- '}',
- '',
- match
- ].join('\n' + indent));
- });
-
- // add `wrapperChain`
- source = source.replace(matchFunction(source, 'wrapperToString'), function(match) {
- var indent = getIndent(match);
- return match && (indent + [
- '',
- '/**',
- ' * Enables method chaining on the wrapper object.',
- ' *',
- ' * @name chain',
- ' * @memberOf _',
- ' * @category Chaining',
- ' * @returns {Mixed} Returns the wrapper object.',
- ' * @example',
- ' *',
- ' * var sum = _([1, 2, 3])',
- ' * .chain()',
- ' * .reduce(function(sum, num) { return sum + num; })',
- ' * .value()',
- ' * // => 6`',
- ' */',
- 'function wrapperChain() {',
- ' this.__chain__ = true;',
- ' return this;',
- '}',
- '',
- match
- ].join('\n' + indent));
- });
-
- // remove `lodash.prototype.toString` and `lodash.prototype.valueOf` assignments
- source = source.replace(/^ *lodash\.prototype\.(?:toString|valueOf) *=.+\n/gm, '');
-
- // remove `lodash.prototype` batch method assignments
- source = source.replace(/(?:\s*\/\/.*)*\n( *)forOwn\(lodash, *function\(func, *methodName\)[\s\S]+?\n\1}.+/g, '');
-
- // replace `_.mixin`
- source = replaceFunction(source, 'mixin', [
- 'function mixin(object) {',
- ' forEach(functions(object), function(methodName) {',
- ' var func = lodash[methodName] = object[methodName];',
- '',
- ' lodash.prototype[methodName] = function() {',
- ' var args = [this.__wrapped__];',
- ' push.apply(args, arguments);',
- '',
- ' var result = func.apply(lodash, args);',
- ' if (this.__chain__) {',
- ' result = new lodashWrapper(result);',
- ' result.__chain__ = true;',
- ' }',
- ' return result;',
- ' };',
- ' });',
- '}'
- ].join('\n'));
-
- // replace wrapper `Array` method assignments
- source = source.replace(/^(?:(?: *\/\/.*\n)*(?: *if *\(.+\n)?( *)(basicEach|forEach)\(\['[\s\S]+?\n\1}\);(?:\n *})?\n+)+/m, function(match, indent, funcName) {
- return indent + [
- '// add `Array` mutator functions to the wrapper',
- funcName + "(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {",
- ' var func = arrayRef[methodName];',
- ' lodash.prototype[methodName] = function() {',
- ' var value = this.__wrapped__;',
- ' func.apply(value, arguments);',
- '',
- ' // avoid array-like object bugs with `Array#shift` and `Array#splice`',
- ' // in Firefox < 10 and IE < 9',
- ' if (!support.spliceObjects && value.length === 0) {',
- ' delete value[0];',
- ' }',
- ' return this;',
- ' };',
- '});',
- '',
- '// add `Array` accessor functions to the wrapper',
- funcName + "(['concat', 'join', 'slice'], function(methodName) {",
- ' var func = arrayRef[methodName];',
- ' lodash.prototype[methodName] = function() {',
- ' var value = this.__wrapped__,',
- ' result = func.apply(value, arguments);',
- '',
- ' if (this.__chain__) {',
- ' result = new lodashWrapper(result);',
- ' result.__chain__ = true;',
- ' }',
- ' return result;',
- ' };',
- '});',
- ''
- ].join('\n' + indent);
- });
-
- // replace `_.chain` assignment
- source = source.replace(getMethodAssignments(source), function(match) {
- return match.replace(/^( *lodash\.chain *= *)[\s\S]+?(?=;\n)/m, '$1chain')
- });
-
- // move `mixin(lodash)` to after the method assignments
- source = source.replace(/(?:\s*\/\/.*)*\n( *)mixin\(lodash\).+/, '');
- source = source.replace(getMethodAssignments(source), function(match) {
- var indent = /^ *(?=lodash\.)/m.exec(match)[0];
- return match + [
- '',
- '',
- '// add functions to `lodash.prototype`',
- 'mixin(lodash);'
- ].join('\n' + indent);
- });
-
- // move the `lodash.prototype.chain` assignment to after `mixin(lodash)`
- source = source
- .replace(/^ *lodash\.prototype\.chain *=[\s\S]+?;\n/m, '')
- .replace(/^( *)lodash\.prototype\.value *=/m, '$1lodash.prototype.chain = wrapperChain;\n$&');
-
- return source;
- }
-
- /**
- * Adds build `commands` to the copyright/license header of the `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {Array} [commands=[]] An array of commands.
- * @returns {String} Returns the modified source.
- */
- function addCommandsToHeader(source, commands) {
- return source.replace(/(\/\**\n)( \*)( *@license[\s*]+)( *Lo-Dash [\w.-]+)(.*)/, function() {
- // remove `node path/to/build.js` from `commands`
- if (reNode.test(commands[0])) {
- commands.splice(0, 2);
- }
- // add quotes to commands with spaces or equals signs
- commands = _.map(commands, function(command) {
- var separator = (command.match(/[= ]/) || [''])[0];
- if (separator) {
- var pair = command.split(separator);
- command = pair[0] + separator + '"' + pair[1] + '"';
- }
- // escape newlines, carriage returns, multi-line comment end tokens
- command = command
- .replace(/\n/g, '\\n')
- .replace(/\r/g, '\\r')
- .replace(/\*\//g, '*\\/');
-
- return command;
- });
- // add build commands to copyright/license header
- var parts = slice.call(arguments, 1);
- return (
- parts[0] +
- parts[1] +
- parts[2] + parts[3] + ' (Custom Build)' + parts[4] + '\n' +
- parts[1] + ' Build: `lodash ' + commands.join(' ') + '`'
- );
- });
- }
-
- /**
- * Compiles template files matched by the given file path `pattern` into a
- * single source, extending `_.templates` with precompiled templates named after
- * each template file's basename.
- *
- * @private
- * @param {String} [pattern='/*.jst'] The file path pattern.
- * @param {Object} options The options object.
- * @returns {String} Returns the compiled source.
- */
- function buildTemplate(pattern, options) {
- pattern || (pattern = path.join(cwd, '*.jst'));
-
- var directory = path.dirname(pattern);
-
- var source = [
- ';(function(window) {',
- ' var undefined;',
- '',
- ' var objectTypes = {',
- " 'function': true,",
- " 'object': true",
- ' };',
- '',
- " var freeExports = objectTypes[typeof exports] && typeof require == 'function' && exports;",
- '',
- " var freeModule = objectTypes[typeof module] && module && module.exports == freeExports && module;",
- '',
- " var freeGlobal = objectTypes[typeof global] && global;",
- ' if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {',
- ' window = freeGlobal;',
- ' }',
- '',
- ' var templates = {},',
- ' _ = window._;',
- ''
- ];
-
- // convert to a regexp
- pattern = RegExp(
- path.basename(pattern)
- .replace(/[.+?^=!:${}()|[\]\/\\]/g, '\\$&')
- .replace(/\*/g, '.*?') + '$'
- );
-
- fs.readdirSync(directory).forEach(function(filename) {
- var filePath = path.join(directory, filename);
- if (pattern.test(filename)) {
- var text = fs.readFileSync(filePath, 'utf8'),
- precompiled = cleanupCompiled(getFunctionSource(_.template(text, null, options))),
- prop = filename.replace(/\..*$/, '');
-
- source.push(" templates['" + prop.replace(/['\n\r\t]/g, '\\$&') + "'] = " + precompiled + ';', '');
- }
- });
-
- source.push(
- " if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {",
- " define(['" + options.moduleId + "'], function(lodash) {",
- ' _ = lodash;',
- ' lodash.templates = lodash.extend(lodash.templates || {}, templates);',
- ' });',
- " } else if (freeExports && !freeExports.nodeType) {",
- " _ = require('" + options.moduleId + "');",
- " if (freeModule) {",
- ' (freeModule.exports = templates).templates = templates;',
- ' } else {',
- ' freeExports.templates = templates;',
- ' }',
- ' } else if (_) {',
- ' _.templates = _.extend(_.templates || {}, templates);',
- ' }',
- '}(this));'
- );
-
- return source.join('\n');
- }
-
- /**
- * Capitalizes a given string.
- *
- * @private
- * @param {String} string The string to capitalize.
- * @returns {String} Returns the capitalized string.
- */
- function capitalize(string) {
- return string[0].toUpperCase() + string.slice(1);
- }
-
- /**
- * Removes unnecessary semicolons and whitespace from compiled code.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function cleanupCompiled(source) {
- return source.replace(/([{}]) *;/g, '$1');
- }
-
- /**
- * Removes unnecessary comments, whitespace, and pseudo private properties.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function cleanupSource(source) {
- return source
- // remove pseudo private properties
- .replace(/(?:(?:\s*\/\/.*)*\s*lodash\._[^=]+=.+\n)+/g, '\n')
- // remove extraneous whitespace
- .replace(/^ *\n/gm, '\n')
- // remove lines with just whitespace and semicolons
- .replace(/^ *;\n/gm, '')
- // consolidate multiple newlines
- .replace(/\n{3,}/g, '\n\n')
- // consolidate consecutive horizontal rule comment separators
- .replace(/(?:\s*\/\*-+\*\/\s*){2,}/g, function(separators) {
- return separators.match(/^\s*/)[0] + separators.slice(separators.lastIndexOf('/*'));
- });
- }
-
- /**
- * Writes the help message to standard output.
- *
- * @private
- */
- function displayHelp() {
- console.log([
- '',
- ' Commands:',
- '',
- ' lodash backbone Build with only methods required by Backbone',
- ' lodash legacy Build tailored for older environments without ES5 support',
- ' lodash modern Build tailored for newer environments with ES5 support',
- ' lodash mobile Build without method compilation and most bug fixes for old browsers',
- ' lodash strict Build with `_.assign`, `_.bindAll`, & `_.defaults` in strict mode',
- ' lodash underscore Build tailored for projects already using Underscore',
- ' lodash include=... Comma separated method/category names to include in the build',
- ' lodash minus=... Comma separated method/category names to remove from those included in the build',
- ' lodash plus=... Comma separated method/category names to add to those included in the build',
- ' lodash category=... Comma separated categories of methods to include in the build (case-insensitive)',
- ' (i.e. “arrays”, “chaining”, “collections”, “functions”, “objects”, and “utilities”)',
- ' lodash exports=... Comma separated names of ways to export the `lodash` function',
- ' (i.e. “amd”, “commonjs”, “global”, “node”, and “none”)',
- ' lodash iife=... Code to replace the immediately-invoked function expression that wraps Lo-Dash',
- ' (e.g. `lodash iife="!function(window){%output%}(this)"`)',
- '',
- ' lodash template=... File path pattern used to match template files to precompile',
- ' (e.g. `lodash template=./*.jst`)',
- ' lodash settings=... Template settings used when precompiling templates',
- ' (e.g. `lodash settings="{interpolate:/{{([\\s\\S]+?)}}/g}"`)',
- ' lodash moduleId=... The AMD module ID of Lo-Dash, which defaults to “lodash”, used by precompiled templates',
- '',
- ' All arguments, except `legacy` with `mobile`, `modern`, or `underscore`, may be combined.',
- ' Unless specified by `-o` or `--output`, all files created are saved to the current working directory.',
- '',
- ' Options:',
- '',
- ' -c, --stdout Write output to standard output',
- ' -d, --debug Write only the non-minified development output',
- ' -h, --help Display help information',
- ' -m, --minify Write only the minified production output',
- ' -o, --output Write output to a given path/filename',
- ' -p, --source-map Generate a source map for the minified output, using an optional source map URL',
- ' -s, --silent Skip status updates normally logged to the console',
- ' -V, --version Output current version of Lo-Dash',
- ''
- ].join('\n'));
- }
-
- /**
- * Gets the aliases associated with a given function name.
- *
- * @private
- * @param {String} methodName The name of the method to get aliases for.
- * @returns {Array} Returns an array of aliases.
- */
- function getAliases(methodName) {
- return (realToAliasMap[methodName] || []).filter(function(methodName) {
- return !dependencyMap[methodName];
- });
- }
-
- /**
- * Gets the category of the given method name.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} methodName The method name.
- * @returns {String} Returns the method name's category.
- */
- function getCategory(source, methodName) {
- var result = /@category +(\w+)/.exec(matchFunction(source, methodName));
- if (result) {
- return result[1];
- }
- // check for the `_.chain` alias
- return methodName == 'chain' ? 'Chaining' : '';
- }
-
- /**
- * Gets an array of category dependencies for a given category.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} category The category.
- * @returns {Array} Returns an array of cetegory dependants.
- */
- function getCategoryDependencies(source, category) {
- var methods = _.uniq(getMethodsByCategory(source, category).reduce(function(result, methodName) {
- push.apply(result, getDependencies(methodName));
- return result;
- }, []));
-
- var categories = _.uniq(methods.map(function(methodName) {
- return getCategory(source, methodName);
- }));
-
- return categories.filter(function(other) {
- return other != category;
- });
- }
-
- /**
- * Gets an array of depenants for the given method name(s).
- *
- * @private
- * @param {String} methodName A method name or array of method names.
- * @returns {Array} Returns an array of method dependants.
- */
- function getDependants(methodName) {
- // iterate over the `dependencyMap`, adding names of methods
- // that have the `methodName` as a dependency
- var methodNames = _.isArray(methodName) ? methodName : [methodName];
- return _.reduce(dependencyMap, function(result, dependencies, otherName) {
- if (_.some(methodNames, function(methodName) {
- return _.contains(dependencies, methodName);
- })) {
- result.push(otherName);
- }
- return result;
- }, []);
- }
-
- /**
- * Gets an array of dependencies for a given method name. If passed an array
- * of dependencies it will return an array containing the given dependencies
- * plus any additional detected sub-dependencies.
- *
- * @private
- * @param {Array|String} methodName A method name or array of dependencies to query.
- * @param- {Object} [stackA=[]] Internally used track queried methods.
- * @returns {Array} Returns an array of method dependencies.
- */
- function getDependencies(methodName, stack) {
- var dependencies = _.isArray(methodName) ? methodName : dependencyMap[methodName];
- if (!dependencies) {
- return [];
- }
- stack || (stack = []);
-
- // recursively accumulate the dependencies of the `methodName` function, and
- // the dependencies of its dependencies, and so on
- return _.uniq(dependencies.reduce(function(result, otherName) {
- if (!_.contains(stack, otherName)) {
- stack.push(otherName);
- result.push.apply(result, getDependencies(otherName, stack).concat(otherName));
- }
- return result;
- }, []));
- }
-
- /**
- * Gets the formatted source of the given function.
- *
- * @private
- * @param {Function} func The function to process.
- * @param {String} indent The function indent.
- * @returns {String} Returns the formatted source.
- */
- function getFunctionSource(func, indent) {
- var source = func.source || (func + '');
- if (indent == null) {
- indent = ' ';
- }
- // format leading whitespace
- return source.replace(/\n(?:.*)/g, function(match, index) {
- match = match.slice(1);
- return (
- '\n' + indent +
- (match == '}' && !_.contains(source, '}', index + 2) ? '' : ' ')
- ) + match;
- });
- }
-
- /**
- * Gets the indent of the given function.
- *
- * @private
- * @param {Function} func The function to process.
- * @returns {String} Returns the indent.
- */
- function getIndent(func) {
- return /^ *(?=\S)/m.exec(func.source || func)[0];
- }
-
- /**
- * Gets the `_.isArguments` fallback from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @returns {String} Returns the `isArguments` fallback.
- */
- function getIsArgumentsFallback(source) {
- return (source.match(/(?:\s*\/\/.*)*\n( *)if *\((?:!support\.argsClass|!isArguments)[\s\S]+?\n *};\n\1}/) || [''])[0];
- }
-
- /**
- * Gets the `_.isArray` fallback from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @returns {String} Returns the `isArray` fallback.
- */
- function getIsArrayFallback(source) {
- return matchFunction(source, 'isArray')
- .replace(/^[\s\S]+?=\s*nativeIsArray\b/, '')
- .replace(/[;\s]+$/, '');
- }
-
- /**
- * Gets the `_.isFunction` fallback from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @returns {String} Returns the `isFunction` fallback.
- */
- function getIsFunctionFallback(source) {
- return (source.match(/(?:\s*\/\/.*)*\n( *)if *\(isFunction\(\/x\/[\s\S]+?\n *};\n\1}/) || [''])[0];
- }
-
- /**
- * Gets the `createObject` fallback from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @returns {String} Returns the `isArguments` fallback.
- */
- function getCreateObjectFallback(source) {
- return (source.match(/(?:\s*\/\/.*)*\n( *)if *\((?:!nativeCreate)[\s\S]+?\n *};\n\1}/) || [''])[0];
- }
-
- /**
- * Gets the `iteratorTemplate` from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @returns {String} Returns the `iteratorTemplate`.
- */
- function getIteratorTemplate(source) {
- return (source.match(/^( *)var iteratorTemplate *= *[\s\S]+?\n\1.+?;\n/m) || [''])[0];
- }
-
- /**
- * Gets the Lo-Dash method assignments snippet from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @returns {String} Returns the method assignments snippet.
- */
- function getMethodAssignments(source) {
- return (source.match(/\/\*-+\*\/\n(?:\s*\/\/.*)*\s*lodash\.\w+ *=[\s\S]+?lodash\.VERSION *=.+/) || [''])[0];
- }
-
- /**
- * Gets the names of methods in `source` belonging to the given `category`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} category The category to filter by.
- * @returns {Array} Returns a new array of method names belonging to the given category.
- */
- function getMethodsByCategory(source, category) {
- return allMethods.filter(function(methodName) {
- return getCategory(source, methodName) == category;
- });
- }
-
- /**
- * Gets the real name, not alias, of a given method name.
- *
- * @private
- * @param {String} methodName The name of the method to resolve.
- * @returns {String} Returns the real method name.
- */
- function getRealName(methodName) {
- return (!dependencyMap[methodName] && aliasToRealMap[methodName]) || methodName;
- }
-
- /**
- * Determines if all functions of the given names have been removed from `source`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} [funcName1, funcName2, ...] The names of functions to check.
- * @returns {Boolean} Returns `true` if all functions have been removed, else `false`.
- */
- function isRemoved(source) {
- return slice.call(arguments, 1).every(function(funcName) {
- return !(
- matchFunction(source, funcName) ||
- RegExp('^ *lodash\\.prototype\\.' + funcName + ' *=[\\s\\S]+?;\\n', 'm').test(source)
- );
- });
- }
-
- /**
- * Searches `source` for a `funcName` function declaration, expression, or
- * assignment and returns the matched snippet.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} funcName The name of the function to match.
- * @returns {String} Returns the matched function snippet.
- */
- function matchFunction(source, funcName) {
- var result = source.match(RegExp(
- multilineComment +
- // match variable declarations with `createIterator` or `overloadWrapper`
- '( *)var ' + funcName + ' *=.*?(?:createIterator\\([\\s\\S]+?|overloadWrapper\\([\\s\\S]+?\\n\\1})\\);\\n'
- ));
-
- result || (result = source.match(RegExp(
- multilineComment +
- // begin non-capturing group
- '( *)(?:' +
- // match a function declaration
- 'function ' + funcName + '\\b[\\s\\S]+?\\n\\1}|' +
- // match a variable declaration with function expression
- 'var ' + funcName + ' *=.*?function[\\s\\S]+?\\n\\1}(?:\\(\\)\\))?;' +
- // end non-capturing group
- ')\\n'
- )));
-
- result || (result = source.match(RegExp(
- multilineComment +
- // match simple variable declarations
- '( *)var ' + funcName + ' *=.+?;\\n'
- )));
-
- return /@type +Function|\b(?:function\s*\w*|createIterator|overloadWrapper)\(/.test(result) ? result[0] : '';
- }
-
- /**
- * Converts a comma separated options string into an array.
- *
- * @private
- * @param {String} value The option to convert.
- * @returns {Array} Returns the new converted array.
- */
- function optionToArray(value) {
- return _.compact(_.isArray(value)
- ? value
- : value.match(/\w+=(.*)$/)[1].split(/, */)
- );
- }
-
- /**
- * Converts a comma separated options string into an array containing
- * only real method names.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} value The option to convert.
- * @returns {Array} Returns the new converted array.
- */
- function optionToMethodsArray(source, value) {
- var methodNames = optionToArray(value);
-
- // convert aliases to real method names
- methodNames = methodNames.map(getRealName);
-
- // remove nonexistent and duplicate method names
- return _.uniq(_.intersection(allMethods, methodNames));
- }
-
- /**
- * Removes all references to `identifier` from `createIterator` in `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} identifier The name of the variable or property to remove.
- * @returns {String} Returns the modified source.
- */
- function removeFromCreateIterator(source, identifier) {
- var snippet = matchFunction(source, 'createIterator');
- if (!snippet) {
- return source;
- }
- // remove data object property assignment
- var modified = snippet.replace(RegExp("^(?: *\\/\\/.*\\n)* *(\\w+)\\." + identifier + " *= *(.+\\n+)", 'm'), function(match, object, postlude) {
- return RegExp('\\b' + object + '\\.').test(postlude) ? postlude : '';
- });
-
- source = source.replace(snippet, function() {
- return modified;
- });
-
- // clip to the `factory` assignment
- snippet = modified.match(/Function\([\s\S]+$/)[0];
-
- // remove `factory` arguments
- source = source.replace(snippet, function(match) {
- return match
- .replace(RegExp('\\b' + identifier + '\\b,? *', 'g'), '')
- .replace(/, *(?=',)/, '')
- .replace(/,(?=\s*\))/, '');
- });
-
- return removeFromGetObject(source, identifier);
- }
-
- /**
- * Removes all references to `identifier` from `getObject` in `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} identifier The name of the property to remove.
- * @returns {String} Returns the modified source.
- */
- function removeFromGetObject(source, identifier) {
- return source.replace(matchFunction(source, 'getObject'), function(match) {
- // remove object property assignments
- return match
- .replace(RegExp("^(?: *\\/\\/.*\\n)* *'" + identifier + "':.+\\n+", 'm'), '')
- .replace(/,(?=\s*})/, '');
- });
- }
-
- /**
- * Removes all references to `identifier` from `releaseObject` in `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} identifier The name of the property to remove.
- * @returns {String} Returns the modified source.
- */
- function removeFromReleaseObject(source, identifier) {
- return source.replace(matchFunction(source, 'releaseObject'), function(match) {
- // remove object property assignments
- return match.replace(RegExp("(?:(^ *)| *)(\\w+)\\." + identifier + " *= *(.+\\n+)", 'm'), function(match, indent, object, postlude) {
- return (indent || '') + RegExp('\\b' + object + '\\.').test(postlude) ? postlude : '';
- });
- });
- }
-
- /**
- * Removes the `funcName` function declaration, expression, or assignment and
- * associated code from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} funcName The name of the function to remove.
- * @returns {String} Returns the modified source.
- */
- function removeFunction(source, funcName) {
- var snippet;
-
- // remove function
- if (funcName == 'runInContext') {
- source = removeRunInContext(source, funcName);
- } else if ((snippet = matchFunction(source, funcName))) {
- source = source.replace(snippet, '');
- }
-
- // remove method assignment from `lodash.prototype`
- source = source.replace(RegExp('^ *lodash\\.prototype\\.' + funcName + ' *=[\\s\\S]+?;\\n', 'm'), '');
-
- // remove pseudo private methods
- source = source.replace(RegExp('^(?: *//.*\\s*)* *lodash\\._' + funcName + ' *=[\\s\\S]+?;\\n', 'm'), '');
-
- // grab the method assignments snippet
- snippet = getMethodAssignments(source);
-
- // remove assignment and aliases
- var modified = getAliases(funcName).concat(funcName).reduce(function(result, otherName) {
- return result.replace(RegExp('^(?: *//.*\\s*)* *lodash\\.' + otherName + ' *=[\\s\\S]+?;\\n', 'm'), '');
- }, snippet);
-
- // replace with the modified snippet
- source = source.replace(snippet, function() {
- return modified;
- });
-
- return removeFromCreateIterator(source, funcName);
- }
-
- /**
- * Removes the `_.isArguments` fallback from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeIsArgumentsFallback(source) {
- return source.replace(getIsArgumentsFallback(source), '');
- }
-
- /**
- * Removes the `_.isArray` fallback from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeIsArrayFallback(source) {
- return source.replace(getIsArrayFallback(source), '');
- }
-
- /**
- * Removes the `_.isFunction` fallback from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeIsFunctionFallback(source) {
- return source.replace(getIsFunctionFallback(source), '');
- }
-
- /**
- * Removes the `createObject` fallback from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeCreateObjectFallback(source) {
- return source.replace(getCreateObjectFallback(source), '');
- }
-
- /**
- * Removes the binding optimization from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeBindingOptimization(source) {
- source = removeVar(source, 'fnToString');
- source = removeVar(source, 'reThis');
-
- // remove `reThis` from `createCallback`
- source = source.replace(matchFunction(source, 'createCallback'), function(match) {
- return match.replace(/\s*\|\|\s*\(reThis[\s\S]+?\)\)\)/, '');
- });
-
- return source;
- }
-
-
- /**
- * Removes the `Object.keys` object iteration optimization from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeKeysOptimization(source) {
- source = removeFromCreateIterator(source, 'useKeys');
-
- // remove optimized branch in `iteratorTemplate`
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match.replace(/^(?: *\/\/.*\n)* *["']( *)<% *if *\(useHas *&& *useKeys[\s\S]+?["']\1<% *} *else *{ *%>.+\n([\s\S]+?) *["']\1<% *} *%>.+/m, "'\\n' +\n$2");
- });
-
- return source;
- }
-
- /**
- * Removes all `lodashWrapper` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeLodashWrapper(source) {
- source = removeFunction(source, 'lodashWrapper');
-
- // remove `lodashWrapper.prototype` assignment
- source = source.replace(/(?:\s*\/\/.*)*\n *lodashWrapper\.prototype *=.+/, '');
-
- // replace `new lodashWrapper` with `new lodash`
- source = source.replace(/\bnew lodashWrapper\b/g, 'new lodash');
-
- return source;
- }
-
- /**
- * Removes all `support.argsObject` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportArgsObject(source) {
- source = removeSupportProp(source, 'argsObject');
-
- // remove `argsAreObjects` from `_.isEqual`
- source = source.replace(matchFunction(source, 'isEqual'), function(match) {
- return match.replace(/!support.\argsObject[^:]+:\s*/g, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `support.argsClass` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportArgsClass(source) {
- source = removeSupportProp(source, 'argsClass');
-
- // replace `support.argsClass` in the `_.isArguments` fallback
- source = source.replace(getIsArgumentsFallback(source), function(match) {
- return match.replace(/!support\.argsClass/g, '!isArguments(arguments)');
- });
-
- // remove `support.argsClass` from `_.isEmpty`
- source = source.replace(matchFunction(source, 'isEmpty'), function(match) {
- return match.replace(/\s*\(support\.argsClass\s*\?([^:]+):.+?\)\)/g, '$1');
- });
-
- // remove `support.argsClass` from `_.isPlainObject`
- _.each(['shimIsPlainObject', 'isPlainObject'], function(methodName) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match.replace(/\s*\|\|\s*\(!support\.argsClass[\s\S]+?\)\)/, '');
- });
- });
-
- return source;
- }
-
- /**
- * Removes all `support.enumErrorProps` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportEnumErrorProps(source) {
- source = removeSupportProp(source, 'enumErrorProps');
-
- // remove `support.enumErrorProps` from `iteratorTemplate`
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match
- .replace(/(?: *\/\/.*\n)* *["'] *(?:<% *)?if *\(support\.enumErrorProps *(?:&&|\))(.+?}["']|[\s\S]+?<% *} *(?:%>|["'])).+/g, '')
- .replace(/support\.enumErrorProps\s*\|\|\s*/g, '');
- });
-
- return source;
- }
-
-
- /**
- * Removes all `support.enumPrototypes` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportEnumPrototypes(source) {
- source = removeSupportProp(source, 'enumPrototypes');
-
- // remove `support.enumPrototypes` from `_.keys`
- source = source.replace(matchFunction(source, 'keys'), function(match) {
- return match
- .replace(/\(support\.enumPrototypes[^)]+\)(?:\s*\|\|\s*)?/, '')
- .replace(/\s*if *\(\s*\)[^}]+}/, '');
- });
-
- // remove `support.enumPrototypes` from `iteratorTemplate`
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match
- .replace(/(?: *\/\/.*\n)* *["'] *(?:<% *)?if *\(support\.enumPrototypes *(?:&&|\))(.+?}["']|[\s\S]+?<% *} *(?:%>|["'])).+/g, '')
- .replace(/support\.enumPrototypes\s*\|\|\s*/g, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `support.nodeClass` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportNodeClass(source) {
- source = removeFunction(source, 'isNode');
- source = removeSupportProp(source, 'nodeClass');
-
- // remove `support.nodeClass` from `_.clone` and `shimIsPlainObject`
- _.each(['clone', 'shimIsPlainObject'], function(methodName) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match.replace(/\s*\|\|\s*\(!support\.nodeClass[\s\S]+?\)\)/, '');
- });
- });
-
- // remove `support.nodeClass` from `_.isEqual`
- source = source.replace(matchFunction(source, 'isEqual'), function(match) {
- return match.replace(/\s*\|\|\s*\(!support\.nodeClass[\s\S]+?\)\)\)/, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `support.nonEnumArgs` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportNonEnumArgs(source) {
- source = removeSupportProp(source, 'nonEnumArgs');
-
- // remove `support.nonEnumArgs` from `_.keys`
- source = source.replace(matchFunction(source, 'keys'), function(match) {
- return match
- .replace(/(?:\s*\|\|\s*)?\(support\.nonEnumArgs[\s\S]+?\)\)/, '')
- .replace(/\s*if *\(\s*\)[^}]+}/, '');
- });
-
- // remove `nonEnumArgs` from `iteratorTemplate`
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match
- .replace(/(?: *\/\/.*\n)*( *["'] *)<% *} *else *if *\(support\.nonEnumArgs[\s\S]+?(\1<% *} *%>.+)/, '$2')
- .replace(/\s*\|\|\s*support\.nonEnumArgs/, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `support.nonEnumShadows` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportNonEnumShadows(source) {
- source = removeSupportProp(source, 'nonEnumShadows');
- source = removeVar(source, 'nonEnumProps');
- source = removeVar(source, 'shadowedProps');
- source = removeFromCreateIterator(source, 'shadowedProps');
-
- // remove nested `nonEnumProps` assignments
- source = source.replace(/^ *\(function[\s\S]+?\n *var length\b[\s\S]+?shadowedProps[\s\S]+?}\(\)\);\n/m, '');
-
- // remove `support.nonEnumShadows` from `iteratorTemplate`
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match.replace(/(?: *\/\/.*\n)* *["']( *)<% *if *\(support\.nonEnumShadows[\s\S]+?["']\1<% *} *%>.+/, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `support.ownLast` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportOwnLast(source) {
- source = removeSupportProp(source, 'ownLast');
-
- // remove `support.ownLast` from `shimIsPlainObject`
- source = source.replace(matchFunction(source, 'shimIsPlainObject'), function(match) {
- return match.replace(/(?:\s*\/\/.*)*\n( *)if *\(support\.ownLast[\s\S]+?\n\1}/, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `support.spliceObjects` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportSpliceObjects(source) {
- source = removeSupportProp(source, 'spliceObjects');
-
- // remove `support.spliceObjects` fix from the `Array` function mixins
- source = source.replace(/(?:\s*\/\/.*)*\n( *)if *\(!support\.spliceObjects[\s\S]+?(?:{\s*}|\n\1})/, '');
-
- return source;
- }
-
- /**
- * Removes all `support.unindexedChars` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSupportUnindexedChars(source) {
- source = removeSupportProp(source, 'unindexedChars');
-
- // remove `support.unindexedChars` from `_.at`
- source = source.replace(matchFunction(source, 'at'), function(match) {
- return match.replace(/^ *if *\(support\.unindexedChars[^}]+}\n+/m, '');
- });
-
- // remove `support.unindexedChars` from `_.reduceRight`
- source = source.replace(matchFunction(source, 'reduceRight'), function(match) {
- return match.replace(/}\s*else if *\(support\.unindexedChars[^}]+/, '');
- });
-
- // remove `support.unindexedChars` from `_.toArray`
- source = source.replace(matchFunction(source, 'toArray'), function(match) {
- return match.replace(/(return\b).+?support\.unindexedChars[^:]+:\s*/, '$1 ');
- });
-
- // remove `support.unindexedChars` from `iteratorTemplate`
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match
- .replace(/'if *\(<%= *array *%>[^']*/, '$&\\n')
- .replace(/(?: *\/\/.*\n)* *["']( *)<% *if *\(support\.unindexedChars[\s\S]+?["']\1<% *} *%>.+/, '');
- });
-
- return source;
- }
-
- /**
- * Removes all `runInContext` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeRunInContext(source) {
- source = removeVar(source, 'contextProps');
-
- // replace reference in `reThis` assignment
- source = source.replace(/\btest\(runInContext\)/, 'test(function() { return this; })');
-
- // remove function scaffolding, leaving most of its content
- source = source.replace(matchFunction(source, 'runInContext'), function(match) {
- return match
- .replace(/^[\s\S]+?function runInContext[\s\S]+?context *= *context.+| *return lodash[\s\S]+$/g, '')
- .replace(/^ {4}/gm, ' ');
- });
-
- // cleanup adjusted source
- source = source
- .replace(/\bcontext\b/g, 'window')
- .replace(/(?:\n +\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\/)?\n *var Array *=[\s\S]+?;\n/, '')
- .replace(/(return *|= *)_([;)])/g, '$1lodash$2')
- .replace(/^ *var _ *=.+\n+/m, '');
-
- return source;
- }
-
- /**
- * Removes all `setImmediate` references from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @returns {String} Returns the modified source.
- */
- function removeSetImmediate(source) {
- source = removeVar(source, 'setImmediate');
-
- // remove the `setImmediate` fork of `_.defer`.
- source = source.replace(/(?:\s*\/\/.*)*\n( *)if *\(isV8 *&& *freeModule[\s\S]+?\n\1}/, '');
-
- return source;
- }
-
- /**
- * Removes a given property from the `support` object in `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} varName The name of the `support` property to remove.
- * @returns {String} Returns the modified source.
- */
- function removeSupportProp(source, propName) {
- return source.replace(RegExp(
- multilineComment +
- // match a `try` block
- '(?: *try\\b.+\\n)?' +
- // match the `support` property assignment
- ' *support\\.' + propName + ' *=.+\\n' +
- // match `catch` block
- '(?:( *).+?catch\\b[\\s\\S]+?\\n\\1}\\n)?'
- ), '');
- }
-
- /**
- * Removes a given variable from `source`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} varName The name of the variable to remove.
- * @returns {String} Returns the modified source.
- */
- function removeVar(source, varName) {
- // simplify complex variable assignments
- if (/^(?:cloneableClasses|contextProps|ctorByClass|nonEnumProps|shadowedProps|whitespace)$/.test(varName)) {
- source = source.replace(RegExp('(var ' + varName + ' *=)[\\s\\S]+?;\\n\\n'), '$1=null;\n\n');
- }
-
- source = removeFunction(source, varName);
-
- source = source.replace(RegExp(
- multilineComment +
- // match a variable declaration that's not part of a declaration list
- '( *)var ' + varName + ' *= *(?:.+?(?:;|&&\\n[^;]+;)|(?:\\w+\\(|{)[\\s\\S]+?\\n\\1.+?;)\\n|' +
- // match a variable in a declaration list
- '^ *' + varName + ' *=.+?,\\n',
- 'm'
- ), '');
-
- // remove a varaible at the start of a variable declaration list
- source = source.replace(RegExp('(var +)' + varName + ' *=.+?,\\s+'), '$1');
-
- // remove a variable at the end of a variable declaration list
- source = source.replace(RegExp(',\\s*' + varName + ' *=.+?;'), ';');
-
- return source;
- }
-
- /**
- * Replaces the `funcName` function body in `source` with `funcValue`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} varName The name of the function to replace.
- * @returns {String} Returns the modified source.
- */
- function replaceFunction(source, funcName, funcValue) {
- var snippet = matchFunction(source, funcName);
- if (!snippet) {
- return source;
- }
- // clip snippet after the JSDoc comment block
- snippet = snippet.replace(/^\s*(?:\/\/.*|\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\/)\n/, '');
-
- source = source.replace(snippet, function() {
- return funcValue
- .replace(RegExp('^' + getIndent(funcValue), 'gm'), getIndent(snippet))
- .trimRight() + '\n';
- });
-
- return source;
- }
-
- /**
- * Replaces the `support` object `propName` property value in `source` with `propValue`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {String} varName The name of the `support` property to replace.
- * @returns {String} Returns the modified source.
- */
- function replaceSupportProp(source, propName, propValue) {
- return source.replace(RegExp(
- // match a `try` block
- '(?: *try\\b.+\\n)?' +
- // match the `support` property assignment
- '( *support\\.' + propName + ' *=).+\\n' +
- // match `catch` block
- '(?:( *).+?catch\\b[\\s\\S]+?\\n\\2}\\n)?'
- ), function(match, left) {
- return left + ' ' + propValue + ';\n';
- });
- }
-
- /**
- * Replaces the `varName` variable declaration value in `source` with `varValue`.
- *
- * @private
- * @param {String} source The source to inspect.
- * @param {String} varName The name of the variable to replace.
- * @returns {String} Returns the modified source.
- */
- function replaceVar(source, varName, varValue) {
- // replace a variable that's not part of a declaration list
- var result = source.replace(RegExp(
- '(( *)var ' + varName + ' *=)' +
- '(?:.+?;|(?:Function\\(.+?|.*?[^,])\\n[\\s\\S]+?\\n\\2.+?;)\\n'
- ), function(match, left) {
- return left + ' ' + varValue + ';\n';
- });
-
- if (source == result) {
- // replace a varaible at the start or middle of a declaration list
- result = source.replace(RegExp('((?:var|\\n) +' + varName + ' *=).+?,'), function(match, left) {
- return left + ' ' + varValue + ',';
- });
- }
- if (source == result) {
- // replace a variable at the end of a variable declaration list
- result = source.replace(RegExp('(,\\s*' + varName + ' *=).+?;'), function(match, left) {
- return left + ' ' + varValue + ';';
- });
- }
- return result;
- }
-
- /**
- * Hard-codes the `strict` template option value for `iteratorTemplate`.
- *
- * @private
- * @param {String} source The source to process.
- * @param {Boolean} value The value to set.
- * @returns {String} Returns the modified source.
- */
- function setUseStrictOption(source, value) {
- // inject or remove the "use strict" directive
- source = source.replace(/^([\s\S]*?function[^{]+{)(?:\s*'use strict';)?/, '$1' + (value ? "\n 'use strict';" : ''));
-
- // replace `strict` branch in `iteratorTemplate` with hard-coded option
- source = source.replace(getIteratorTemplate(source), function(match) {
- return match.replace(/(template\()(?:\s*"'use strict.+)?/, '$1' + (value ? '\n "\'use strict\';\\n" +' : ''));
- });
-
- return source;
- }
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Creates a debug and/or minified build, executing the `callback` for each.
- * The `callback` is invoked with two arguments; (filePath, outputSource).
- *
- * Note: For a list of commands see `displayHelp()` or run `lodash --help`.
- *
- * @param {Array} [options=[]] An array of commands.
- * @param {Function} callback The function called per build.
- */
- function build(options, callback) {
- options || (options = []);
-
- // the debug version of `source`
- var debugSource;
-
- // used to specify the source map URL
- var sourceMapURL;
-
- // used to report invalid command-line arguments
- var invalidArgs = _.reject(options.slice(reNode.test(options[0]) ? 2 : 0), function(value, index, options) {
- if (/^(?:-o|--output)$/.test(options[index - 1]) ||
- /^(?:category|exclude|exports|iife|include|moduleId|minus|plus|settings|template)=.*$/.test(value)) {
- return true;
- }
- var result = _.contains([
- 'backbone',
- 'csp',
- 'legacy',
- 'mobile',
- 'modern',
- 'modularize',
- 'strict',
- 'underscore',
- '-c', '--stdout',
- '-d', '--debug',
- '-h', '--help',
- '-m', '--minify',
- '-n', '--no-dep',
- '-o', '--output',
- '-p', '--source-map',
- '-s', '--silent',
- '-V', '--version'
- ], value);
-
- if (!result && /^(?:-p|--source-map)$/.test(options[index - 1])) {
- result = true;
- sourceMapURL = value;
- }
- return result;
- });
-
- // report invalid arguments
- if (invalidArgs.length) {
- console.log(
- '\n' +
- 'Invalid argument' + (invalidArgs.length > 1 ? 's' : '') +
- ' passed: ' + invalidArgs.join(', ')
- );
- displayHelp();
- return;
- }
-
- // display help message
- if (_.find(options, function(arg) {
- return /^(?:-h|--help)$/.test(arg);
- })) {
- displayHelp();
- return;
- }
-
- // display `lodash.VERSION`
- if (_.find(options, function(arg) {
- return /^(?:-V|--version)$/.test(arg);
- })) {
- console.log(_.VERSION);
- return;
- }
-
- /*------------------------------------------------------------------------*/
-
- // backup `dependencyMap` to restore later
- var dependencyBackup = _.cloneDeep(dependencyMap);
-
- // used to specify a custom IIFE to wrap Lo-Dash
- var iife = options.reduce(function(result, value) {
- var match = value.match(/^iife=(.*)$/);
- return match ? match[1] : result;
- }, null);
-
- // the path to the source file
- var filePath = path.join(__dirname, 'lodash.js');
-
- // flag to specify a Backbone build
- var isBackbone = _.contains(options, 'backbone');
-
- // flag to specify a Content Security Policy build
- var isCSP = _.contains(options, 'csp') || _.contains(options, 'CSP');
-
- // flag to specify only creating the debug build
- var isDebug = _.contains(options, '-d') || _.contains(options, '--debug');
-
- // flag to indicate that a custom IIFE was specified
- var isIIFE = typeof iife == 'string';
-
- // flag to specify creating a source map for the minified source
- var isMapped = _.contains(options, '-p') || _.contains(options, '--source-map');
-
- // flag to specify only creating the minified build
- var isMinify = _.contains(options, '-m') || _.contains(options, '--minify');
-
- // flag to specify a mobile build
- var isMobile = _.contains(options, 'mobile');
-
- // flag to specify a modern build
- var isModern = isCSP || isMobile || _.contains(options, 'modern');
-
- // flag to specify a modularize build
- var isModularize = _.contains(options, 'modularize');
-
- // flag to specify a no-dependency build
- var isNoDep = _.contains(options, '-n') || _.contains(options, '--no-dep');
-
- // flag to specify writing output to standard output
- var isStdOut = _.contains(options, '-c') || _.contains(options, '--stdout');
-
- // flag to specify skipping status updates normally logged to the console
- var isSilent = isStdOut || _.contains(options, '-s') || _.contains(options, '--silent');
-
- // flag to specify `_.assign`, `_.bindAll`, and `_.defaults` are
- // constructed using the "use strict" directive
- var isStrict = _.contains(options, 'strict');
-
- // flag to specify an Underscore build
- var isUnderscore = isBackbone || _.contains(options, 'underscore');
-
- // flag to specify a legacy build
- var isLegacy = !(isModern || isUnderscore) && _.contains(options, 'legacy');
-
- // used to specify the ways to export the `lodash` function
- var exportsOptions = options.reduce(function(result, value) {
- return /^exports=.*$/.test(value) ? optionToArray(value).sort() : result;
- }, isUnderscore
- ? ['commonjs', 'global', 'node']
- : exportsAll.slice()
- );
-
- // used to specify the AMD module ID of Lo-Dash used by precompiled templates
- var moduleId = options.reduce(function(result, value) {
- var match = value.match(/^moduleId=(.*)$/);
- return match ? match[1] : result;
- }, 'lodash');
-
- // used to specify the output path for builds
- var outputPath = options.reduce(function(result, value, index) {
- if (/^(?:-o|--output)$/.test(value)) {
- result = options[index + 1];
- var dirname = path.dirname(result);
- fs.mkdirpSync(dirname);
- result = path.join(fs.realpathSync(dirname), path.basename(result));
- }
- return result;
- }, '');
-
- // used to match external template files to precompile
- var templatePattern = options.reduce(function(result, value) {
- var match = value.match(/^template=(.+)$/);
- return match
- ? path.join(fs.realpathSync(path.dirname(match[1])), path.basename(match[1]))
- : result;
- }, '');
-
- // used as the template settings for precompiled templates
- var templateSettings = options.reduce(function(result, value) {
- var match = value.match(/^settings=(.+)$/);
- return match
- ? _.assign(result, Function('return {' + match[1].replace(/^{|}$/g, '') + '}')())
- : result;
- }, _.assign(_.clone(_.templateSettings), {
- 'moduleId': moduleId
- }));
-
- // flag to specify a template build
- var isTemplate = !!templatePattern;
-
- // the lodash.js source
- var source = fs.readFileSync(filePath, 'utf8');
-
- // flags to specify export options
- var isAMD = _.contains(exportsOptions, 'amd'),
- isCommonJS = _.contains(exportsOptions, 'commonjs'),
- isGlobal = _.contains(exportsOptions, 'global'),
- isNode = _.contains(exportsOptions, 'node');
-
- /*------------------------------------------------------------------------*/
-
- var useLodashMethod = function(methodName) {
- if (_.contains(lodashOnlyMethods, methodName) || /^(?:assign|zipObject)$/.test(methodName)) {
- var methods = _.without.apply(_, [_.union(includeMethods, plusMethods)].concat(minusMethods));
- return _.contains(methods, methodName);
- }
- methods = _.without.apply(_, [plusMethods].concat(minusMethods));
- return _.contains(methods, methodName);
- };
-
- // delete the `_.findWhere` dependency map to enable its alias mapping
- if (!isUnderscore || useLodashMethod('findWhere')) {
- delete dependencyMap.findWhere;
- }
-
- // methods to include in the build
- var includeMethods = options.reduce(function(accumulator, value) {
- return /^include=.*$/.test(value)
- ? _.union(accumulator, optionToMethodsArray(source, value))
- : accumulator;
- }, []);
-
- // methods to remove from the build
- var minusMethods = options.reduce(function(accumulator, value) {
- return /^(?:exclude|minus)=.*$/.test(value)
- ? _.union(accumulator, optionToMethodsArray(source, value))
- : accumulator;
- }, []);
-
- // methods to add to the build
- var plusMethods = options.reduce(function(accumulator, value) {
- return /^plus=.*$/.test(value)
- ? _.union(accumulator, optionToMethodsArray(source, value))
- : accumulator;
- }, []);
-
- // methods categories to include in the build
- var categories = options.reduce(function(accumulator, value) {
- if (/^(category|exclude|include|minus|plus)=.+$/.test(value)) {
- var array = optionToArray(value);
- accumulator = _.union(accumulator, /^category=.*$/.test(value)
- ? array.map(function(category) { return capitalize(category.toLowerCase()); })
- : array.filter(function(category) { return /^[A-Z]/.test(category); })
- );
- }
- return accumulator;
- }, []);
-
- // names of methods to include in the build
- var buildMethods = !isTemplate && (function() {
- var result;
-
- // update dependencies
- if (isLegacy) {
- dependencyMap.defer = _.without(dependencyMap.defer, 'bind');
- }
- if (isModern) {
- dependencyMap.reduceRight = _.without(dependencyMap.reduceRight, 'isString');
-
- if (isMobile) {
- _.each(['assign', 'defaults'], function(methodName) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'keys');
- });
- }
- else {
- _.each(['isEmpty', 'isEqual', 'isPlainObject', 'keys'], function(methodName) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'isArguments');
- });
- }
- }
- if (isUnderscore) {
- if (!useLodashMethod('clone') && !useLodashMethod('cloneDeep')) {
- dependencyMap.clone = _.without(dependencyMap.clone, 'forEach', 'forOwn');
- }
- if (!useLodashMethod('contains')) {
- dependencyMap.contains = _.without(dependencyMap.contains, 'isString');
- }
- if (!useLodashMethod('flatten')) {
- dependencyMap.flatten = _.without(dependencyMap.flatten, 'createCallback');
- }
- if (!useLodashMethod('isEmpty')) {
- dependencyMap.isEmpty = ['isArray', 'isString'];
- }
- if (!useLodashMethod('isEqual')) {
- dependencyMap.isEqual = _.without(dependencyMap.isEqual, 'forIn', 'isArguments');
- }
- if (!useLodashMethod('pick')){
- dependencyMap.pick = _.without(dependencyMap.pick, 'forIn', 'isObject');
- }
- if (!useLodashMethod('template')) {
- dependencyMap.template = _.without(dependencyMap.template, 'keys', 'values');
- }
- if (!useLodashMethod('toArray')) {
- dependencyMap.toArray.push('isArray', 'map');
- }
- if (!useLodashMethod('where')) {
- dependencyMap.createCallback = _.without(dependencyMap.createCallback, 'isEqual');
- dependencyMap.where.push('find', 'isEmpty');
- }
-
- _.each(['clone', 'difference', 'intersection', 'isEqual', 'sortBy', 'uniq'], function(methodName) {
- if (methodName == 'clone'
- ? (!useLodashMethod('clone') && !useLodashMethod('cloneDeep'))
- : !useLodashMethod(methodName)
- ) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'getArray', 'getObject', 'releaseArray', 'releaseObject');
- }
- });
-
- _.each(['debounce', 'throttle'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- dependencyMap[methodName] = [];
- }
- });
-
- _.each(['difference', 'intersection', 'uniq'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- dependencyMap[methodName] = ['getIndexOf'].concat(_.without(dependencyMap[methodName], 'cacheIndexOf', 'createCache'));
- }
- });
-
- _.each(['flatten', 'uniq'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'overloadWrapper');
- }
- });
-
- _.each(['max', 'min'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'charAtCallback', 'isArray', 'isString');
- }
- });
- }
- if (isModern || isUnderscore) {
- dependencyMap.reduceRight = _.without(dependencyMap.reduceRight, 'isString');
-
- _.each(['assign', 'basicEach', 'defaults', 'forIn', 'forOwn', 'shimKeys'], function(methodName) {
- if (!(isUnderscore && useLodashMethod(methodName))) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'createIterator');
- }
- });
-
- _.each(['at', 'forEach', 'toArray'], function(methodName) {
- if (!(isUnderscore && useLodashMethod(methodName))) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'isString');
- }
- });
-
- if (!isMobile) {
- _.each(['every', 'find', 'filter', 'forEach', 'forIn', 'forOwn', 'map', 'reduce'], function(methodName) {
- if (!(isUnderscore && useLodashMethod(methodName))) {
- dependencyMap[methodName] = _.without(dependencyMap[methodName], 'isArguments', 'isArray');
- }
- });
-
- _.each(['max', 'min'], function(methodName) {
- if (!(isUnderscore && useLodashMethod(methodName))) {
- dependencyMap[methodName].push('forEach');
- }
- });
- }
- }
- // add method names explicitly
- if (includeMethods.length) {
- result = includeMethods;
- }
- // add method names required by Backbone and Underscore builds
- if (isBackbone && !result) {
- result = backboneDependencies;
- }
- else if (isUnderscore && !result) {
- result = underscoreMethods;
- }
- // add method names by category
- if (categories.length) {
- result = _.union(result || [], categories.reduce(function(accumulator, category) {
- // get method names belonging to each category
- var methodNames = getMethodsByCategory(source, category);
-
- // add `chain` and `findWhere`
- if (isUnderscore) {
- if (_.contains(categories, 'Chaining') && !_.contains(methodNames, 'chain')) {
- methodNames.push('chain');
- }
- if (_.contains(categories, 'Collections') && !_.contains(methodNames, 'findWhere')) {
- methodNames.push('findWhere');
- }
- }
- // limit category methods to those available for specific builds
- if (isBackbone) {
- methodNames = methodNames.filter(function(methodName) {
- return _.contains(backboneDependencies, methodName);
- });
- }
- else if (isUnderscore) {
- methodNames = methodNames.filter(function(methodName) {
- return _.contains(underscoreMethods, methodName);
- });
- }
- return accumulator.concat(methodNames);
- }, []));
- }
- if (!result) {
- result = lodashMethods.slice();
- }
- if (plusMethods.length) {
- result = _.union(result, plusMethods);
- }
- if (minusMethods.length) {
- result = _.without.apply(_, [result].concat(minusMethods, isNoDep
- ? minusMethods
- : getDependants(minusMethods)
- ));
- }
- if (!isNoDep) {
- result = getDependencies(result);
- }
- return result;
- }());
-
- /*------------------------------------------------------------------------*/
-
- // load customized Lo-Dash module
- var lodash = !isTemplate && (function() {
- source = setUseStrictOption(source, isStrict);
-
- if (isLegacy) {
- source = removeSupportProp(source, 'fastBind');
- source = replaceSupportProp(source, 'argsClass', 'false');
-
- _.each(['isIeOpera', 'isV8', 'getPrototypeOf', 'nativeBind', 'nativeCreate', 'nativeIsArray', 'nativeKeys', 'reNative'], function(varName) {
- source = removeVar(source, varName);
- });
-
- // remove native `Function#bind` branch in `_.bind`
- source = source.replace(matchFunction(source, 'bind'), function(match) {
- return match.replace(/(?:\s*\/\/.*)*\s*return support\.fastBind[^:]+:\s*/, 'return ');
- });
-
- // remove native `Array.isArray` branch in `_.isArray`
- source = source.replace(matchFunction(source, 'isArray'), function(match) {
- return match.replace(/\bnativeIsArray\s*\|\|\s*/, '');
- });
-
- // replace `createObject` and `isArguments` with their fallbacks
- _.each(['createObject', 'isArguments'], function(methodName) {
- var capitalized = capitalize(methodName),
- get = eval('get' + capitalized + 'Fallback'),
- remove = eval('remove' + capitalized + 'Fallback');
-
- source = source.replace(matchFunction(source, methodName).replace(RegExp('[\\s\\S]+?function ' + methodName), ''), function() {
- var snippet = get(source),
- body = snippet.match(RegExp(methodName + ' *= *function([\\s\\S]+?\\n *});'))[1],
- indent = getIndent(snippet);
-
- return body.replace(RegExp('^' + indent, 'gm'), indent.slice(0, -2)) + '\n';
- });
-
- source = remove(source);
- });
-
- // replace `_.isPlainObject` with `shimIsPlainObject`
- source = source.replace(
- matchFunction(source, 'isPlainObject').replace(/[\s\S]+?var isPlainObject *= */, ''),
- matchFunction(source, 'shimIsPlainObject').replace(/[\s\S]+?function shimIsPlainObject/, 'function').replace(/\s*$/, ';\n')
- );
-
- source = removeFunction(source, 'shimIsPlainObject');
-
- // replace `_.keys` with `shimKeys`
- source = source.replace(
- matchFunction(source, 'keys').replace(/[\s\S]+?var keys *= */, ''),
- matchFunction(source, 'shimKeys').replace(/[\s\S]+?var shimKeys *= */, '')
- );
-
- source = removeFunction(source, 'shimKeys');
- }
- if (isModern) {
- source = removeSupportSpliceObjects(source);
- source = removeIsArgumentsFallback(source);
-
- if (isMobile) {
- source = replaceSupportProp(source, 'enumPrototypes', 'true');
- source = replaceSupportProp(source, 'nonEnumArgs', 'true');
- }
- else {
- source = removeIsArrayFallback(source);
- source = removeIsFunctionFallback(source);
- source = removeCreateObjectFallback(source);
-
- // remove `shimIsPlainObject` from `_.isPlainObject`
- source = source.replace(matchFunction(source, 'isPlainObject'), function(match) {
- return match.replace(/!getPrototypeOf[^:]+:\s*/, '');
- });
- }
- }
- if ((isLegacy || isMobile || isUnderscore) && !useLodashMethod('createCallback')) {
- source = removeBindingOptimization(source);
- }
- if (isLegacy || isMobile || isUnderscore) {
- if (isMobile || (!useLodashMethod('assign') && !useLodashMethod('defaults') && !useLodashMethod('forIn') && !useLodashMethod('forOwn'))) {
- source = removeKeysOptimization(source);
- }
- if (!useLodashMethod('defer')) {
- source = removeSetImmediate(source);
- }
- }
- if (isModern || isUnderscore) {
- source = removeSupportArgsClass(source);
- source = removeSupportArgsObject(source);
- source = removeSupportNonEnumShadows(source);
- source = removeSupportOwnLast(source);
- source = removeSupportUnindexedChars(source);
- source = removeSupportNodeClass(source);
-
- if (!isMobile) {
- source = removeSupportEnumErrorProps(source);
- source = removeSupportEnumPrototypes(source);
- source = removeSupportNonEnumArgs(source);
-
- // replace `_.forEach`
- source = replaceFunction(source, 'forEach', [
- 'function forEach(collection, callback, thisArg) {',
- ' var index = -1,',
- ' length = collection ? collection.length : 0;',
- '',
- " callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);",
- " if (typeof length == 'number') {",
- ' while (++index < length) {',
- ' if (callback(collection[index], index, collection) === false) {',
- ' break;',
- ' }',
- ' }',
- ' } else {',
- ' basicEach(collection, callback);',
- ' }',
- ' return collection;',
- '}',
- ].join('\n'));
-
- // replace `_.isRegExp`
- if (!isUnderscore || (isUnderscore && useLodashMethod('isRegExp'))) {
- source = replaceFunction(source, 'isRegExp', [
- 'function isRegExp(value) {',
- " return value ? (typeof value == 'object' && toString.call(value) == regexpClass) : false;",
- '}'
- ].join('\n'));
- }
-
- // replace `_.map`
- source = replaceFunction(source, 'map', [
- 'function map(collection, callback, thisArg) {',
- ' var index = -1,',
- ' length = collection ? collection.length : 0;',
- '',
- ' callback = lodash.createCallback(callback, thisArg);',
- " if (typeof length == 'number') {",
- ' var result = Array(length);',
- ' while (++index < length) {',
- ' result[index] = callback(collection[index], index, collection);',
- ' }',
- ' } else {',
- ' result = [];',
- ' basicEach(collection, function(value, key, collection) {',
- ' result[++index] = callback(value, key, collection);',
- ' });',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
-
- // replace `_.pluck`
- source = replaceFunction(source, 'pluck', [
- 'function pluck(collection, property) {',
- ' var index = -1,',
- ' length = collection ? collection.length : 0;',
- '',
- " if (typeof length == 'number') {",
- ' var result = Array(length);',
- ' while (++index < length) {',
- ' result[index] = collection[index][property];',
- ' }',
- ' }',
- ' return result || map(collection, property);',
- '}'
- ].join('\n'));
-
- // replace `isArray(collection)` checks in "Collections" methods with simpler type checks
- _.each(['every', 'filter', 'find', 'max', 'min', 'reduce', 'some'], function(methodName) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- if (methodName == 'reduce') {
- match = match.replace(/^( *)var noaccum\b/m, '$1if (!collection) return accumulator;\n$&');
- }
- else if (/^(?:max|min)$/.test(methodName)) {
- match = match.replace(/\bbasicEach\(/, 'forEach(');
- if (!isUnderscore || useLodashMethod(methodName)) {
- return match;
- }
- }
- return match.replace(/^(( *)if *\(.*?\bisArray\([^\)]+\).*?\) *{\n)(( *)var index[^;]+.+\n+)/m, function(snippet, statement, indent, vars) {
- vars = vars
- .replace(/\b(length *=)[^;=]+/, '$1 collection' + (methodName == 'reduce' ? '.length' : ' ? collection.length : 0'))
- .replace(RegExp('^ ' + indent, 'gm'), indent);
-
- return vars + statement.replace(/\bisArray\([^\)]+\)/, "typeof length == 'number'");
- });
- });
- });
-
- // replace `array` property value of `eachIteratorOptions` with `false`
- source = source.replace(/^( *)var eachIteratorOptions *= *[\s\S]+?\n\1};\n/m, function(match) {
- return match.replace(/(^ *'array':)[^,]+/m, '$1 false');
- });
- }
- }
- if (isUnderscore) {
- // replace `lodash`
- source = replaceFunction(source, 'lodash', [
- 'function lodash(value) {',
- ' return (value instanceof lodash)',
- ' ? value',
- ' : new lodashWrapper(value);',
- '}'
- ].join('\n'));
-
- // replace `_.assign`
- if (!useLodashMethod('assign')) {
- source = replaceFunction(source, 'assign', [
- 'function assign(object) {',
- ' if (!object) {',
- ' return object;',
- ' }',
- ' for (var argsIndex = 1, argsLength = arguments.length; argsIndex < argsLength; argsIndex++) {',
- ' var iterable = arguments[argsIndex];',
- ' if (iterable) {',
- ' for (var key in iterable) {',
- ' object[key] = iterable[key];',
- ' }',
- ' }',
- ' }',
- ' return object;',
- '}'
- ].join('\n'));
- }
- // replace `_.clone`
- if (!useLodashMethod('clone') && !useLodashMethod('cloneDeep')) {
- source = replaceFunction(source, 'clone', [
- 'function clone(value) {',
- ' return isObject(value)',
- ' ? (isArray(value) ? slice(value) : assign({}, value))',
- ' : value;',
- '}'
- ].join('\n'));
- }
- // replace `_.contains`
- if (!useLodashMethod('contains')) {
- source = replaceFunction(source, 'contains', [
- 'function contains(collection, target) {',
- ' var indexOf = getIndexOf(),',
- ' length = collection ? collection.length : 0,',
- ' result = false;',
- " if (length && typeof length == 'number') {",
- ' result = indexOf(collection, target) > -1;',
- ' } else {',
- ' basicEach(collection, function(value) {',
- ' return !(result = value === target);',
- ' });',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.debounce`
- if (!useLodashMethod('debounce')) {
- source = replaceFunction(source, 'debounce', [
- 'function debounce(func, wait, immediate) {',
- ' var args,',
- ' result,',
- ' thisArg,',
- ' timeoutId = null;',
- '',
- ' function delayed() {',
- ' timeoutId = null;',
- ' if (!immediate) {',
- ' result = func.apply(thisArg, args);',
- ' }',
- ' }',
- ' return function() {',
- ' var isImmediate = immediate && !timeoutId;',
- ' args = arguments;',
- ' thisArg = this;',
- '',
- ' clearTimeout(timeoutId);',
- ' timeoutId = setTimeout(delayed, wait);',
- '',
- ' if (isImmediate) {',
- ' result = func.apply(thisArg, args);',
- ' }',
- ' return result;',
- ' };',
- '}'
- ].join('\n'));
- }
- // replace `_.defaults`
- if (!useLodashMethod('defaults')) {
- source = replaceFunction(source, 'defaults', [
- 'function defaults(object) {',
- ' if (!object) {',
- ' return object;',
- ' }',
- ' for (var argsIndex = 1, argsLength = arguments.length; argsIndex < argsLength; argsIndex++) {',
- ' var iterable = arguments[argsIndex];',
- ' if (iterable) {',
- ' for (var key in iterable) {',
- ' if (object[key] == null) {',
- ' object[key] = iterable[key];',
- ' }',
- ' }',
- ' }',
- ' }',
- ' return object;',
- '}'
- ].join('\n'));
- }
- // replace `_.difference`
- if (!useLodashMethod('difference')) {
- source = replaceFunction(source, 'difference', [
- 'function difference(array) {',
- ' var index = -1,',
- ' indexOf = getIndexOf(),',
- ' length = array.length,',
- ' flattened = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),',
- ' result = [];',
- '',
- ' while (++index < length) {',
- ' var value = array[index];',
- ' if (indexOf(flattened, value) < 0) {',
- ' result.push(value);',
- ' }',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // add Underscore's `_.findWhere`
- if (!useLodashMethod('findWhere') && !useLodashMethod('where')) {
- source = source.replace(matchFunction(source, 'find'), function(match) {
- var indent = getIndent(match);
- return match && (match + [
- '',
- '/**',
- ' * Examines each element in a `collection`, returning the first that',
- ' * has the given `properties`. When checking `properties`, this method',
- ' * performs a deep comparison between values to determine if they are',
- ' * equivalent to each other.',
- ' *',
- ' * @static',
- ' * @memberOf _',
- ' * @category Collections',
- ' * @param {Array|Object|String} collection The collection to iterate over.',
- ' * @param {Object} properties The object of property values to filter by.',
- ' * @returns {Mixed} Returns the found element, else `undefined`.',
- ' * @example',
- ' *',
- ' * var food = [',
- " * { 'name': 'apple', 'organic': false, 'type': 'fruit' },",
- " * { 'name': 'banana', 'organic': true, 'type': 'fruit' },",
- " * { 'name': 'beet', 'organic': false, 'type': 'vegetable' }",
- ' * ];',
- ' *',
- " * _.findWhere(food, { 'type': 'vegetable' });",
- " * // => { 'name': 'beet', 'organic': false, 'type': 'vegetable' }",
- ' */',
- 'function findWhere(object, properties) {',
- ' return where(object, properties, true);',
- '}',
- ''
- ].join('\n' + indent));
- });
-
- // replace alias assignment
- source = source.replace(getMethodAssignments(source), function(match) {
- return match.replace(/^( *lodash.findWhere *= *).+/m, '$1findWhere;');
- });
- }
- // replace `_.flatten`
- if (!useLodashMethod('flatten')) {
- source = replaceFunction(source, 'flatten', [
- 'function flatten(array, isShallow) {',
- ' var index = -1,',
- ' length = array ? array.length : 0,',
- ' result = [];',
- '' ,
- ' while (++index < length) {',
- ' var value = array[index];',
- ' if (isArray(value)) {',
- ' push.apply(result, isShallow ? value : flatten(value));',
- ' } else {',
- ' result.push(value);',
- ' }',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.intersection`
- if (!useLodashMethod('intersection')) {
- source = replaceFunction(source, 'intersection', [
- 'function intersection(array) {',
- ' var args = arguments,',
- ' argsLength = args.length,',
- ' index = -1,',
- ' indexOf = getIndexOf(),',
- ' length = array ? array.length : 0,',
- ' result = [];',
- '',
- ' outer:',
- ' while (++index < length) {',
- ' var value = array[index];',
- ' if (indexOf(result, value) < 0) {',
- ' var argsIndex = argsLength;',
- ' while (--argsIndex) {',
- ' if (indexOf(args[argsIndex], value) < 0) {',
- ' continue outer;',
- ' }',
- ' }',
- ' result.push(value);',
- ' }',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.isEmpty`
- if (!useLodashMethod('isEmpty')) {
- source = replaceFunction(source, 'isEmpty', [
- 'function isEmpty(value) {',
- ' if (!value) {',
- ' return true;',
- ' }',
- ' if (isArray(value) || isString(value)) {',
- ' return !value.length;',
- ' }',
- ' for (var key in value) {',
- ' if (hasOwnProperty.call(value, key)) {',
- ' return false;',
- ' }',
- ' }',
- ' return true;',
- '}'
- ].join('\n'));
- }
- // replace `_.isEqual`
- if (!useLodashMethod('isEqual')) {
- source = replaceFunction(source, 'isEqual', [
- 'function isEqual(a, b, stackA, stackB) {',
- ' if (a === b) {',
- ' return a !== 0 || (1 / a == 1 / b);',
- ' }',
- ' var type = typeof a,',
- ' otherType = typeof b;',
- '',
- ' if (a === a &&',
- " (!a || (type != 'function' && type != 'object')) &&",
- " (!b || (otherType != 'function' && otherType != 'object'))) {",
- ' return false;',
- ' }',
- ' if (a == null || b == null) {',
- ' return a === b;',
- ' }',
- ' var className = toString.call(a),',
- ' otherClass = toString.call(b);',
- '',
- ' if (className != otherClass) {',
- ' return false;',
- ' }',
- ' switch (className) {',
- ' case boolClass:',
- ' case dateClass:',
- ' return +a == +b;',
- '',
- ' case numberClass:',
- ' return a != +a',
- ' ? b != +b',
- ' : (a == 0 ? (1 / a == 1 / b) : a == +b);',
- '',
- ' case regexpClass:',
- ' case stringClass:',
- ' return a == String(b);',
- ' }',
- ' var isArr = className == arrayClass;',
- ' if (!isArr) {',
- ' if (a instanceof lodash || b instanceof lodash) {',
- ' return isEqual(a.__wrapped__ || a, b.__wrapped__ || b, stackA, stackB);',
- ' }',
- ' if (className != objectClass) {',
- ' return false;',
- ' }',
- ' var ctorA = a.constructor,',
- ' ctorB = b.constructor;',
- '',
- ' if (ctorA != ctorB && !(',
- ' isFunction(ctorA) && ctorA instanceof ctorA &&',
- ' isFunction(ctorB) && ctorB instanceof ctorB',
- ' )) {',
- ' return false;',
- ' }',
- ' }',
- ' stackA || (stackA = []);',
- ' stackB || (stackB = []);',
- '',
- ' var length = stackA.length;',
- ' while (length--) {',
- ' if (stackA[length] == a) {',
- ' return stackB[length] == b;',
- ' }',
- ' }',
- ' var result = true,',
- ' size = 0;',
- '',
- ' stackA.push(a);',
- ' stackB.push(b);',
- '',
- ' if (isArr) {',
- ' size = b.length;',
- ' result = size == a.length;',
- '',
- ' if (result) {',
- ' while (size--) {',
- ' if (!(result = isEqual(a[size], b[size], stackA, stackB))) {',
- ' break;',
- ' }',
- ' }',
- ' }',
- ' return result;',
- ' }',
- ' forIn(b, function(value, key, b) {',
- ' if (hasOwnProperty.call(b, key)) {',
- ' size++;',
- ' return (result = hasOwnProperty.call(a, key) && isEqual(a[key], value, stackA, stackB));',
- ' }',
- ' });',
- '',
- ' if (result) {',
- ' forIn(a, function(value, key, a) {',
- ' if (hasOwnProperty.call(a, key)) {',
- ' return (result = --size > -1);',
- ' }',
- ' });',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.memoize`
- if (!useLodashMethod('memoize')) {
- source = replaceFunction(source, 'memoize', [
- 'function memoize(func, resolver) {',
- ' var cache = {};',
- ' return function() {',
- ' var key = keyPrefix + (resolver ? resolver.apply(this, arguments) : arguments[0]);',
- ' return hasOwnProperty.call(cache, key)',
- ' ? cache[key]',
- ' : (cache[key] = func.apply(this, arguments));',
- ' };',
- '}'
- ].join('\n'));
- }
- // replace `_.omit`
- if (!useLodashMethod('omit')) {
- source = replaceFunction(source, 'omit', [
- 'function omit(object) {',
- ' var indexOf = getIndexOf(),',
- ' props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),',
- ' result = {};',
- '',
- ' forIn(object, function(value, key) {',
- ' if (indexOf(props, key) < 0) {',
- ' result[key] = value;',
- ' }',
- ' });',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.pick`
- if (!useLodashMethod('pick')) {
- source = replaceFunction(source, 'pick', [
- 'function pick(object) {',
- ' var index = -1,',
- ' props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),',
- ' length = props.length,',
- ' result = {};',
- '',
- ' while (++index < length) {',
- ' var prop = props[index];',
- ' if (prop in object) {',
- ' result[prop] = object[prop];',
- ' }',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.result`
- if (!useLodashMethod('result')) {
- source = replaceFunction(source, 'result', [
- 'function result(object, property) {',
- ' var value = object ? object[property] : null;',
- ' return isFunction(value) ? object[property]() : value;',
- '}'
- ].join('\n'));
- }
- // replace `_.sortBy`
- if (!useLodashMethod('sortBy')) {
- source = replaceFunction(source, 'sortBy', [
- 'function sortBy(collection, callback, thisArg) {',
- ' var index = -1,',
- ' length = collection ? collection.length : 0,',
- " result = Array(typeof length == 'number' ? length : 0);",
- '',
- ' callback = lodash.createCallback(callback, thisArg);',
- ' forEach(collection, function(value, key, collection) {',
- ' result[++index] = {',
- " 'criteria': callback(value, key, collection),",
- " 'index': index,",
- " 'value': value",
- ' };',
- ' });',
- '',
- ' length = result.length;',
- ' result.sort(compareAscending);',
- ' while (length--) {',
- ' result[length] = result[length].value;',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.template`
- if (!useLodashMethod('template')) {
- // remove `_.templateSettings.imports assignment
- source = source.replace(/,[^']*'imports':[^}]+}/, '');
-
- source = replaceFunction(source, 'template', [
- 'function template(text, data, options) {',
- ' var settings = lodash.templateSettings;',
- " text || (text = '');",
- ' options = iteratorTemplate ? defaults({}, options, settings) : settings;',
- '',
- ' var index = 0,',
- ' source = "__p += \'",',
- ' variable = options.variable;',
- '',
- ' var reDelimiters = RegExp(',
- " (options.escape || reNoMatch).source + '|' +",
- " (options.interpolate || reNoMatch).source + '|' +",
- " (options.evaluate || reNoMatch).source + '|$'",
- " , 'g');",
- '',
- ' text.replace(reDelimiters, function(match, escapeValue, interpolateValue, evaluateValue, offset) {',
- ' source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);',
- ' if (escapeValue) {',
- ' source += "\' +\\n_.escape(" + escapeValue + ") +\\n\'";',
- ' }',
- ' if (evaluateValue) {',
- ' source += "\';\\n" + evaluateValue + ";\\n__p += \'";',
- ' }',
- ' if (interpolateValue) {',
- ' source += "\' +\\n((__t = (" + interpolateValue + ")) == null ? \'\' : __t) +\\n\'";',
- ' }',
- ' index = offset + match.length;',
- ' return match;',
- ' });',
- '',
- ' source += "\';\\n";',
- ' if (!variable) {',
- " variable = 'obj';",
- " source = 'with (' + variable + ' || {}) {\\n' + source + '\\n}\\n';",
- ' }',
- " source = 'function(' + variable + ') {\\n' +",
- ' "var __t, __p = \'\', __j = Array.prototype.join;\\n" +',
- ' "function print() { __p += __j.call(arguments, \'\') }\\n" +',
- ' source +',
- " 'return __p\\n}';",
- '',
- ' try {',
- " var result = Function('_', 'return ' + source)(lodash);",
- ' } catch(e) {',
- ' e.source = source;',
- ' throw e;',
- ' }',
- ' if (data) {',
- ' return result(data);',
- ' }',
- ' result.source = source;',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.throttle`
- if (!useLodashMethod('throttle')) {
- source = replaceFunction(source, 'throttle', [
- 'function throttle(func, wait) {',
- ' var args,',
- ' result,',
- ' thisArg,',
- ' lastCalled = 0,',
- ' timeoutId = null;',
- '',
- ' function trailingCall() {',
- ' lastCalled = new Date;',
- ' timeoutId = null;',
- ' result = func.apply(thisArg, args);',
- ' }',
- ' return function() {',
- ' var now = new Date,',
- ' remaining = wait - (now - lastCalled);',
- '',
- ' args = arguments;',
- ' thisArg = this;',
- '',
- ' if (remaining <= 0) {',
- ' clearTimeout(timeoutId);',
- ' timeoutId = null;',
- ' lastCalled = now;',
- ' result = func.apply(thisArg, args);',
- ' }',
- ' else if (!timeoutId) {',
- ' timeoutId = setTimeout(trailingCall, remaining);',
- ' }',
- ' return result;',
- ' };',
- '}'
- ].join('\n'));
- }
- // replace `_.times`
- if (!useLodashMethod('times')) {
- source = replaceFunction(source, 'times', [
- 'function times(n, callback, thisArg) {',
- ' var index = -1,',
- ' result = Array(n > -1 ? n : 0);',
- '',
- ' while (++index < n) {',
- ' result[index] = callback.call(thisArg, index);',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.toArray`
- if (!useLodashMethod('toArray')) {
- source = replaceFunction(source, 'toArray', [
- 'function toArray(collection) {',
- ' if (isArray(collection)) {',
- ' return slice(collection);',
- ' }',
- " if (collection && typeof collection.length == 'number') {",
- ' return map(collection);',
- ' }',
- ' return values(collection);',
- '}'
- ].join('\n'));
- }
- // replace `_.uniq`
- if (!useLodashMethod('uniq')) {
- source = replaceFunction(source, 'uniq', [
- 'function uniq(array, isSorted, callback, thisArg) {',
- ' var index = -1,',
- ' indexOf = getIndexOf(),',
- ' length = array ? array.length : 0,',
- ' result = [],',
- ' seen = result;',
- '',
- " if (typeof isSorted != 'boolean' && isSorted != null) {",
- ' thisArg = callback;',
- ' callback = isSorted;',
- ' isSorted = false;',
- ' }',
- ' if (callback != null) {',
- ' seen = [];',
- ' callback = lodash.createCallback(callback, thisArg);',
- ' }',
- ' while (++index < length) {',
- ' var value = array[index],',
- ' computed = callback ? callback(value, index, array) : value;',
- '',
- ' if (isSorted',
- ' ? !index || seen[seen.length - 1] !== computed',
- ' : indexOf(seen, computed) < 0',
- ' ) {',
- ' if (callback) {',
- ' seen.push(computed);',
- ' }',
- ' result.push(value);',
- ' }',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
- // replace `_.uniqueId`
- if (!useLodashMethod('uniqueId')) {
- source = replaceFunction(source, 'uniqueId', [
- 'function uniqueId(prefix) {',
- " var id = ++idCounter + '';",
- ' return prefix ? prefix + id : id;',
- '}'
- ].join('\n'));
- }
- // replace `_.where`
- if (!useLodashMethod('where')) {
- source = replaceFunction(source, 'where', [
- 'function where(collection, properties, first) {',
- ' return (first && isEmpty(properties))',
- ' ? null',
- ' : (first ? find : filter)(collection, properties);',
- '}'
- ].join('\n'));
- }
- // replace `_.zip`
- if (!useLodashMethod('unzip')) {
- source = replaceFunction(source, 'zip', [
- 'function zip(array) {',
- ' var index = -1,',
- " length = array ? max(pluck(arguments, 'length')) : 0,",
- ' result = Array(length < 0 ? 0 : length);',
- '',
- ' while (++index < length) {',
- ' result[index] = pluck(arguments, index);',
- ' }',
- ' return result;',
- '}'
- ].join('\n'));
- }
-
- // unexpose `lodash.support`
- source = source.replace(/lodash\.support *= */, '');
-
- // replace `slice` with `nativeSlice.call`
- _.each(['clone', 'first', 'initial', 'last', 'rest', 'toArray'], function(methodName) {
- if (methodName == 'clone'
- ? (!useLodashMethod('clone') && !useLodashMethod('cloneDeep'))
- : !useLodashMethod(methodName)
- ) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match.replace(/([^.])\bslice\(/g, '$1nativeSlice.call(');
- });
- }
- });
-
- // remove conditional `charCodeCallback` use from `_.max` and `_.min`
- _.each(['max', 'min'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match.replace(/=.+?callback *&& *isString[^:]+:\s*/g, '= ');
- });
- }
- });
-
- // remove unneeded variables
- if (!useLodashMethod('clone') && !useLodashMethod('cloneDeep')) {
- source = removeVar(source, 'cloneableClasses');
- source = removeVar(source, 'ctorByClass');
- }
- // remove `_.isEqual` use from `createCallback`
- if (!useLodashMethod('where')) {
- source = source.replace(matchFunction(source, 'createCallback'), function(match) {
- return match.replace(/\bisEqual\(([^,]+), *([^,]+)[^)]+\)/, '$1 === $2');
- });
- }
- // remove unused features from `createBound`
- if (_.every(['bindKey', 'partial', 'partialRight'], function(methodName) {
- return !_.contains(buildMethods, methodName);
- })) {
- source = source.replace(matchFunction(source, 'createBound'), function(match) {
- return match
- .replace(/, *indicator[^)]*/, '')
- .replace(/(function createBound\([^{]+{)[\s\S]+?(\n *)(function bound)/, function(match, part1, indent, part2) {
- return [
- part1,
- 'if (!isFunction(func)) {',
- ' throw new TypeError;',
- '}',
- part2
- ].join(indent);
- })
- .replace(/thisBinding *=[^}]+}/, 'thisBinding = thisArg;\n')
- .replace(/\(args *=.+/, 'partialArgs.concat(nativeSlice.call(args))');
- });
- }
- }
- // add Underscore's chaining methods
- if (isUnderscore ? !_.contains(plusMethods, 'chain') : _.contains(plusMethods, 'chain')) {
- source = addChainMethods(source);
- }
- // replace `basicEach` references with `forEach` and `forOwn`
- if ((isUnderscore || (isModern && !isMobile)) &&
- _.contains(buildMethods, 'forEach') && _.contains(buildMethods, 'forOwn')) {
- source = removeFunction(source, 'basicEach');
-
- // remove `lodash._basicEach` pseudo property
- source = source.replace(/^ *lodash\._basicEach *=.+\n/m, '');
-
- // replace `basicEach` with `_.forOwn` in "Collections" methods
- source = source.replace(/\bbasicEach(?=\(collection)/g, 'forOwn');
-
- // replace `basicEach` with `_.forEach` in the rest of the methods
- source = source.replace(/(\?\s*)basicEach(?=\s*:)/g, '$1forEach');
-
- // replace `basicEach` with `_.forEach` in the method assignment snippet
- source = source.replace(/\bbasicEach(?=\(\[)/g, 'forEach');
- }
-
- var context = vm.createContext({
- 'clearTimeout': clearTimeout,
- 'console': console,
- 'setTimeout': setTimeout
- });
-
- vm.runInContext(source, context);
- return context._;
- }());
-
- /*------------------------------------------------------------------------*/
-
- if (isTemplate) {
- source = buildTemplate(templatePattern, templateSettings);
- }
- else {
- // remove methods from the build
- allMethods.forEach(function(otherName) {
- if (!_.contains(buildMethods, otherName) &&
- !(otherName == 'findWhere' && !isUnderscore)) {
- source = removeFunction(source, otherName);
- }
- });
-
- // remove `iteratorTemplate` dependency checks from `_.template`
- source = source.replace(matchFunction(source, 'template'), function(match) {
- return match
- .replace(/iteratorTemplate *&& */g, '')
- .replace(/iteratorTemplate\s*\?\s*([^:]+?)\s*:[^,;]+/g, '$1');
- });
-
- /*----------------------------------------------------------------------*/
-
- if (isModern || isUnderscore) {
- source = removeFunction(source, 'createIterator');
-
- iteratorOptions.forEach(function(prop) {
- if (prop != 'array') {
- source = removeFromGetObject(source, prop);
- }
- });
-
- // inline all functions defined with `createIterator`
- _.functions(lodash).forEach(function(methodName) {
- // strip leading underscores to match pseudo private functions
- var reFunc = RegExp('^( *)(var ' + methodName.replace(/^_/, '') + ' *= *)createIterator\\(((?:{|[a-zA-Z])[\\s\\S]+?)\\);\\n', 'm');
- if (reFunc.test(source)) {
- // extract, format, and inject the compiled function's source code
- source = source.replace(reFunc, function(match, indent, left) {
- return (indent + left) +
- cleanupCompiled(getFunctionSource(lodash[methodName], indent)) + ';\n';
- });
- }
- });
-
- if (isUnderscore) {
- // unexpose "exit early" feature of `basicEach`, `_.forEach`, `_.forIn`, and `_.forOwn`
- _.each(['basicEach', 'forEach', 'forIn', 'forOwn'], function(methodName) {
- if (methodName == 'basicEach' || !useLodashMethod(methodName)) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match.replace(/=== *false\)/g, '=== indicatorObject)');
- });
- }
- });
-
- // modify `_.contains`, `_.every`, `_.find`, `_.some`, and `_.transform` to use the private `indicatorObject`
- if (isUnderscore && (/\bbasicEach\(/.test(source) || !useLodashMethod('forOwn'))) {
- source = source.replace(matchFunction(source, 'every'), function(match) {
- return match.replace(/\(result *= *(.+?)\);/g, '!(result = $1) && indicatorObject;');
- });
-
- source = source.replace(matchFunction(source, 'find'), function(match) {
- return match.replace(/return false/, 'return indicatorObject');
- });
-
- source = source.replace(matchFunction(source, 'transform'), function(match) {
- return match.replace(/return callback[^)]+\)/, '$& && indicatorObject');
- });
-
- _.each(['contains', 'some'], function(methodName) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match.replace(/!\(result *= *(.+?)\);/, '(result = $1) && indicatorObject;');
- });
- });
- }
- // modify `_.isEqual` and `shimIsPlainObject` to use the private `indicatorObject`
- if (!useLodashMethod('forIn')) {
- source = source.replace(matchFunction(source, 'isEqual'), function(match) {
- return match.replace(/\(result *= *(.+?)\);/g, '!(result = $1) && indicatorObject;');
- });
-
- source = source.replace(matchFunction(source, 'shimIsPlainObject'), function(match) {
- return match.replace(/return false/, 'return indicatorObject');
- });
- }
-
- // remove `thisArg` from unexposed `forIn` and `forOwn`
- _.each(['forIn', 'forOwn'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match
- .replace(/(callback), *thisArg/g, '$1')
- .replace(/^ *callback *=.+\n/m, '');
- });
- }
- });
-
- // replace `lodash.createCallback` references with `createCallback`
- if (!useLodashMethod('createCallback')) {
- source = source.replace(/\blodash\.(createCallback\()\b/g, '$1');
- }
- // remove chainability from `basicEach` and `_.forEach`
- if (!useLodashMethod('forEach')) {
- _.each(['basicEach', 'forEach'], function(methodName) {
- source = source.replace(matchFunction(source, methodName), function(match) {
- return match
- .replace(/\n *return .+?([};\s]+)$/, '$1')
- .replace(/\b(return) +result\b/, '$1')
- });
- });
- }
- // remove `_.assign`, `_.forIn`, `_.forOwn`, `_.isPlainObject`, `_.unzip`, and `_.zipObject` assignments
- (function() {
- var snippet = getMethodAssignments(source),
- modified = snippet;
-
- _.each(['assign', 'createCallback', 'forIn', 'forOwn', 'isPlainObject', 'unzip', 'zipObject'], function(methodName) {
- if (!useLodashMethod(methodName)) {
- modified = modified.replace(RegExp('^(?: *//.*\\s*)* *lodash\\.' + methodName + ' *=.+\\n', 'm'), '');
- }
- });
-
- source = source.replace(snippet, function() {
- return modified;
- });
- }());
- }
- }
- else {
- source = removeFromCreateIterator(source, 'support');
-
- // inline `iteratorTemplate` template
- source = source.replace(getIteratorTemplate(source), function(match) {
- var indent = getIndent(match),
- snippet = cleanupCompiled(getFunctionSource(lodash._iteratorTemplate, indent));
-
- // prepend data object references to property names to avoid having to
- // use a with-statement
- iteratorOptions.forEach(function(prop) {
- if (prop !== 'support') {
- snippet = snippet.replace(RegExp('([^\\w.])\\b' + prop + '\\b', 'g'), '$1obj.' + prop);
- }
- });
-
- // remove unnecessary code
- snippet = snippet
- .replace(/var __t.+/, "var __p = '';")
- .replace(/function print[^}]+}/, '')
- .replace(/'(?:\\n|\s)+'/g, "''")
- .replace(/__p *\+= *' *';/g, '')
- .replace(/\s*\+\s*'';/g, ';')
- .replace(/(__p *\+= *)' *' *\+/g, '$1')
- .replace(/\(\(__t *= *\( *([\s\S]+?) *\)\) *== *null *\? *'' *: *__t\)/g, '($1)');
-
- // remove the with-statement
- snippet = snippet.replace(/ *with *\(.+?\) *{/, '\n').replace(/}([^}]*}[^}]*$)/, '$1');
-
- // minor cleanup
- snippet = snippet
- .replace(/obj\s*\|\|\s*\(obj *= *{}\);/, '')
- .replace(/var __p = '';\s*__p \+=/, 'var __p =');
-
- // remove comments, including sourceURLs
- snippet = snippet.replace(/\s*\/\/.*(?:\n|$)/g, '');
-
- return indent + 'var iteratorTemplate = ' + snippet + ';\n';
- });
- }
- }
-
- /*------------------------------------------------------------------------*/
-
- // customize Lo-Dash's IIFE
- (function() {
- if (isIIFE) {
- var token = '%output%',
- index = iife.indexOf(token);
-
- source = source.match(/^\/\**[\s\S]+?\*\/\n/) +
- iife.slice(0, index) +
- source.replace(/^[\s\S]+?\(function[^{]+?{|}\(this\)\)[;\s]*$/g, '') +
- iife.slice(index + token.length);
- }
- }());
-
- /*------------------------------------------------------------------------*/
-
- // customize Lo-Dash's export bootstrap
- (function() {
- if (!isAMD) {
- source = source.replace(/(?: *\/\/.*\n)*( *)if *\(typeof +define[\s\S]+?else /, '$1');
- }
- if (!isNode) {
- source = source.replace(/(?: *\/\/.*\n)*( *)if *\(freeModule[\s\S]+?else *{([\s\S]+?\n)\1}\n+/, '$1$2');
- }
- if (!isCommonJS) {
- source = source.replace(/(?: *\/\/.*\n)*(?:( *)else *{)?\s*freeExports\.\w+ *=[\s\S]+?(?:\n\1})?\n+/, '');
- }
- if (!isGlobal) {
- source = source.replace(/(?:( *)(})? *else(?: *if *\(_\))? *{)?(?:\s*\/\/.*)*\s*(?:window\._|_\.templates) *=[\s\S]+?(?:\n\1})?\n+/g, '$1$2\n');
- }
- // remove `if (freeExports) {...}` if it's empty
- if (isAMD && isGlobal) {
- source = source.replace(/(?: *\/\/.*\n)* *(?:else )?if *\(freeExports.*?\) *{\s*}\n+/, '');
- } else {
- source = source.replace(/(?: *\/\/.*\n)* *(?:else )?if *\(freeExports.*?\) *{\s*}(?:\s*else *{([\s\S]+?) *})?\n+/, '$1\n');
- }
- }());
-
- /*------------------------------------------------------------------------*/
-
- // modify/remove references to removed methods/variables
- if (!isTemplate) {
- if (isRemoved(source, 'clone')) {
- source = removeVar(source, 'cloneableClasses');
- source = removeVar(source, 'ctorByClass');
- }
- if (isRemoved(source, 'clone', 'isEqual', 'isPlainObject')) {
- source = removeSupportNodeClass(source);
- }
- if (isRemoved(source, 'createIterator')) {
- source = removeVar(source, 'defaultsIteratorOptions');
- source = removeVar(source, 'eachIteratorOptions');
- source = removeVar(source, 'forOwnIteratorOptions');
- source = removeVar(source, 'iteratorTemplate');
- source = removeVar(source, 'templateIterator');
- source = removeSupportNonEnumShadows(source);
- }
- if (isRemoved(source, 'createIterator', 'bind', 'keys')) {
- source = removeSupportProp(source, 'fastBind');
- source = removeVar(source, 'isV8');
- source = removeVar(source, 'nativeBind');
- }
- if (isRemoved(source, 'createIterator', 'keys')) {
- source = removeVar(source, 'nativeKeys');
- source = removeKeysOptimization(source);
- source = removeSupportNonEnumArgs(source);
- }
- if (isRemoved(source, 'defer')) {
- source = removeSetImmediate(source);
- }
- if (isRemoved(source, 'escape', 'unescape')) {
- source = removeVar(source, 'htmlEscapes');
- source = removeVar(source, 'htmlUnescapes');
- }
- if (isRemoved(source, 'getArray', 'releaseArray')) {
- source = removeVar(source, 'arrayPool');
- }
- if (isRemoved(source, 'getObject', 'releaseObject')) {
- source = removeVar(source, 'objectPool');
- }
- if (isRemoved(source, 'releaseArray', 'releaseObject')) {
- source = removeVar(source, 'maxPoolSize');
- }
- if (isRemoved(source, 'invert')) {
- source = replaceVar(source, 'htmlUnescapes', "{'&':'&','<':'<','>':'>','"':'\"',''':\"'\"}");
- }
- if (isRemoved(source, 'isArguments')) {
- source = replaceSupportProp(source, 'argsClass', 'true');
- }
- if (isRemoved(source, 'isArguments', 'isEmpty')) {
- source = removeSupportArgsClass(source);
- }
- if (isRemoved(source, 'isArray')) {
- source = removeVar(source, 'nativeIsArray');
- source = removeIsArrayFallback(source);
- }
- if (isRemoved(source, 'isPlainObject')) {
- source = removeFunction(source, 'shimIsPlainObject');
- source = removeVar(source, 'getPrototypeOf');
- source = removeSupportOwnLast(source);
- }
- if (isRemoved(source, 'keys')) {
- source = removeFunction(source, 'shimKeys');
- }
- if (isRemoved(source, 'mixin')) {
- // if possible, inline the `_.mixin` call to ensure proper chaining behavior
- source = source.replace(/^( *)mixin\(lodash\).+/m, function(match, indent) {
- if (isRemoved(source, 'forOwn')) {
- return '';
- }
- return indent + [
- 'forOwn(lodash, function(func, methodName) {',
- ' lodash[methodName] = func;',
- '',
- ' lodash.prototype[methodName] = function() {',
- ' var value = this.__wrapped__,',
- ' args = [value];',
- '',
- ' push.apply(args, arguments);',
- ' var result = func.apply(lodash, args);',
- " return (value && typeof value == 'object' && value == result)",
- ' ? this',
- ' : new lodashWrapper(result);',
- ' };',
- '});'
- ].join('\n' + indent);
- });
- }
- if (isRemoved(source, 'parseInt')) {
- source = removeVar(source, 'nativeParseInt');
- source = removeVar(source, 'reLeadingSpacesAndZeros');
- source = removeVar(source, 'whitespace');
- }
- if (isRemoved(source, 'sortBy')) {
- _.each([removeFromGetObject, removeFromReleaseObject], function(func) {
- source = func(source, 'criteria');
- source = func(source, 'index');
- source = func(source, 'value');
- });
- }
- if (isRemoved(source, 'template')) {
- // remove `templateSettings` assignment
- source = source.replace(/(?:\n +\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\/)?\n *lodash\.templateSettings[\s\S]+?};\n/, '');
- }
- if (isRemoved(source, 'throttle')) {
- _.each(['leading', 'maxWait', 'trailing'], function(prop) {
- source = removeFromGetObject(source, prop);
- });
- }
- if (isRemoved(source, 'value')) {
- source = removeFunction(source, 'chain');
- source = removeFunction(source, 'wrapperToString');
- source = removeFunction(source, 'wrapperValueOf');
- source = removeSupportSpliceObjects(source);
- source = removeLodashWrapper(source);
-
- // simplify the `lodash` function
- source = replaceFunction(source, 'lodash', [
- 'function lodash() {',
- ' // no operation performed',
- '}'
- ].join('\n'));
-
- // remove `lodash.prototype` method assignments from `_.mixin`
- source = replaceFunction(source, 'mixin', [
- 'function mixin(object) {',
- ' forEach(functions(object), function(methodName) {',
- ' lodash[methodName] = object[methodName];',
- ' });',
- '}'
- ].join('\n'));
-
- // remove all `lodash.prototype` additions
- source = source
- .replace(/(?:\s*\/\/.*)*\n( *)forOwn\(lodash, *function\(func, *methodName\)[\s\S]+?\n\1}.+/g, '')
- .replace(/(?:\s*\/\/.*)*\n( *)(?:basicEach|forEach)\(\['[\s\S]+?\n\1}.+/g, '')
- .replace(/(?:\s*\/\/.*)*\n *lodash\.prototype.[\s\S]+?;/g, '');
- }
-
- // remove method fallbacks
- _.each(['createObject', 'isArguments', 'isArray', 'isFunction'], function(methodName) {
- if (_.size(source.match(RegExp(methodName + '\\(', 'g'))) < 2) {
- source = eval('remove' + capitalize(methodName) + 'Fallback')(source);
- }
- });
-
- if (!/\bbasicEach\(/.test(source)) {
- source = removeFunction(source, 'basicEach');
- }
- if (_.size(source.match(/[^.]slice\(/g)) < 2) {
- source = removeFunction(source, 'slice');
- }
- if (!/^ *support\.(?:enumErrorProps|nonEnumShadows) *=/m.test(source)) {
- source = removeVar(source, 'Error');
- source = removeVar(source, 'errorProto');
- source = removeFromCreateIterator(source, 'errorClass');
- source = removeFromCreateIterator(source, 'errorProto');
-
- // remove 'Error' from the `contextProps` array
- source = source.replace(/^ *var contextProps *=[\s\S]+?;/m, function(match) {
- return match.replace(/'Error', */, '');
- });
- }
-
- // remove code used to resolve unneeded `support` properties
- source = source.replace(/^ *\(function[\s\S]+?\n(( *)var ctor *= *function[\s\S]+?(?:\n *for.+)+\n)([\s\S]+?)}\(1\)\);\n/m, function(match, setup, indent, body) {
- var modified = setup;
- if (!/support\.spliceObjects *=(?! *(?:false|true))/.test(match)) {
- modified = modified.replace(/^ *object *=.+\n/m, '');
- }
- if (!/support\.enumPrototypes *=(?! *(?:false|true))/.test(match) &&
- !/support\.nonEnumShadows *=(?! *(?:false|true))/.test(match) &&
- !/support\.ownLast *=(?! *(?:false|true))/.test(match)) {
- modified = modified
- .replace(/\bctor *=.+\s+/, '')
- .replace(/^ *ctor\.prototype.+\s+.+\n/m, '')
- .replace(/(?:,\n)? *props *=[^;=]+/, '')
- .replace(/^ *for *\((?=prop)/, '$&var ')
- }
- if (!/support\.nonEnumArgs *=(?! *(?:false|true))/.test(match)) {
- modified = modified.replace(/^ *for *\(.+? arguments.+\n/m, '');
- }
- // cleanup the empty var statement
- modified = modified.replace(/^ *var;\n/m, '');
-
- // if no setup then remove IIFE
- return /^\s*$/.test(modified)
- ? body.replace(RegExp('^' + indent, 'gm'), indent.slice(0, -2))
- : match.replace(setup, modified);
- });
- }
- if (_.size(source.match(/\bfreeModule\b/g)) < 2) {
- source = removeVar(source, 'freeModule');
- }
- if (_.size(source.match(/\bfreeExports\b/g)) < 2) {
- source = removeVar(source, 'freeExports');
- }
-
- debugSource = cleanupSource(source);
- source = debugSource;
-
- /*------------------------------------------------------------------------*/
-
- // flag to track if `outputPath` has been used by `callback`
- var outputUsed = false;
-
- // flag to specify creating a custom build
- var isCustom = (
- isLegacy || isMapped || isModern || isNoDep || isStrict || isUnderscore || outputPath ||
- /(?:category|exclude|exports|iife|include|minus|plus)=.*$/.test(options) ||
- !_.isEqual(exportsOptions, exportsAll)
- );
-
- // used as the basename of the output path
- var basename = outputPath
- ? path.basename(outputPath, '.js')
- : 'lodash' + (isTemplate ? '.template' : isCustom ? '.custom' : '');
-
- // restore `dependencyMap`
- dependencyMap = dependencyBackup;
-
- // output debug build
- if (!isMinify && (isCustom || isDebug || isTemplate)) {
- if (isCustom) {
- debugSource = addCommandsToHeader(debugSource, options);
- }
- if (isDebug && isStdOut) {
- stdout.write(debugSource);
- callback({
- 'source': debugSource
- });
- }
- else if (!isStdOut) {
- filePath = outputPath || path.join(cwd, basename + '.js');
- outputUsed = true;
- callback({
- 'source': debugSource,
- 'outputPath': filePath
- });
- }
- }
- // begin the minification process
- if (!isDebug) {
- if (outputPath && outputUsed) {
- outputPath = path.join(path.dirname(outputPath), path.basename(outputPath, '.js') + '.min.js');
- } else if (!outputPath) {
- outputPath = path.join(cwd, basename + '.min.js');
- }
- minify(source, {
- 'filePath': filePath,
- 'isMapped': isMapped,
- 'isSilent': isSilent,
- 'isTemplate': isTemplate,
- 'modes': isIIFE && ['simple', 'hybrid'],
- 'outputPath': outputPath,
- 'sourceMapURL': sourceMapURL,
- 'onComplete': function(data) {
- if (isCustom) {
- data.source = addCommandsToHeader(data.source, options);
- }
- if (isStdOut) {
- delete data.outputPath;
- stdout.write(data.source);
- }
- callback(data);
- }
- });
- }
- }
-
- /*--------------------------------------------------------------------------*/
-
- // expose `build`
- if (module != require.main) {
- module.exports = build;
- }
- else {
- // or invoked directly
- build(process.argv, function(data) {
- var outputPath = data.outputPath,
- sourceMap = data.sourceMap;
-
- if (outputPath) {
- fs.writeFileSync(outputPath, data.source, 'utf8');
- if (sourceMap) {
- fs.writeFileSync(path.join(path.dirname(outputPath), path.basename(outputPath, '.js') + '.map'), sourceMap, 'utf8');
- }
- }
- });
- }
-}());
diff --git a/build/minify.js b/build/minify.js
deleted file mode 100755
index 64cf27e60b..0000000000
--- a/build/minify.js
+++ /dev/null
@@ -1,793 +0,0 @@
-#!/usr/bin/env node
-;(function() {
- 'use strict';
-
- /** Load Node.js modules */
- var cp = require('child_process'),
- https = require('https'),
- zlib = require('zlib');
-
- /** Load other modules */
- var _ = require('../lodash.js'),
- preprocess = require('./pre-compile.js'),
- postprocess = require('./post-compile.js'),
- tar = require('../vendor/tar/tar.js'),
- util = require('./util.js');
-
- /** Module shortcuts */
- var fs = util.fs,
- path = util.path;
-
- /** The Git object ID of `closure-compiler.tar.gz` */
- var closureId = '9fd5d61c1b706e7505aeb5187941c2c5497e5fd8';
-
- /** The Git object ID of `uglifyjs.tar.gz` */
- var uglifyId = '7de2795a3af58d1b293e3b0e83cdbc994f4941dc';
-
- /** The path of the directory that is the base of the repository */
- var basePath = fs.realpathSync(path.join(__dirname, '..'));
-
- /** The path of the `vendor` directory */
- var vendorPath = path.join(basePath, 'vendor');
-
- /** The path to the Closure Compiler `.jar` */
- var closurePath = path.join(vendorPath, 'closure-compiler', 'compiler.jar');
-
- /** The path to the UglifyJS module */
- var uglifyPath = path.join(vendorPath, 'uglifyjs', 'tools', 'node.js');
-
- /** The Closure Compiler command-line options */
- var closureOptions = ['--warning_level=QUIET'];
-
- /** The media type for raw blob data */
- var mediaType = 'application/vnd.github.v3.raw';
-
- /** Used to detect the Node.js executable in command-line arguments */
- var reNode = RegExp('(?:^|' + path.sepEscaped + ')node(?:\\.exe)?$');
-
- /** Used to reference parts of the blob href */
- var location = (function() {
- var host = 'api.github.com',
- origin = 'https://api.github.com',
- pathname = '/repos/bestiejs/lodash/git/blobs';
-
- return {
- 'host': host,
- 'href': origin + pathname,
- 'origin': origin,
- 'pathname': pathname
- };
- }());
-
- /** The Closure Compiler optimization modes */
- var optimizationModes = {
- 'simple': 'SIMPLE_OPTIMIZATIONS',
- 'advanced': 'ADVANCED_OPTIMIZATIONS'
- };
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Minifies a given Lo-Dash `source` and invokes the `options.onComplete`
- * callback when finished. The `onComplete` callback is invoked with one
- * argument; (outputSource).
- *
- * @param {Array|String} [source=''] The source to minify or array of commands.
- * -o, --output - Write output to a given path/filename.
- * -s, --silent - Skip status updates normally logged to the console.
- * -t, --template - Applies template specific minifier options.
- *
- * @param {Object} [options={}] The options object.
- * outputPath - Write output to a given path/filename.
- * isSilent - Skip status updates normally logged to the console.
- * isTemplate - Applies template specific minifier options.
- * onComplete - The function called once minification has finished.
- */
- function minify(source, options) {
- // used to specify the source map URL
- var sourceMapURL;
-
- // used to specify the default minifer modes
- var modes = ['simple', 'advanced', 'hybrid'];
-
- source || (source = '');
- options || (options = {});
-
- // juggle arguments
- if (Array.isArray(source)) {
- // convert commands to an options object
- options = source;
-
- // used to report invalid command-line arguments
- var invalidArgs = _.reject(options.slice(reNode.test(options[0]) ? 2 : 0), function(value, index, options) {
- if (/^(?:-o|--output)$/.test(options[index - 1]) ||
- /^modes=.*$/.test(value)) {
- return true;
- }
- var result = [
- '-o', '--output',
- '-p', '--source-map',
- '-s', '--silent',
- '-t', '--template'
- ].indexOf(value) > -1;
-
- if (!result && /^(?:-p|--source-map)$/.test(options[index - 1])) {
- result = true;
- sourceMapURL = value;
- }
- return result;
- });
-
- // report invalid arguments
- if (invalidArgs.length) {
- console.log(
- '\n' +
- 'Invalid argument' + (invalidArgs.length > 1 ? 's' : '') +
- ' passed: ' + invalidArgs.join(', ')
- );
- return;
- }
- var filePath = options[options.length - 1],
- isMapped = _.contains(options, '-p') || _.contains(options, '--source-map'),
- isSilent = _.contains(options, '-s') || _.contains(options, '--silent'),
- isTemplate = _.contains(options, '-t') || _.contains(options, '--template'),
- outputPath = path.join(path.dirname(filePath), path.basename(filePath, '.js') + '.min.js');
-
- modes = options.reduce(function(result, value) {
- var match = value.match(/modes=(.*)$/);
- return match ? match[1].split(/, */) : result;
- }, modes);
-
- outputPath = options.reduce(function(result, value, index) {
- if (/-o|--output/.test(value)) {
- result = options[index + 1];
- var dirname = path.dirname(result);
- fs.mkdirpSync(dirname);
- result = path.join(fs.realpathSync(dirname), path.basename(result));
- }
- return result;
- }, outputPath);
-
- options = {
- 'filePath': filePath,
- 'isMapped': isMapped,
- 'isSilent': isSilent,
- 'isTemplate': isTemplate,
- 'modes': modes,
- 'outputPath': outputPath,
- 'sourceMapURL': sourceMapURL
- };
-
- source = fs.readFileSync(filePath, 'utf8');
- }
-
- modes = options.modes || modes;
- if (options.isMapped) {
- modes = modes.filter(function(mode) {
- return mode != 'hybrid';
- });
- }
- if (options.isTemplate) {
- modes = modes.filter(function(mode) {
- return mode != 'advanced';
- });
- }
- options.modes = modes;
-
- // fetch the Closure Compiler
- getDependency({
- 'id': 'closure-compiler',
- 'hashId': closureId,
- 'path': vendorPath,
- 'title': 'the Closure Compiler',
- 'onComplete': function(exception) {
- var error = exception;
-
- // fetch UglifyJS
- getDependency({
- 'id': 'uglifyjs',
- 'hashId': uglifyId,
- 'title': 'UglifyJS',
- 'path': vendorPath,
- 'onComplete': function(exception) {
- error || (error = exception);
- if (!error) {
- new Minify(source, options);
- }
- }
- });
- }
- });
- }
-
- /**
- * The Minify constructor used to keep state of each `minify` invocation.
- *
- * @private
- * @constructor
- * @param {String} source The source to minify.
- * @param {Object} options The options object.
- * outputPath - Write output to a given path/filename.
- * isSilent - Skip status updates normally logged to the console.
- * isTemplate - Applies template specific minifier options.
- * onComplete - The function called once minification has finished.
- */
- function Minify(source, options) {
- // juggle arguments
- if (typeof source == 'object' && source) {
- options = source || options;
- source = options.source || '';
- }
- this.compiled = { 'simple': {}, 'advanced': {} };
- this.hybrid = { 'simple': {}, 'advanced': {} };
- this.uglified = {};
-
- this.filePath = options.filePath;
- this.isMapped = !!options.isMapped;
- this.isSilent = !!options.isSilent;
- this.isTemplate = !!options.isTemplate;
- this.outputPath = options.outputPath;
- this.sourceMapURL = options.sourceMapURL;
-
- var modes = this.modes = options.modes;
- source = this.source = preprocess(source, options);
-
- this.onComplete = options.onComplete || function(data) {
- var outputPath = this.outputPath,
- sourceMap = data.sourceMap;
-
- fs.writeFileSync(outputPath, data.source, 'utf8');
- if (sourceMap) {
- fs.writeFileSync(getMapPath(outputPath), sourceMap, 'utf8');
- }
- };
-
- // begin the minification process
- if (_.contains(modes, 'simple')) {
- closureCompile.call(this, source, 'simple', onClosureSimpleCompile.bind(this));
- } else if (_.contains(modes, 'advanced')) {
- onClosureSimpleGzip.call(this);
- } else {
- onClosureAdvancedGzip.call(this);
- }
- }
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Fetches a required `.tar.gz` dependency with the given Git object ID from
- * the Lo-Dash repo on GitHub. The object ID may be obtained by running
- * `git hash-object path/to/dependency.tar.gz`.
- *
- * @private
- * @param {Object} options The options object.
- * id - The Git object ID of the `.tar.gz` file.
- * onComplete - The function called once the extraction has finished.
- * path - The path of the extraction directory.
- * title - The dependency's title used in status updates logged to the console.
- */
- function getDependency(options) {
- options || (options = {});
-
- var ran,
- destPath = options.path,
- hashId = options.hashId,
- id = options.id,
- onComplete = options.onComplete,
- title = options.title;
-
- // exit early if dependency exists
- if (fs.existsSync(path.join(destPath, id))) {
- onComplete();
- return;
- }
- var callback = function(exception) {
- if (ran) {
- return;
- }
- if (exception) {
- console.error([
- 'There was a problem installing ' + title + '.',
- 'Try running the command as root, via `sudo`, or manually install by running:',
- '',
- "curl -H 'Accept: " + mediaType + "' " + location.href + '/' + hashId + " | tar xvz -C '" + destPath + "'",
- ''
- ].join('\n'));
- }
- ran = true;
- process.removeListener('uncaughtException', callback);
- onComplete(exception);
- };
-
- console.log('Downloading ' + title + '...');
- process.on('uncaughtException', callback);
-
- https.get({
- 'host': location.host,
- 'path': location.pathname + '/' + hashId,
- 'headers': {
- // By default, all GitHub blob API endpoints return a JSON document
- // containing Base64-encoded blob data. Overriding the `Accept` header
- // with the GitHub raw media type returns the blob data directly.
- // See http://developer.github.com/v3/media/.
- 'Accept': mediaType,
- // As of 2013-04-24, the GitHub API mandates the `User-Agent` header
- // for all requests.
- 'User-Agent': 'Lo-Dash/' + _.VERSION
- }
- }, function(response) {
- var decompressor = zlib.createUnzip(),
- parser = new tar.Extract({ 'path': destPath });
-
- parser.on('end', callback);
- response.pipe(decompressor).pipe(parser);
- });
- }
-
- /**
- * Retrieves the Java command-line options used for faster minification by
- * the Closure Compiler, invoking the `callback` when finished. Subsequent
- * calls will lazily return the previously retrieved options. The `callback`
- * is invoked with one argument; (options).
- *
- * See https://code.google.com/p/closure-compiler/wiki/FAQ#What_are_the_recommended_Java_VM_command-line_options?.
- *
- * @private
- * @param {Function} callback The function called once the options have been retrieved.
- */
- function getJavaOptions(callback) {
- var result = [];
- cp.exec('java -version -client -d32', function(error) {
- if (!error && process.platform != 'win32') {
- result.push('-client', '-d32');
- }
- getJavaOptions = function(callback) {
- _.defer(callback, result);
- };
- callback(result);
- });
- }
-
- /**
- * Resolves the source map path from the given output path.
- *
- * @private
- * @param {String} outputPath The output path.
- * @returns {String} Returns the source map path.
- */
- function getMapPath(outputPath) {
- return path.join(path.dirname(outputPath), path.basename(outputPath, '.js') + '.map');
- }
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Compresses a `source` string using the Closure Compiler. Yields the
- * minified result, and any exceptions encountered, to a `callback` function.
- *
- * @private
- * @param {String} source The JavaScript source to minify.
- * @param {String} mode The optimization mode.
- * @param {Function} callback The function called once the process has completed.
- */
- function closureCompile(source, mode, callback) {
- var filePath = this.filePath,
- isAdvanced = mode == 'advanced',
- isMapped = this.isMapped,
- isSilent = this.isSilent,
- isTemplate = this.isTemplate,
- options = closureOptions.slice(),
- outputPath = this.outputPath,
- mapPath = getMapPath(outputPath),
- sourceMapURL = this.sourceMapURL || path.basename(mapPath);
-
- // remove copyright header to make other modifications easier
- var license = (/^(?:\s*\/\/.*\s*|\s*\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\/\s*)*/.exec(source) || [''])[0];
- if (license) {
- source = source.replace(license, '');
- }
-
- var hasIIFE = /^;?\(function[^{]+{/.test(source),
- isStrict = hasIIFE && /^;?\(function[^{]+{\s*["']use strict["']/.test(source);
-
- // to avoid stripping the IIFE, convert it to a function call
- if (hasIIFE && isAdvanced) {
- source = source
- .replace(/\(function/, '__iife__$&')
- .replace(/\(this\)\)([\s;]*(\n\/\/.+)?)$/, ', this)$1');
- }
-
- options.push('--compilation_level=' + optimizationModes[mode]);
- if (isMapped) {
- options.push('--create_source_map=' + mapPath, '--source_map_format=V3');
- }
- if (isTemplate) {
- options.push('--charset=UTF-8');
- }
-
- getJavaOptions(function(javaOptions) {
- var compiler = cp.spawn('java', javaOptions.concat('-jar', closurePath, options));
- if (!isSilent) {
- console.log('Compressing ' + path.basename(outputPath, '.js') + ' using the Closure Compiler (' + mode + ')...');
- }
-
- var error = '';
- compiler.stderr.on('data', function(data) {
- error += data;
- });
-
- var output = '';
- compiler.stdout.on('data', function(data) {
- output += data;
- });
-
- compiler.on('exit', function(status) {
- // `status` contains the process exit code
- if (status) {
- var exception = new Error(error);
- exception.status = status;
- }
- // restore IIFE and move exposed vars inside the IIFE
- if (hasIIFE && isAdvanced) {
- output = output
- .replace(/__iife__\(/, '(')
- .replace(/,\s*this\)([\s;]*(\n\/\/.+)?)$/, '(this))$1')
- .replace(/^((?:var (?:\w+=(?:!0|!1|null)[,;])+)?)([\s\S]*?function[^{]+{)/, '$2$1');
- }
- // inject "use strict" directive
- if (isStrict) {
- output = output.replace(/^[\s\S]*?function[^{]+{/, '$&"use strict";');
- }
- // restore copyright header
- if (license) {
- output = license + output;
- }
- if (isMapped) {
- var mapOutput = fs.readFileSync(mapPath, 'utf8');
- fs.unlinkSync(mapPath);
- output = output.replace(/[\s;]*$/, '\n/*\n//@ sourceMappingURL=' + sourceMapURL) + '\n*/';
-
- mapOutput = JSON.parse(mapOutput);
- mapOutput.file = path.basename(outputPath);
- mapOutput.sources = [path.basename(filePath)];
- mapOutput = JSON.stringify(mapOutput, null, 2);
- }
- callback(exception, output, mapOutput);
- });
-
- // proxy the standard input to the Closure Compiler
- compiler.stdin.end(source);
- });
- }
-
- /**
- * Compresses a `source` string using UglifyJS. Yields the result to a
- * `callback` function. This function is synchronous; the `callback` is used
- * for symmetry.
- *
- * @private
- * @param {String} source The JavaScript source to minify.
- * @param {String} label The label to log.
- * @param {Function} callback The function called once the process has completed.
- */
- function uglify(source, label, callback) {
- if (!this.isSilent) {
- console.log('Compressing ' + path.basename(this.outputPath, '.js') + ' using ' + label + '...');
- }
- try {
- var uglifyJS = require(uglifyPath);
-
- // 1. parse
- var toplevel = uglifyJS.parse(source);
-
- // 2. compress
- // enable unsafe comparisons
- toplevel.figure_out_scope();
- toplevel = toplevel.transform(uglifyJS.Compressor({
- 'comparisons': false,
- 'unsafe': true,
- 'unsafe_comps': true,
- 'warnings': false
- }));
-
- // 3. mangle
- // excluding the `define` function exposed by AMD loaders
- toplevel.figure_out_scope();
- toplevel.compute_char_frequency();
- toplevel.mangle_names({
- 'except': ['define']
- });
-
- // 4. output
- // restrict lines to 500 characters for consistency with the Closure Compiler
- var stream = uglifyJS.OutputStream({
- 'ascii_only': !this.isTemplate,
- 'comments': /@cc_on|@license|@preserve/i,
- 'max_line_len': 500,
- });
-
- toplevel.print(stream);
- }
- catch(e) {
- var exception = e;
- }
- callback(exception, stream && String(stream));
- }
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * The Closure Compiler callback for simple optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {String} result The resulting minified source.
- * @param {String} map The source map output.
- */
- function onClosureSimpleCompile(exception, result, map) {
- if (exception) {
- throw exception;
- }
- result = postprocess(result);
-
- var simple = this.compiled.simple;
- simple.source = result;
- simple.sourceMap = map;
- zlib.gzip(result, onClosureSimpleGzip.bind(this));
- }
-
- /**
- * The Closure Compiler `gzip` callback for simple optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {Buffer} result The resulting gzipped source.
- */
- function onClosureSimpleGzip(exception, result) {
- if (exception) {
- throw exception;
- }
- if (result != null) {
- if (!this.isSilent) {
- console.log('Done. Size: %d bytes.', result.length);
- }
- this.compiled.simple.gzip = result;
- }
- // compile the source using advanced optimizations
- if (_.contains(this.modes, 'advanced')) {
- closureCompile.call(this, this.source, 'advanced', onClosureAdvancedCompile.bind(this));
- } else {
- onClosureAdvancedGzip.call(this);
- }
- }
-
- /**
- * The Closure Compiler callback for advanced optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {String} result The resulting minified source.
- * @param {String} map The source map output.
- */
- function onClosureAdvancedCompile(exception, result, map) {
- if (exception) {
- throw exception;
- }
- result = postprocess(result);
-
- var advanced = this.compiled.advanced;
- advanced.source = result;
- advanced.sourceMap = map;
- zlib.gzip(result, onClosureAdvancedGzip.bind(this));
- }
-
- /**
- * The Closure Compiler `gzip` callback for advanced optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {Buffer} result The resulting gzipped source.
- */
- function onClosureAdvancedGzip(exception, result) {
- if (exception) {
- throw exception;
- }
- if (result != null) {
- if (!this.isSilent) {
- console.log('Done. Size: %d bytes.', result.length);
- }
- this.compiled.advanced.gzip = result;
- }
- // minify the source using UglifyJS
- if (!this.isMapped) {
- uglify.call(this, this.source, 'UglifyJS', onUglify.bind(this));
- } else {
- onComplete.call(this);
- }
- }
-
- /**
- * The UglifyJS callback.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {String} result The resulting minified source.
- */
- function onUglify(exception, result) {
- if (exception) {
- throw exception;
- }
- result = postprocess(result);
- this.uglified.source = result;
- zlib.gzip(result, onUglifyGzip.bind(this));
- }
-
- /**
- * The UglifyJS `gzip` callback.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {Buffer} result The resulting gzipped source.
- */
- function onUglifyGzip(exception, result) {
- if (exception) {
- throw exception;
- }
- if (result != null) {
- if (!this.isSilent) {
- console.log('Done. Size: %d bytes.', result.length);
- }
- this.uglified.gzip = result;
- }
- // minify the already Closure Compiler simple optimized source using UglifyJS
- var modes = this.modes;
- if (_.contains(modes, 'hybrid')) {
- if (_.contains(modes, 'simple')) {
- uglify.call(this, this.compiled.simple.source, 'hybrid (simple)', onSimpleHybrid.bind(this));
- } else if (_.contains(modes, 'advanced')) {
- onSimpleHybridGzip.call(this);
- }
- } else {
- onComplete.call(this);
- }
- }
-
- /**
- * The hybrid callback for simple optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {String} result The resulting minified source.
- */
- function onSimpleHybrid(exception, result) {
- if (exception) {
- throw exception;
- }
- result = postprocess(result);
- this.hybrid.simple.source = result;
- zlib.gzip(result, onSimpleHybridGzip.bind(this));
- }
-
- /**
- * The hybrid `gzip` callback for simple optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {Buffer} result The resulting gzipped source.
- */
- function onSimpleHybridGzip(exception, result) {
- if (exception) {
- throw exception;
- }
- if (result != null) {
- if (!this.isSilent) {
- console.log('Done. Size: %d bytes.', result.length);
- }
- this.hybrid.simple.gzip = result;
- }
- // minify the already Closure Compiler advance optimized source using UglifyJS
- if (_.contains(this.modes, 'advanced')) {
- uglify.call(this, this.compiled.advanced.source, 'hybrid (advanced)', onAdvancedHybrid.bind(this));
- } else {
- onComplete.call(this);
- }
- }
-
- /**
- * The hybrid callback for advanced optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {String} result The resulting minified source.
- */
- function onAdvancedHybrid(exception, result) {
- if (exception) {
- throw exception;
- }
- result = postprocess(result);
- this.hybrid.advanced.source = result;
- zlib.gzip(result, onAdvancedHybridGzip.bind(this));
- }
-
- /**
- * The hybrid `gzip` callback for advanced optimizations.
- *
- * @private
- * @param {Object|Undefined} exception The error object.
- * @param {Buffer} result The resulting gzipped source.
- */
- function onAdvancedHybridGzip(exception, result) {
- if (exception) {
- throw exception;
- }
- if (result != null) {
- if (!this.isSilent) {
- console.log('Done. Size: %d bytes.', result.length);
- }
- this.hybrid.advanced.gzip = result;
- }
- // finish by choosing the smallest compressed file
- onComplete.call(this);
- }
-
- /**
- * The callback executed after the source is minified and gzipped.
- *
- * @private
- */
- function onComplete() {
- var compiledSimple = this.compiled.simple,
- compiledAdvanced = this.compiled.advanced,
- uglified = this.uglified,
- hybridSimple = this.hybrid.simple,
- hybridAdvanced = this.hybrid.advanced;
-
- var objects = [
- compiledSimple,
- compiledAdvanced,
- uglified,
- hybridSimple,
- hybridAdvanced
- ];
-
- var gzips = objects
- .map(function(data) { return data.gzip; })
- .filter(Boolean);
-
- // select the smallest gzipped file and use its minified counterpart as the
- // official minified release (ties go to the Closure Compiler)
- var min = gzips.reduce(function(min, gzip) {
- var length = gzip.length;
- return min > length ? length : min;
- }, Infinity);
-
- // pass the minified source to the "onComplete" callback
- objects.some(function(data) {
- var gzip = data.gzip;
- if (gzip && gzip.length == min) {
- data.outputPath = this.outputPath;
- this.onComplete(data);
- return true;
- }
- }, this);
- }
-
- /*--------------------------------------------------------------------------*/
-
- // expose `minify`
- if (module != require.main) {
- module.exports = minify;
- }
- else {
- // read the Lo-Dash source file from the first argument if the script
- // was invoked directly (e.g. `node minify.js source.js`) and write to
- // `.min.js`
- (function() {
- var options = process.argv;
- if (options.length < 3) {
- return;
- }
- minify(options);
- }());
- }
-}());
diff --git a/build/post-compile.js b/build/post-compile.js
deleted file mode 100644
index 0ff394d244..0000000000
--- a/build/post-compile.js
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-;(function() {
- 'use strict';
-
- /** Load Node.js modules */
- var fs = require('fs'),
- vm = require('vm');
-
- /** The minimal license/copyright template */
- var licenseTemplate = [
- '/**',
- ' * @license',
- ' * Lo-Dash <%= VERSION %> lodash.com/license',
- ' * Underscore.js 1.4.4 underscorejs.org/LICENSE',
- ' */'
- ].join('\n');
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Post-process a given minified Lo-Dash `source`, preparing it for
- * deployment.
- *
- * @param {String} source The source to process.
- * @returns {String} Returns the processed source.
- */
- function postprocess(source) {
- // correct overly aggressive Closure Compiler advanced optimization
- source = source
- .replace(/(document[^&]+&&)\s*(?:\w+|!\d)/, '$1!({toString:0}+"")')
- .replace(/"\t"/g, '"\\t"')
- .replace(/"[^"]*?\\f[^"]*?"/g,
- '" \\t\\x0B\\f\\xa0\\ufeff' +
- '\\n\\r\\u2028\\u2029' +
- '\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000"'
- );
-
- try {
- var context = vm.createContext({});
- vm.runInContext(source, context);
- } catch(e) { }
-
- ['forEach', 'forIn', 'forOwn'].forEach(function(methodName) {
- var pairs = /[!=]==\s*([a-zA-Z]+)(?!\()|([a-zA-Z]+)\s*[!=]==/.exec((context._ || {})[methodName]),
- varName = pairs && (pairs[1] || pairs[2]),
- value = (value = varName && RegExp('\\b' + varName + '\\s*=\\s*!([01])\\b').exec(source)) && !+value[1];
-
- if (typeof value == 'boolean') {
- // replace vars for `false` and `true` with boolean literals
- source = source.replace(RegExp('([!=]==\\s*)' + varName + '\\b(?!\\()|\\b' + varName + '(\\s*[!=]==)', 'g'), function(match, prelude, postlude, at) {
- // avoid replacing local variables with the same name
- return RegExp('\\b' + varName + '\\s*(?:,|=[^=])').test(source.slice(at - 10, at))
- ? match
- : (prelude || '') + value + (postlude || '');
- });
- }
- });
-
- // replace `!1` and `!0` in expressions with `false` and `true` values
- [/([!=]==)\s*!1\b|(.)!1\s*([!=]==)/g, /([!=]==)\s*!0\b|(.)!0\s*([!=]==)/g].forEach(function(regexp, index) {
- source = source.replace(regexp, function(match, prelude, chr, postlude) {
- return (prelude || chr + (/\w/.test(chr) ? ' ' : '')) + !!index + (postlude || '');
- });
- });
-
- // flip `typeof` expressions to help optimize Safari and
- // correct the AMD module definition for AMD build optimizers
- // (e.g. from `"number" == typeof x` to `typeof x == "number")
- source = source.replace(/(\w)?("[^"]+")\s*([!=]=)\s*(typeof(?:\s*\([^)]+\)|\s+[.\w]+(?!\[)))/g, function(match, other, type, equality, expression) {
- return (other ? other + ' ' : '') + expression + equality + type;
- });
-
- // add a space so `define` is detected by the Dojo builder
- source = source.replace(/(.)(define\()/, function(match, prelude, define) {
- return prelude + (/^\S/.test(prelude) ? ' ' : '') + define;
- });
-
- // add trailing semicolon
- if (source) {
- source = source.replace(/[\s;]*?(\s*\/\/.*\s*|\s*\/\*[^*]*\*+(?:[^\/][^*]*\*+)*\/\s*)*$/, ';$1');
- }
- // exit early if version snippet isn't found
- var snippet = /VERSION\s*[=:]\s*([\'"])(.*?)\1/.exec(source);
- if (!snippet) {
- return source;
- }
- // remove copyright header
- source = source.replace(/^\/\**[\s\S]+?\*\/\n/, '');
-
- // add new copyright header
- var version = snippet[2];
- source = licenseTemplate.replace('<%= VERSION %>', version) + '\n;' + source;
-
- return source;
- }
-
- /*--------------------------------------------------------------------------*/
-
- // expose `postprocess`
- if (module != require.main) {
- module.exports = postprocess;
- }
- else {
- // read the Lo-Dash source file from the first argument if the script
- // was invoked directly (e.g. `node post-compile.js source.js`) and write to
- // the same file
- (function() {
- var options = process.argv;
- if (options.length < 3) {
- return;
- }
- var filePath = options[options.length - 1],
- source = fs.readFileSync(filePath, 'utf8');
-
- fs.writeFileSync(filePath, postprocess(source), 'utf8');
- }());
- }
-}());
diff --git a/build/pre-compile.js b/build/pre-compile.js
deleted file mode 100644
index f7c1ef4ed1..0000000000
--- a/build/pre-compile.js
+++ /dev/null
@@ -1,473 +0,0 @@
-#!/usr/bin/env node
-;(function() {
- 'use strict';
-
- /** The Node.js filesystem module */
- var fs = require('fs');
-
- /** Used to minify variables embedded in compiled strings */
- var compiledVars = [
- 'args',
- 'argsIndex',
- 'argsLength',
- 'callback',
- 'className',
- 'collection',
- 'conditions',
- 'ctor',
- 'errorClass',
- 'errorProto',
- 'guard',
- 'hasOwnProperty',
- 'index',
- 'isArguments',
- 'isArray',
- 'isProto',
- 'isString',
- 'iterable',
- 'length',
- 'keys',
- 'lodash',
- 'nonEnum',
- 'nonEnumProps',
- 'object',
- 'objectProto',
- 'objectTypes',
- 'ownIndex',
- 'ownProps',
- 'result',
- 'skipErrorProps',
- 'skipProto',
- 'source',
- 'stringClass',
- 'stringProto',
- 'thisArg',
- 'toString'
- ];
-
- /** Used to minify `iteratorTemplate` data properties */
- var iteratorOptions = [
- 'args',
- 'array',
- 'bottom',
- 'firstArg',
- 'init',
- 'loop',
- 'shadowedProps',
- 'top',
- 'useHas',
- 'useKeys'
- ];
-
- /** Used to minify variables and string values to a single character */
- var minNames = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
- minNames.push.apply(minNames, minNames.map(function(value) {
- return value + value;
- }));
-
- /** Used to protect the specified properties from getting minified */
- var propWhitelist = [
- 'Array',
- 'Boolean',
- 'Date',
- 'Error',
- 'Function',
- 'Math',
- 'Number',
- 'Object',
- 'RegExp',
- 'String',
- 'TypeError',
- 'VERSION',
- '_',
- '__wrapped__',
- 'after',
- 'all',
- 'amd',
- 'any',
- 'argsClass',
- 'argsObject',
- 'array',
- 'assign',
- 'at',
- 'attachEvent',
- 'bind',
- 'bindAll',
- 'bindKey',
- 'cache',
- 'clearTimeout',
- 'clone',
- 'cloneDeep',
- 'collect',
- 'compact',
- 'compose',
- 'contains',
- 'countBy',
- 'createCallback',
- 'criteria',
- 'debounce',
- 'defaults',
- 'defer',
- 'delay',
- 'detect',
- 'difference',
- 'drop',
- 'each',
- 'enumErrorProps',
- 'enumPrototypes',
- 'environment',
- 'escape',
- 'evaluate',
- 'every',
- 'exports',
- 'extend',
- 'fastBind',
- 'fastKeys',
- 'filter',
- 'find',
- 'findIndex',
- 'findKey',
- 'first',
- 'flatten',
- 'foldl',
- 'foldr',
- 'forEach',
- 'forIn',
- 'forOwn',
- 'function',
- 'functions',
- 'global',
- 'groupBy',
- 'has',
- 'head',
- 'identity',
- 'imports',
- 'include',
- 'index',
- 'indexOf',
- 'initial',
- 'inject',
- 'interpolate',
- 'intersection',
- 'invert',
- 'invoke',
- 'isArguments',
- 'isArray',
- 'isBoolean',
- 'isDate',
- 'isElement',
- 'isEmpty',
- 'isEqual',
- 'isEqual',
- 'isFinite',
- 'isFinite',
- 'isFunction',
- 'isNaN',
- 'isNull',
- 'isNumber',
- 'isObject',
- 'isPlainObject',
- 'isRegExp',
- 'isString',
- 'isUndefined',
- 'keys',
- 'last',
- 'lastIndexOf',
- 'leading',
- 'map',
- 'max',
- 'maxWait',
- 'memoize',
- 'merge',
- 'methods',
- 'min',
- 'mixin',
- 'noConflict',
- 'nodeClass',
- 'nonEnumArgs',
- 'nonEnumShadows',
- 'null',
- 'number',
- 'object',
- 'omit',
- 'once',
- 'ownLast',
- 'pairs',
- 'parseInt',
- 'partial',
- 'partialRight',
- 'pick',
- 'pluck',
- 'random',
- 'range',
- 'reduce',
- 'reduceRight',
- 'reject',
- 'rest',
- 'result',
- 'runInContext',
- 'select',
- 'setImmediate',
- 'setTimeout',
- 'shuffle',
- 'size',
- 'some',
- 'sortBy',
- 'sortedIndex',
- 'source',
- 'spliceObjects',
- 'string',
- 'support',
- 'tail',
- 'take',
- 'tap',
- 'template',
- 'templateSettings',
- 'throttle',
- 'times',
- 'toArray',
- 'trailing',
- 'transform',
- 'undefined',
- 'unescape',
- 'unindexedChars',
- 'union',
- 'uniq',
- 'unique',
- 'uniqueId',
- 'unzip',
- 'value',
- 'values',
- 'variable',
- 'where',
- 'window',
- 'without',
- 'wrap',
- 'zip',
- 'zipObject',
-
- // properties used by the `backbone` and `underscore` builds
- '__chain__',
- 'chain',
- 'findWhere'
- ];
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Pre-process a given Lo-Dash `source`, preparing it for minification.
- *
- * @param {String} [source=''] The source to process.
- * @param {Object} [options={}] The options object.
- * @returns {String} Returns the processed source.
- */
- function preprocess(source, options) {
- source || (source = '');
- options || (options = {});
-
- // remove unrecognized JSDoc tags so the Closure Compiler won't complain
- source = source.replace(/@(?:alias|category)\b.*/g, '');
-
- if (options.isTemplate) {
- return source;
- }
- // add brackets to whitelisted properties so the Closure Compiler won't mung them
- // http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
- source = source.replace(RegExp('\\.(' + propWhitelist.join('|') + ')\\b', 'g'), function(match, prop) {
- return "['" + prop.replace(/['\n\r\t]/g, '\\$&') + "']";
- });
-
- // remove brackets from `lodash.createCallback` in `eachIteratorOptions`
- source = source.replace('lodash[\'createCallback\'](callback, thisArg)"', 'lodash.createCallback(callback, thisArg)"');
-
- // remove brackets from `lodash.createCallback` in `_.assign`
- source = source.replace("' var callback = lodash['createCallback']", "'var callback=lodash.createCallback");
-
- // remove brackets from `_.escape` in `_.template`
- source = source.replace(/__e *= *_\['escape']/g, '__e=_.escape');
-
- // remove brackets from `collection.indexOf` in `_.contains`
- source = source.replace("collection['indexOf'](target)", 'collection.indexOf(target)');
-
- // remove brackets from `result[length].value` in `_.sortBy`
- source = source.replace("result[length]['value']", 'result[length].value');
-
- // remove whitespace from string literals
- source = source.replace(/^((?:[ "'\w]+:)? *)"[^"\\\n]*(?:\\.[^"\\\n]*)*"|'[^'\\\n]*(?:\\.[^'\\\n]*)*'/gm, function(string, left) {
- // clip after an object literal property name or leading spaces
- if (left) {
- string = string.slice(left.length);
- }
- // avoids removing the '\n' of the `stringEscapes` object
- string = string.replace(/\[object |delete |else (?!{)|function | in | instanceof |return\s+[\w"']|throw |typeof |use strict|var |@ |(["'])\\n\1|\\\\n|\\n|\s+/g, function(match) {
- return match == false || match == '\\n' ? '' : match;
- });
- // unclip
- return (left || '') + string;
- });
-
- // remove whitespace from `_.template` related regexes
- source = source.replace(/reEmptyString\w+ *=.+/g, function(match) {
- return match.replace(/ |\\n/g, '');
- });
-
- // remove newline from double-quoted strings in `_.template`
- source = source
- .replace('"__p += \'"', '"__p+=\'"')
- .replace('"\';\n"', '"\';"')
-
- // remove debug sourceURL use in `_.template`
- source = source.replace(/(?:\s*\/\/.*\n)* *var sourceURL[^;]+;|\+ *sourceURL/g, '');
-
- // minify internal properties
- (function() {
- var methods = [
- 'cacheIndexOf',
- 'cachePush',
- 'compareAscending',
- 'createCache',
- 'getObject',
- 'releaseObject',
- 'sortBy',
- 'uniq'
- ];
-
- var props = [
- 'cache',
- 'criteria',
- 'index',
- 'value'
- ];
-
- var snippets = source.match(RegExp('^( *)(?:var|function) +(?:' + methods.join('|') + ')\\b[\\s\\S]+?\\n\\1}', 'gm'));
- if (!snippets) {
- return;
- }
- snippets.forEach(function(snippet) {
- var modified = snippet;
-
- // minify properties
- props.forEach(function(prop, index) {
- // use minified names different than those chosen for `iteratorOptions`
- var minName = minNames[iteratorOptions.length + index],
- reBracketProp = RegExp("\\['(" + prop + ")'\\]", 'g'),
- reDotProp = RegExp('\\.' + prop + '\\b', 'g'),
- rePropColon = RegExp("([^?\\s])\\s*([\"'])?\\b" + prop + "\\2 *:", 'g');
-
- modified = modified
- .replace(reBracketProp, "['" + minName + "']")
- .replace(reDotProp, "['" + minName + "']")
- .replace(rePropColon, "$1'" + minName + "':");
- });
-
- // replace with modified snippet
- source = source.replace(snippet, function() {
- return modified;
- });
- });
- }());
-
- // minify all compilable snippets
- var snippets = source.match(
- RegExp([
- // match the `iteratorTemplate`
- '^( *)var iteratorTemplate\\b[\\s\\S]+?\\n\\1}',
- // match methods created by `createIterator` calls
- 'createIterator\\((?:{|[a-zA-Z]+)[\\s\\S]*?\\);\\n',
- // match variables storing `createIterator` options
- '^( *)var [a-zA-Z]+IteratorOptions\\b[\\s\\S]+?\\n\\2}',
- // match `cachePush`, `createCache`, `createIterator`, `getObject`, `releaseObject`, and `uniq` functions
- '^( *)(?:var|function) +(?:cachePush|createCache|createIterator|getObject|releaseObject|uniq)\\b[\\s\\S]+?\\n\\3}'
- ].join('|'), 'gm')
- );
-
- // exit early if no compilable snippets
- if (!snippets) {
- return source;
- }
-
- snippets.forEach(function(snippet, index) {
- var isFunc = /\bfunction *[ \w]*\(/.test(snippet),
- isIteratorTemplate = /var iteratorTemplate\b/.test(snippet),
- modified = snippet;
-
- // add brackets to iterator option properties so the Closure Compiler won't mung them
- modified = modified.replace(RegExp('\\.(' + iteratorOptions.join('|') + ')\\b', 'g'), function(match, prop) {
- return "['" + prop.replace(/['\n\r\t]/g, '\\$&') + "']";
- });
-
- // remove unnecessary semicolons in strings
- modified = modified.replace(/;(?:}["']|(?:\\n|\s)*["']\s*\+\s*["'](?:\\n|\s)*})/g, function(match) {
- return match.slice(1);
- });
-
- // minify `createIterator` option property names
- iteratorOptions.forEach(function(property, index) {
- var minName = minNames[index];
-
- // minify variables in `iteratorTemplate` or property names in everything else
- modified = isIteratorTemplate
- ? modified.replace(RegExp('\\b' + property + '\\b', 'g'), minName)
- : modified.replace(RegExp("'" + property + "'", 'g'), "'" + minName + "'");
- });
-
- // minify snippet variables / arguments
- compiledVars.forEach(function(varName, index) {
- var minName = minNames[index];
-
- // minify variable names present in strings
- if (isFunc && !isIteratorTemplate) {
- modified = modified.replace(RegExp('((["\'])[^\\n\\2]*?)\\b' + varName + '\\b(?=[^\\n\\2]*\\2[ ,+;]+$)', 'gm'), function(match, prelude) {
- return prelude + minName;
- });
- }
- // ensure properties in compiled strings aren't minified
- else {
- modified = modified.replace(RegExp('([^.])\\b' + varName + '\\b(?!\' *[\\]:])', 'g'), function(match, prelude) {
- return prelude + minName;
- });
- }
- // correct `typeof` string values
- if (/^(?:boolean|function|object|number|string|undefined)$/.test(varName)) {
- modified = modified.replace(RegExp('(= *)(["\'])' + minName + '\\2|(["\'])' + minName + '\\3( *=)', 'g'), function(match, prelude, preQuote, postQuote, postlude) {
- return prelude
- ? prelude + preQuote + varName + preQuote
- : postQuote + varName + postQuote + postlude;
- });
- }
- });
-
- // replace with modified snippet
- source = source.replace(snippet, function() {
- return modified;
- });
- });
-
- return source;
- }
-
- /*--------------------------------------------------------------------------*/
-
- // expose `preprocess`
- if (module != require.main) {
- module.exports = preprocess;
- }
- else {
- // read the Lo-Dash source file from the first argument if the script
- // was invoked directly (e.g. `node pre-compile.js source.js`) and write to
- // the same file
- (function() {
- var options = process.argv;
- if (options.length < 3) {
- return;
- }
- var filePath = options[options.length - 1],
- isTemplate = options.indexOf('-t') > -1 || options.indexOf('--template') > -1,
- source = fs.readFileSync(filePath, 'utf8');
-
- fs.writeFileSync(filePath, preprocess(source, {
- 'isTemplate': isTemplate
- }), 'utf8');
- }());
- }
-}());
diff --git a/build/util.js b/build/util.js
deleted file mode 100755
index 0ea45c3cd7..0000000000
--- a/build/util.js
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env node
-;(function() {
- 'use strict';
-
- /** Load Node.js modules */
- var fs = require('fs'),
- path = require('path');
-
- /** Load other modules */
- var _ = require('../lodash.js');
-
- /** Used to indicate if running in Windows */
- var isWindows = process.platform == 'win32';
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * The path separator.
- *
- * @memberOf util.path
- * @type String
- */
- var sep = path.sep || (isWindows ? '\\' : '/');
-
- /**
- * The escaped path separator used for inclusion in RegExp strings.
- *
- * @memberOf util.path
- * @type String
- */
- var sepEscaped = sep.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
- /** Used to determine if a path is prefixed with a drive letter, dot, or slash */
- var rePrefixed = RegExp('^(?:' + (isWindows ? '[a-zA-Z]:|' : '') + '\\.?)' + sepEscaped);
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * Makes the given `dirname` directory, without throwing errors for existing
- * directories and making parent directories as needed.
- *
- * @memberOf util.fs
- * @param {String} dirname The path of the directory.
- * @param {Number|String} [mode='0777'] The permission mode.
- */
- function mkdirpSync(dirname, mode) {
- // ensure relative paths are prefixed with `./`
- if (!rePrefixed.test(dirname)) {
- dirname = '.' + sep + dirname;
- }
- dirname.split(sep).reduce(function(currPath, segment) {
- currPath += sep + segment;
- try {
- currPath = fs.realpathSync(currPath);
- } catch(e) {
- fs.mkdirSync(currPath, mode);
- }
- return currPath;
- });
- }
-
- /*--------------------------------------------------------------------------*/
-
- /**
- * The utility object.
- *
- * @type Object
- */
- var util = {
-
- /**
- * The file system object.
- *
- * @memberOf util
- * @type Object
- */
- 'fs': _.defaults(_.cloneDeep(fs), {
- 'existsSync': fs.existsSync || path.existsSync,
- 'mkdirpSync': mkdirpSync
- }),
-
- /**
- * The path object.
- *
- * @memberOf util
- * @type Object
- */
- 'path': _.defaults(_.cloneDeep(path), {
- 'sep': sep,
- 'sepEscaped': sepEscaped
- })
- };
-
- /*--------------------------------------------------------------------------*/
-
- // expose
- module.exports = util;
-}());
diff --git a/component.json b/component.json
index 96c9425e10..af014a9373 100644
--- a/component.json
+++ b/component.json
@@ -1,20 +1,12 @@
{
"name": "lodash",
- "repo": "bestiejs/lodash",
- "version": "1.3.1",
- "description": "A low-level utility library delivering consistency, customization, performance, and extra features.",
+ "repo": "lodash/lodash",
+ "version": "2.0.0",
+ "description": "A utility library delivering consistency, customization, performance, and extras.",
"license": "MIT",
+ "keywords": ["amd", "browser", "client", "customize", "functional", "performance", "server", "speed", "util"],
"scripts": [
"index.js",
"dist/lodash.compat.js"
- ],
- "keywords": [
- "browser",
- "client",
- "functional",
- "performance",
- "server",
- "speed",
- "util"
]
}
diff --git a/dist/lodash.compat.js b/dist/lodash.compat.js
index 7dc1deb6eb..5ec3c8cc21 100644
--- a/dist/lodash.compat.js
+++ b/dist/lodash.compat.js
@@ -1,13 +1,13 @@
/**
* @license
- * Lo-Dash 1.3.1 (Custom Build)
+ * Lo-Dash 2.0.0 (Custom Build)
* Build: `lodash -o ./dist/lodash.compat.js`
* Copyright 2012-2013 The Dojo Foundation
- * Based on Underscore.js 1.4.4
- * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+ * Based on Underscore.js 1.5.2
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
* Available under MIT license
*/
-;(function(window) {
+;(function() {
/** Used as a safe reference for `undefined` in pre ES5 environments */
var undefined;
@@ -31,14 +31,23 @@
/** Used as the max size of the `arrayPool` and `objectPool` */
var maxPoolSize = 40;
+ /** Used to detect and test whitespace */
+ var whitespace = (
+ // whitespace
+ ' \t\x0B\f\xA0\ufeff' +
+
+ // line terminators
+ '\n\r\u2028\u2029' +
+
+ // unicode category "Zs" space separators
+ '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
+ );
+
/** Used to match empty string literals in compiled template source */
var reEmptyStringLeading = /\b__p \+= '';/g,
reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
- /** Used to match HTML entities */
- var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;
-
/**
* Used to match ES6 template delimiters
* http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6
@@ -48,32 +57,20 @@
/** Used to match regexp flags from their coerced string values */
var reFlags = /\w*$/;
+ /** Used to detected named functions */
+ var reFuncName = /^function[ \n\r\t]+\w/;
+
/** Used to match "interpolate" template delimiters */
var reInterpolate = /<%=([\s\S]+?)%>/g;
- /** Used to detect functions containing a `this` reference */
- var reThis = (reThis = /\bthis\b/) && reThis.test(runInContext) && reThis;
-
- /** Used to detect and test whitespace */
- var whitespace = (
- // whitespace
- ' \t\x0B\f\xA0\ufeff' +
-
- // line terminators
- '\n\r\u2028\u2029' +
-
- // unicode category "Zs" space separators
- '\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000'
- );
-
/** Used to match leading whitespace and zeros to be removed */
var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');
/** Used to ensure capturing order of template delimiters */
var reNoMatch = /($^)/;
- /** Used to match HTML characters */
- var reUnescapedHtml = /[&<>"']/g;
+ /** Used to detect functions containing a `this` reference */
+ var reThis = (reThis = /\bthis\b/) && reThis.test(runInContext) && reThis;
/** Used to match unescaped characters in compiled string literals */
var reUnescapedString = /['\n\r\t\u2028\u2029\\]/g;
@@ -135,33 +132,36 @@
'\u2029': 'u2029'
};
+ /** Used as a reference to the global object */
+ var root = (objectTypes[typeof window] && window) || this;
+
/** Detect free variable `exports` */
var freeExports = objectTypes[typeof exports] && exports;
/** Detect free variable `module` */
var freeModule = objectTypes[typeof module] && module && module.exports == freeExports && module;
- /** Detect free variable `global`, from Node.js or Browserified code, and use it as `window` */
+ /** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
var freeGlobal = objectTypes[typeof global] && global;
if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
- window = freeGlobal;
+ root = freeGlobal;
}
/*--------------------------------------------------------------------------*/
/**
- * A basic implementation of `_.indexOf` without support for binary searches
+ * The base implementation of `_.indexOf` without support for binary searches
* or `fromIndex` constraints.
*
* @private
* @param {Array} array The array to search.
- * @param {Mixed} value The value to search for.
- * @param {Number} [fromIndex=0] The index to search from.
- * @returns {Number} Returns the index of the matched value or `-1`.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
*/
- function basicIndexOf(array, value, fromIndex) {
+ function baseIndexOf(array, value, fromIndex) {
var index = (fromIndex || 0) - 1,
- length = array.length;
+ length = array ? array.length : 0;
while (++index < length) {
if (array[index] === value) {
@@ -177,32 +177,32 @@
*
* @private
* @param {Object} cache The cache object to inspect.
- * @param {Mixed} value The value to search for.
- * @returns {Number} Returns `0` if `value` is found, else `-1`.
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `0` if `value` is found, else `-1`.
*/
function cacheIndexOf(cache, value) {
var type = typeof value;
cache = cache.cache;
if (type == 'boolean' || value == null) {
- return cache[value];
+ return cache[value] ? 0 : -1;
}
if (type != 'number' && type != 'string') {
type = 'object';
}
var key = type == 'number' ? value : keyPrefix + value;
- cache = cache[type] || (cache[type] = {});
+ cache = (cache = cache[type]) && cache[key];
return type == 'object'
- ? (cache[key] && basicIndexOf(cache[key], value) > -1 ? 0 : -1)
- : (cache[key] ? 0 : -1);
+ ? (cache && baseIndexOf(cache, value) > -1 ? 0 : -1)
+ : (cache ? 0 : -1);
}
/**
* Adds a given `value` to the corresponding cache object.
*
* @private
- * @param {Mixed} value The value to add to the cache.
+ * @param {*} value The value to add to the cache.
*/
function cachePush(value) {
var cache = this.cache,
@@ -218,9 +218,7 @@
typeCache = cache[type] || (cache[type] = {});
if (type == 'object') {
- if ((typeCache[key] || (typeCache[key] = [])).push(value) == this.array.length) {
- cache[type] = false;
- }
+ (typeCache[key] || (typeCache[key] = [])).push(value);
} else {
typeCache[key] = true;
}
@@ -228,44 +226,45 @@
}
/**
- * Used by `_.max` and `_.min` as the default `callback` when a given
- * `collection` is a string value.
+ * Used by `_.max` and `_.min` as the default callback when a given
+ * collection is a string value.
*
* @private
- * @param {String} value The character to inspect.
- * @returns {Number} Returns the code unit of given character.
+ * @param {string} value The character to inspect.
+ * @returns {number} Returns the code unit of given character.
*/
function charAtCallback(value) {
return value.charCodeAt(0);
}
/**
- * Used by `sortBy` to compare transformed `collection` values, stable sorting
+ * Used by `sortBy` to compare transformed `collection` elements, stable sorting
* them in ascending order.
*
* @private
* @param {Object} a The object to compare to `b`.
* @param {Object} b The object to compare to `a`.
- * @returns {Number} Returns the sort order indicator of `1` or `-1`.
+ * @returns {number} Returns the sort order indicator of `1` or `-1`.
*/
function compareAscending(a, b) {
- var ai = a.index,
- bi = b.index;
-
- a = a.criteria;
- b = b.criteria;
+ var ac = a.criteria,
+ bc = b.criteria;
// ensure a stable sort in V8 and other engines
// http://code.google.com/p/v8/issues/detail?id=90
- if (a !== b) {
- if (a > b || typeof a == 'undefined') {
+ if (ac !== bc) {
+ if (ac > bc || typeof ac == 'undefined') {
return 1;
}
- if (a < b || typeof b == 'undefined') {
+ if (ac < bc || typeof bc == 'undefined') {
return -1;
}
}
- return ai < bi ? -1 : 1;
+ // The JS engine embedded in Adobe applications like InDesign has a buggy
+ // `Array#sort` implementation that causes it, under certain circumstances,
+ // to return the same value for `a` and `b`.
+ // See https://github.com/jashkenas/underscore/pull/1247
+ return a.index - b.index;
}
/**
@@ -273,12 +272,17 @@
*
* @private
* @param {Array} [array=[]] The array to search.
- * @returns {Null|Object} Returns the cache object or `null` if caching should not be used.
+ * @returns {null|Object} Returns the cache object or `null` if caching should not be used.
*/
function createCache(array) {
var index = -1,
- length = array.length;
+ length = array.length,
+ first = array[0],
+ last = array[length - 1];
+ if (first && typeof first == 'object' && last && typeof last == 'object') {
+ return false;
+ }
var cache = getObject();
cache['false'] = cache['null'] = cache['true'] = cache['undefined'] = false;
@@ -290,9 +294,7 @@
while (++index < length) {
result.push(array[index]);
}
- return cache.object === false
- ? (releaseObject(result), null)
- : result;
+ return result;
}
/**
@@ -300,8 +302,8 @@
* string literals.
*
* @private
- * @param {String} match The matched character to escape.
- * @returns {String} Returns the escaped character.
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
*/
function escapeStringChar(match) {
return '\\' + stringEscapes[match];
@@ -329,11 +331,14 @@
'array': null,
'bottom': '',
'cache': null,
+ 'configurable': false,
'criteria': null,
+ 'enumerable': false,
'false': false,
'firstArg': '',
'index': 0,
'init': '',
+ 'keys': null,
'leading': false,
'loop': '',
'maxWait': 0,
@@ -348,8 +353,8 @@
'true': false,
'undefined': false,
'useHas': false,
- 'useKeys': false,
- 'value': null
+ 'value': null,
+ 'writable': false
};
}
@@ -357,8 +362,8 @@
* Checks if `value` is a DOM node in IE < 9.
*
* @private
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true` if the `value` is a DOM node, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a DOM node, else `false`.
*/
function isNode(value) {
// IE < 9 presents DOM nodes as `Object` objects except they have `toString`
@@ -376,7 +381,7 @@
}
/**
- * Releases the given `array` back to the array pool.
+ * Releases the given array back to the array pool.
*
* @private
* @param {Array} [array] The array to release.
@@ -389,7 +394,7 @@
}
/**
- * Releases the given `object` back to the object pool.
+ * Releases the given object back to the object pool.
*
* @private
* @param {Object} [object] The object to release.
@@ -409,13 +414,13 @@
* Slices the `collection` from the `start` index up to, but not including,
* the `end` index.
*
- * Note: This function is used, instead of `Array#slice`, to support node lists
+ * Note: This function is used instead of `Array#slice` to support node lists
* in IE < 9 and to ensure dense arrays are returned.
*
* @private
- * @param {Array|Object|String} collection The collection to slice.
- * @param {Number} start The start index.
- * @param {Number} end The end index.
+ * @param {Array|Object|string} collection The collection to slice.
+ * @param {number} start The start index.
+ * @param {number} end The end index.
* @returns {Array} Returns the new array.
*/
function slice(array, start, end) {
@@ -441,15 +446,15 @@
* @static
* @memberOf _
* @category Utilities
- * @param {Object} [context=window] The context object.
+ * @param {Object} [context=root] The context object.
* @returns {Function} Returns the `lodash` function.
*/
function runInContext(context) {
// Avoid issues with some ES3 environments that attempt to use values, named
// after built-in constructors like `Object`, for the creation of literals.
// ES5 clears this up by stating that literals must use built-in constructors.
- // See http://es5.github.com/#x11.1.5.
- context = context ? _.defaults(window.Object(), context, _.pick(window, contextProps)) : window;
+ // See http://es5.github.io/#x11.1.5.
+ context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;
/** Native constructor references */
var Array = context.Array,
@@ -490,7 +495,6 @@
/** Native method shortcuts */
var ceil = Math.ceil,
clearTimeout = context.clearTimeout,
- concat = arrayRef.concat,
floor = Math.floor,
fnToString = Function.prototype.toString,
getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
@@ -499,11 +503,22 @@
propertyIsEnumerable = objectProto.propertyIsEnumerable,
setImmediate = context.setImmediate,
setTimeout = context.setTimeout,
- toString = objectProto.toString;
+ splice = arrayRef.splice,
+ toString = objectProto.toString,
+ unshift = arrayRef.unshift;
+
+ var defineProperty = (function() {
+ try {
+ var o = {},
+ func = reNative.test(func = Object.defineProperty) && func,
+ result = func(o, o, o) && func;
+ } catch(e) { }
+ return result;
+ }());
/* Native method shortcuts for methods with the same name as other `lodash` methods */
var nativeBind = reNative.test(nativeBind = toString.bind) && nativeBind,
- nativeCreate = reNative.test(nativeCreate = Object.create) && nativeCreate,
+ nativeCreate = reNative.test(nativeCreate = Object.create) && nativeCreate,
nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,
nativeIsFinite = context.isFinite,
nativeIsNaN = context.isNaN,
@@ -551,7 +566,7 @@
/*--------------------------------------------------------------------------*/
/**
- * Creates a `lodash` object, which wraps the given `value`, to enable method
+ * Creates a `lodash` object which wraps the given value to enable method
* chaining.
*
* In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
@@ -563,32 +578,33 @@
*
* The chainable wrapper functions are:
* `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,
- * `compose`, `concat`, `countBy`, `createCallback`, `debounce`, `defaults`,
- * `defer`, `delay`, `difference`, `filter`, `flatten`, `forEach`, `forIn`,
- * `forOwn`, `functions`, `groupBy`, `initial`, `intersection`, `invert`,
- * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
- * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `push`, `range`,
- * `reject`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, `sortBy`, `splice`,
+ * `compose`, `concat`, `countBy`, `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`, `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`
+ * `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
- * passed, otherwise they return unwrapped values.
+ * provided, otherwise they return unwrapped values.
*
* @name _
* @constructor
- * @alias chain
* @category Chaining
- * @param {Mixed} value The value to wrap in a `lodash` instance.
+ * @param {*} value The value to wrap in a `lodash` instance.
* @returns {Object} Returns a `lodash` instance.
* @example
*
@@ -622,10 +638,12 @@
* A fast path for creating `lodash` wrapper objects.
*
* @private
- * @param {Mixed} value The value to wrap in a `lodash` instance.
+ * @param {*} value The value to wrap in a `lodash` instance.
+ * @param {boolean} chainAll A flag to enable chaining for all methods
* @returns {Object} Returns a `lodash` instance.
*/
- function lodashWrapper(value) {
+ function lodashWrapper(value, chainAll) {
+ this.__chain__ = !!chainAll;
this.__wrapped__ = value;
}
// ensure `new lodashWrapper` is an instance of `lodash`
@@ -653,7 +671,7 @@
* Detect if `arguments` objects are `Object` objects (all but Narwhal and Opera < 10.5).
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.argsObject = arguments.constructor == Object && !(arguments instanceof Array);
@@ -661,16 +679,16 @@
* Detect if an `arguments` object's [[Class]] is resolvable (all but Firefox < 4, IE < 9).
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
- support.argsClass = isArguments(arguments);
+ support.argsClass = toString.call(arguments) == argsClass;
/**
* Detect if `name` or `message` properties of `Error.prototype` are
* enumerable by default. (IE < 9, Safari < 5.1)
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name');
@@ -683,7 +701,7 @@
* value to `true`.
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype');
@@ -691,15 +709,23 @@
* Detect if `Function#bind` exists and is inferred to be fast (all but V8).
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.fastBind = nativeBind && !isV8;
+ /**
+ * Detect if `Function#name` is supported (all but IE).
+ *
+ * @memberOf _.support
+ * @type boolean
+ */
+ support.funcNames = typeof Function.name == 'string';
+
/**
* Detect if own properties are iterated after inherited properties (all but IE < 9).
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.ownLast = props[0] != 'x';
@@ -708,7 +734,7 @@
* (Firefox < 4, IE < 9, PhantomJS, Safari < 5.1).
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.nonEnumArgs = prop != 0;
@@ -719,7 +745,7 @@
* made non-enumerable as well (a.k.a the JScript [[DontEnum]] bug).
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.nonEnumShadows = !/valueOf/.test(props);
@@ -733,7 +759,7 @@
* is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.spliceObjects = (arrayRef.splice.call(object, 0, 1), !object[0]);
@@ -744,7 +770,7 @@
* characters by index on string literals.
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx';
@@ -754,7 +780,7 @@
* a string without a `toString` function.
*
* @memberOf _.support
- * @type Boolean
+ * @type boolean
*/
try {
support.nodeClass = !(toString.call(document) == objectClass && !({ 'toString': 0 } + ''));
@@ -802,7 +828,7 @@
* Used to reference the data object in the template text.
*
* @memberOf _.templateSettings
- * @type String
+ * @type string
*/
'variable': '',
@@ -831,7 +857,7 @@
*
* @private
* @param {Object} data The data object used to populate the text.
- * @returns {String} Returns the interpolated text.
+ * @returns {string} Returns the interpolated text.
*/
var iteratorTemplate = function(obj) {
@@ -868,14 +894,14 @@
var conditions = []; if (support.enumPrototypes) { conditions.push('!(skipProto && index == "prototype")'); } if (support.enumErrorProps) { conditions.push('!(skipErrorProps && (index == "message" || index == "name"))'); }
- if (obj.useHas && obj.useKeys) {
+ if (obj.useHas && obj.keys) {
__p += '\n var ownIndex = -1,\n ownProps = objectTypes[typeof iterable] && keys(iterable),\n length = ownProps ? ownProps.length : 0;\n\n while (++ownIndex < length) {\n index = ownProps[ownIndex];\n';
if (conditions.length) {
__p += ' if (' +
(conditions.join(' && ')) +
') {\n ';
}
- __p +=
+ __p +=
(obj.loop) +
'; ';
if (conditions.length) {
@@ -889,7 +915,7 @@
(conditions.join(' && ')) +
') {\n ';
}
- __p +=
+ __p +=
(obj.loop) +
'; ';
if (conditions.length) {
@@ -917,250 +943,755 @@
if (obj.array || support.nonEnumArgs) {
__p += '\n}';
}
- __p +=
+ __p +=
(obj.bottom) +
';\nreturn result';
return __p
};
- /** Reusable iterator options for `assign` and `defaults` */
- var defaultsIteratorOptions = {
- 'args': 'object, source, guard',
- 'top':
- 'var args = arguments,\n' +
- ' argsIndex = 0,\n' +
- " argsLength = typeof guard == 'number' ? 2 : args.length;\n" +
- 'while (++argsIndex < argsLength) {\n' +
- ' iterable = args[argsIndex];\n' +
- ' if (iterable && objectTypes[typeof iterable]) {',
- 'loop': "if (typeof result[index] == 'undefined') result[index] = iterable[index]",
- 'bottom': ' }\n}'
- };
-
- /** Reusable iterator options shared by `each`, `forIn`, and `forOwn` */
- var eachIteratorOptions = {
- 'args': 'collection, callback, thisArg',
- 'top': "callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg)",
- 'array': "typeof length == 'number'",
- 'loop': 'if (callback(iterable[index], index, collection) === false) return result'
- };
-
- /** Reusable iterator options for `forIn` and `forOwn` */
- var forOwnIteratorOptions = {
- 'top': 'if (!objectTypes[typeof iterable]) return result;\n' + eachIteratorOptions.top,
- 'array': false
- };
-
/*--------------------------------------------------------------------------*/
/**
- * Creates a function that, when called, invokes `func` with the `this` binding
- * of `thisArg` and prepends any `partialArgs` to the arguments passed to the
- * bound function.
+ * The base implementation of `_.clone` without argument juggling or support
+ * for `thisArg` binding.
*
* @private
- * @param {Function|String} func The function to bind or the method name.
- * @param {Mixed} [thisArg] The `this` binding of `func`.
- * @param {Array} partialArgs An array of arguments to be partially applied.
- * @param {Object} [idicator] Used to indicate binding by key or partially
- * applying arguments from the right.
- * @returns {Function} Returns the new bound function.
+ * @param {*} value The value to clone.
+ * @param {boolean} [deep=false] A flag to indicate 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 createBound(func, thisArg, partialArgs, indicator) {
- var isFunc = isFunction(func),
- isPartial = !partialArgs,
- key = thisArg;
+ function baseClone(value, deep, callback, stackA, stackB) {
+ var result = value;
- // juggle arguments
- if (isPartial) {
- var rightIndicator = indicator;
- partialArgs = thisArg;
- }
- else if (!isFunc) {
- if (!indicator) {
- throw new TypeError;
+ if (callback) {
+ result = callback(result);
+ if (typeof result != 'undefined') {
+ return result;
}
- thisArg = func;
+ result = value;
}
-
- function bound() {
- // `Function#bind` spec
- // http://es5.github.com/#x15.3.4.5
- var args = arguments,
- thisBinding = isPartial ? this : thisArg;
-
- if (!isFunc) {
- func = thisArg[key];
- }
- if (partialArgs.length) {
- args = args.length
- ? (args = nativeSlice.call(args), rightIndicator ? args.concat(partialArgs) : partialArgs.concat(args))
- : partialArgs;
- }
- if (this instanceof bound) {
- // ensure `new bound` is an instance of `func`
- thisBinding = createObject(func.prototype);
-
- // mimic the constructor's `return` behavior
- // http://es5.github.com/#x13.2.2
- var result = func.apply(thisBinding, args);
- return isObject(result) ? result : thisBinding;
+ // inspect [[Class]]
+ var isObj = isObject(result);
+ if (isObj) {
+ var className = toString.call(result);
+ if (!cloneableClasses[className] || (!support.nodeClass && isNode(result))) {
+ return result;
}
- return func.apply(thisBinding, args);
+ var isArr = isArray(result);
}
- return bound;
- }
+ // shallow clone
+ if (!isObj || !deep) {
+ return isObj
+ ? (isArr ? slice(result) : assign({}, result))
+ : result;
+ }
+ var ctor = ctorByClass[className];
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ return new ctor(+result);
- /**
- * Creates compiled iteration functions.
- *
- * @private
- * @param {Object} [options1, options2, ...] The compile options object(s).
- * array - A string of code to determine if the iterable is an array or array-like.
- * useHas - A boolean to specify using `hasOwnProperty` checks in the object loop.
- * useKeys - A boolean to specify using `_.keys` for own property iteration.
- * args - A string of comma separated arguments the iteration function will accept.
- * top - A string of code to execute before the iteration branches.
- * loop - A string of code to execute in the object loop.
- * bottom - A string of code to execute after the iteration branches.
- * @returns {Function} Returns the compiled function.
- */
- function createIterator() {
- var data = getObject();
+ case numberClass:
+ case stringClass:
+ return new ctor(result);
- // data properties
- data.shadowedProps = shadowedProps;
- // iterator options
- data.array = data.bottom = data.loop = data.top = '';
- data.init = 'iterable';
- data.useHas = true;
- data.useKeys = !!keys;
+ case regexpClass:
+ return ctor(result.source, reFlags.exec(result));
+ }
+ // check for circular references and return corresponding clone
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
- // merge options into a template data object
- for (var object, index = 0; object = arguments[index]; index++) {
- for (var key in object) {
- data[key] = object[key];
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == value) {
+ return stackB[length];
}
}
- var args = data.args;
- data.firstArg = /^[^,]+/.exec(args)[0];
+ // init cloned object
+ result = isArr ? ctor(result.length) : {};
- // create the function factory
- var factory = Function(
- 'errorClass, errorProto, hasOwnProperty, isArguments, isArray, ' +
- 'isString, keys, lodash, objectProto, objectTypes, nonEnumProps, ' +
- 'stringClass, stringProto, toString',
- 'return function(' + args + ') {\n' + iteratorTemplate(data) + '\n}'
- );
+ // 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;
+ }
+ }
+ // add the source value to the stack of traversed objects
+ // and associate it with its clone
+ stackA.push(value);
+ stackB.push(result);
- releaseObject(data);
+ // recursively populate clone (susceptible to call stack limits)
+ (isArr ? baseEach : forOwn)(value, function(objValue, key) {
+ result[key] = baseClone(objValue, deep, callback, stackA, stackB);
+ });
- // return the compiled function
- return factory(
- errorClass, errorProto, hasOwnProperty, isArguments, isArray,
- isString, keys, lodash, objectProto, objectTypes, nonEnumProps,
- stringClass, stringProto, toString
- );
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
}
/**
- * Creates a new object with the specified `prototype`.
+ * The base implementation of `_.createCallback` without support for creating
+ * "_.pluck" or "_.where" style callbacks.
*
* @private
- * @param {Object} prototype The prototype object.
- * @returns {Object} Returns the new object.
+ * @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 createObject(prototype) {
- return isObject(prototype) ? nativeCreate(prototype) : {};
- }
- // fallback for browsers without `Object.create`
- if (!nativeCreate) {
- var createObject = function(prototype) {
- if (isObject(prototype)) {
- noop.prototype = prototype;
- var result = new noop;
- noop.prototype = null;
+ function baseCreateCallback(func, thisArg, argCount) {
+ if (typeof func != 'function') {
+ return identity;
+ }
+ // exit early if there is no `thisArg`
+ if (typeof thisArg == 'undefined') {
+ return func;
+ }
+ var bindData = func.__bindData__ || (support.funcNames && !func.name);
+ if (typeof bindData == 'undefined') {
+ var source = reThis && fnToString.call(func);
+ if (!support.funcNames && source && !reFuncName.test(source)) {
+ bindData = true;
}
- return result || {};
- };
+ if (support.funcNames || !bindData) {
+ // checks if `func` references the `this` keyword and stores the result
+ bindData = !reThis || reThis.test(source);
+ setBindData(func, bindData);
+ }
+ }
+ // exit early if there are no `this` references or `func` is bound
+ if (bindData !== true && (bindData && 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);
}
/**
- * Used by `escape` to convert characters to HTML entities.
+ * The base implementation of `_.flatten` without support for callback
+ * shorthands or `thisArg` binding.
*
* @private
- * @param {String} match The matched character to escape.
- * @returns {String} Returns the escaped character.
+ * @param {Array} array The array to flatten.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @param {boolean} [isArgArrays=false] A flag to restrict flattening to arrays and `arguments` objects.
+ * @param {number} [fromIndex=0] The index to start from.
+ * @returns {Array} Returns a new flattened array.
*/
- function escapeHtmlChar(match) {
- return htmlEscapes[match];
- }
+ function baseFlatten(array, isShallow, isArgArrays, fromIndex) {
+ var index = (fromIndex || 0) - 1,
+ length = array ? array.length : 0,
+ result = [];
- /**
- * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
- * customized, this method returns the custom method, otherwise it returns
- * the `basicIndexOf` function.
- *
- * @private
- * @returns {Function} Returns the "indexOf" function.
- */
- function getIndexOf(array, value, fromIndex) {
- var result = (result = lodash.indexOf) === indexOf ? basicIndexOf : result;
+ while (++index < length) {
+ var value = array[index];
+ // recursively flatten arrays (susceptible to call stack limits)
+ if (value && typeof value == 'object' && (isArray(value) || isArguments(value))) {
+ push.apply(result, isShallow ? value : baseFlatten(value, isShallow, isArgArrays));
+ } else if (!isArgArrays) {
+ result.push(value);
+ }
+ }
return result;
}
/**
- * Creates a function that juggles arguments, allowing argument overloading
- * for `_.flatten` and `_.uniq`, before passing them to the given `func`.
+ * The base implementation of `_.isEqual`, without support for `thisArg` binding,
+ * that allows partial "_.where" style comparisons.
*
* @private
- * @param {Function} func The function to wrap.
- * @returns {Function} Returns the new function.
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
+ * @param {Function} [callback] The function to customize comparing values.
+ * @param {Function} [isWhere=false] A flag to indicate performing partial comparisons.
+ * @param {Array} [stackA=[]] Tracks traversed `a` objects.
+ * @param {Array} [stackB=[]] Tracks traversed `b` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
*/
- function overloadWrapper(func) {
- return function(array, flag, callback, thisArg) {
- // juggle arguments
- if (typeof flag != 'boolean' && flag != null) {
- thisArg = callback;
- callback = !(thisArg && thisArg[flag] === array) ? flag : undefined;
- flag = false;
- }
- if (callback != null) {
- callback = lodash.createCallback(callback, thisArg);
+ function baseIsEqual(a, b, callback, isWhere, stackA, stackB) {
+ // used to indicate that when comparing objects, `a` has at least the properties of `b`
+ if (callback) {
+ var result = callback(a, b);
+ if (typeof result != 'undefined') {
+ return !!result;
}
- return func(array, flag, callback, thisArg);
- };
- }
-
- /**
- * A fallback implementation of `isPlainObject` which checks if a given `value`
- * is an object created by the `Object` constructor, assuming objects created
- * by the `Object` constructor have no inherited enumerable properties and that
- * there are no `Object.prototype` extensions.
- *
- * @private
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
- */
- function shimIsPlainObject(value) {
- var ctor,
- result;
-
- // avoid non Object objects, `arguments` objects, and DOM elements
- if (!(value && toString.call(value) == objectClass) ||
- (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor)) ||
- (!support.argsClass && isArguments(value)) ||
- (!support.nodeClass && isNode(value))) {
- return false;
}
- // IE < 9 iterates inherited properties before own properties. If the first
- // iterated property is an object's own property then there are no inherited
- // enumerable properties.
- if (support.ownLast) {
- forIn(value, function(value, key, object) {
- result = hasOwnProperty.call(object, key);
- return false;
+ // exit early for identical values
+ if (a === b) {
+ // treat `+0` vs. `-0` as not equal
+ return a !== 0 || (1 / a == 1 / b);
+ }
+ var type = typeof a,
+ otherType = typeof b;
+
+ // exit early for unlike primitive values
+ if (a === a &&
+ !(a && objectTypes[type]) &&
+ !(b && objectTypes[otherType])) {
+ return false;
+ }
+ // exit early for `null` and `undefined` avoiding ES3's Function#call behavior
+ // http://es5.github.io/#x15.3.4.4
+ if (a == null || b == null) {
+ return a === b;
+ }
+ // compare [[Class]] names
+ var className = toString.call(a),
+ otherClass = toString.call(b);
+
+ if (className == argsClass) {
+ className = objectClass;
+ }
+ if (otherClass == argsClass) {
+ otherClass = objectClass;
+ }
+ if (className != otherClass) {
+ return false;
+ }
+ switch (className) {
+ case boolClass:
+ case dateClass:
+ // coerce dates and booleans to numbers, dates to milliseconds and booleans
+ // to `1` or `0` treating invalid dates coerced to `NaN` as not equal
+ return +a == +b;
+
+ case numberClass:
+ // treat `NaN` vs. `NaN` as equal
+ return (a != +a)
+ ? b != +b
+ // but treat `+0` vs. `-0` as not equal
+ : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+ case regexpClass:
+ case stringClass:
+ // coerce regexes to strings (http://es5.github.io/#x15.10.6.4)
+ // treat string primitives and their corresponding object instances as equal
+ return a == String(b);
+ }
+ var isArr = className == arrayClass;
+ if (!isArr) {
+ // unwrap any `lodash` wrapped values
+ if (hasOwnProperty.call(a, '__wrapped__ ') || hasOwnProperty.call(b, '__wrapped__')) {
+ return baseIsEqual(a.__wrapped__ || a, b.__wrapped__ || b, callback, isWhere, stackA, stackB);
+ }
+ // exit for functions and DOM nodes
+ if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) {
+ return false;
+ }
+ // in older versions of Opera, `arguments` objects have `Array` constructors
+ var ctorA = !support.argsObject && isArguments(a) ? Object : a.constructor,
+ ctorB = !support.argsObject && isArguments(b) ? Object : b.constructor;
+
+ // non `Object` object instances with different constructors are not equal
+ if (ctorA != ctorB && !(
+ isFunction(ctorA) && ctorA instanceof ctorA &&
+ isFunction(ctorB) && ctorB instanceof ctorB
+ )) {
+ return false;
+ }
+ }
+ // assume cyclic structures are equal
+ // the algorithm for detecting cyclic structures is adapted from ES 5.1
+ // section 15.12.3, abstract operation `JO` (http://es5.github.io/#x15.12.3)
+ var initedStack = !stackA;
+ stackA || (stackA = getArray());
+ stackB || (stackB = getArray());
+
+ var length = stackA.length;
+ while (length--) {
+ if (stackA[length] == a) {
+ return stackB[length] == b;
+ }
+ }
+ var size = 0;
+ result = true;
+
+ // add `a` and `b` to the stack of traversed objects
+ stackA.push(a);
+ stackB.push(b);
+
+ // recursively compare objects and arrays (susceptible to call stack limits)
+ if (isArr) {
+ length = a.length;
+ size = b.length;
+
+ // compare lengths to determine if a deep comparison is necessary
+ result = size == a.length;
+ if (!result && !isWhere) {
+ return result;
+ }
+ // deep compare the contents, ignoring non-numeric properties
+ while (size--) {
+ var index = length,
+ value = b[size];
+
+ if (isWhere) {
+ while (index--) {
+ if ((result = baseIsEqual(a[index], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ } else if (!(result = baseIsEqual(a[size], value, callback, isWhere, stackA, stackB))) {
+ break;
+ }
+ }
+ return result;
+ }
+ // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+ // which, in this case, is more costly
+ forIn(b, function(value, key, b) {
+ if (hasOwnProperty.call(b, key)) {
+ // count the number of properties.
+ size++;
+ // deep compare each property value.
+ return (result = hasOwnProperty.call(a, key) && baseIsEqual(a[key], value, callback, isWhere, stackA, stackB));
+ }
+ });
+
+ if (result && !isWhere) {
+ // ensure both objects have the same number of properties
+ forIn(a, function(value, key, a) {
+ if (hasOwnProperty.call(a, key)) {
+ // `size` will be `-1` if `a` has more properties than `b`
+ return (result = --size > -1);
+ }
+ });
+ }
+ if (initedStack) {
+ releaseArray(stackA);
+ releaseArray(stackB);
+ }
+ return result;
+ }
+
+ /**
+ * The base implementation of `_.merge` without argument juggling or support
+ * for `thisArg` binding.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {Function} [callback] The function to customize merging properties.
+ * @param {Array} [stackA=[]] Tracks traversed source objects.
+ * @param {Array} [stackB=[]] Associates values with source counterparts.
+ */
+ function baseMerge(object, source, callback, stackA, stackB) {
+ (isArray(source) ? forEach : forOwn)(source, function(source, key) {
+ var found,
+ isArr,
+ result = source,
+ value = object[key];
+
+ if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+ // avoid merging previously merged cyclic sources
+ var stackLength = stackA.length;
+ while (stackLength--) {
+ if ((found = stackA[stackLength] == source)) {
+ value = stackB[stackLength];
+ break;
+ }
+ }
+ if (!found) {
+ var isShallow;
+ if (callback) {
+ result = callback(value, source);
+ if ((isShallow = typeof result != 'undefined')) {
+ value = result;
+ }
+ }
+ if (!isShallow) {
+ value = isArr
+ ? (isArray(value) ? value : [])
+ : (isPlainObject(value) ? value : {});
+ }
+ // add `source` and associated `value` to the stack of traversed objects
+ stackA.push(source);
+ stackB.push(value);
+
+ // recursively merge objects and arrays (susceptible to call stack limits)
+ if (!isShallow) {
+ baseMerge(value, source, callback, stackA, stackB);
+ }
+ }
+ }
+ else {
+ if (callback) {
+ result = callback(value, source);
+ if (typeof result == 'undefined') {
+ result = source;
+ }
+ }
+ if (typeof result != 'undefined') {
+ value = result;
+ }
+ }
+ object[key] = value;
+ });
+ }
+
+ /**
+ * The base implementation of `_.uniq` without support for callback shorthands
+ * or `thisArg` binding.
+ *
+ * @private
+ * @param {Array} array The array to process.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @param {Function} [callback] The function called per iteration.
+ * @returns {Array} Returns a duplicate-value-free array.
+ */
+ function baseUniq(array, isSorted, callback) {
+ var index = -1,
+ indexOf = getIndexOf(),
+ length = array ? array.length : 0,
+ result = [];
+
+ var isLarge = !isSorted && length >= largeArraySize && indexOf === baseIndexOf,
+ seen = (callback || isLarge) ? getArray() : result;
+
+ if (isLarge) {
+ var cache = createCache(seen);
+ if (cache) {
+ indexOf = cacheIndexOf;
+ seen = cache;
+ } else {
+ isLarge = false;
+ seen = callback ? seen : (releaseArray(seen), result);
+ }
+ }
+ while (++index < length) {
+ var value = array[index],
+ computed = callback ? callback(value, index, array) : value;
+
+ if (isSorted
+ ? !index || seen[seen.length - 1] !== computed
+ : indexOf(seen, computed) < 0
+ ) {
+ if (callback || isLarge) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ if (isLarge) {
+ releaseArray(seen.array);
+ releaseObject(seen);
+ } else if (callback) {
+ releaseArray(seen);
+ }
+ return result;
+ }
+
+ /**
+ * Creates a function that aggregates a collection, creating an object composed
+ * of keys generated from the results of running each element of the collection
+ * through a callback. The given `setter` function sets the keys and values
+ * of the composed object.
+ *
+ * @private
+ * @param {Function} setter The setter function.
+ * @returns {Function} Returns the new aggregator function.
+ */
+ function createAggregator(setter) {
+ return function(collection, callback, thisArg) {
+ var result = {};
+ callback = lodash.createCallback(callback, thisArg, 3);
+
+ if (isArray(collection)) {
+ var index = -1,
+ length = collection.length;
+
+ while (++index < length) {
+ var value = collection[index];
+ setter(result, value, callback(value, index, collection), collection);
+ }
+ } else {
+ baseEach(collection, function(value, key, collection) {
+ setter(result, value, callback(value, key, collection), collection);
+ });
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Creates a function that, when called, either curries or invokes `func`
+ * with an optional `this` binding and partially applied arguments.
+ *
+ * @private
+ * @param {Function|string} func The function or method name to reference.
+ * @param {number} bitmask The bitmask of method flags to compose.
+ * The bitmask may be composed of the following flags:
+ * 1 - `_.bind`
+ * 2 - `_.bindKey`
+ * 4 - `_.curry`
+ * 8 - `_.curry` (bound)
+ * 16 - `_.partial`
+ * 32 - `_.partialRight`
+ * @param {Array} [partialArgs] An array of arguments to prepend to those
+ * provided to the new function.
+ * @param {Array} [partialRightArgs] An array of arguments to append to those
+ * provided to the new function.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {number} [arity] The arity of `func`.
+ * @returns {Function} Returns the new bound function.
+ */
+ function createBound(func, bitmask, partialArgs, partialRightArgs, thisArg, arity) {
+ var isBind = bitmask & 1,
+ isBindKey = bitmask & 2,
+ isCurry = bitmask & 4,
+ isCurryBound = bitmask & 8,
+ isPartial = bitmask & 16,
+ isPartialRight = bitmask & 32,
+ key = func;
+
+ if (!isBindKey && !isFunction(func)) {
+ throw new TypeError;
+ }
+ if (isPartial && !partialArgs.length) {
+ bitmask &= ~16;
+ isPartial = partialArgs = false;
+ }
+ if (isPartialRight && !partialRightArgs.length) {
+ bitmask &= ~32;
+ isPartialRight = partialRightArgs = false;
+ }
+ var bindData = func && func.__bindData__;
+ if (bindData) {
+ if (isBind && !(bindData[1] & 1)) {
+ bindData[4] = thisArg;
+ }
+ if (!isBind && bindData[1] & 1) {
+ bitmask |= 8;
+ }
+ if (isCurry && !(bindData[1] & 4)) {
+ bindData[5] = arity;
+ }
+ if (isPartial) {
+ push.apply(bindData[2] || (bindData[2] = []), partialArgs);
+ }
+ if (isPartialRight) {
+ push.apply(bindData[3] || (bindData[3] = []), partialRightArgs);
+ }
+ bindData[1] |= bitmask;
+ return createBound.apply(null, bindData);
+ }
+ // use `Function#bind` if it exists and is fast
+ // (in V8 `Function#bind` is slower except when partially applied)
+ if (isBind && !(isBindKey || isCurry || isPartialRight) &&
+ (support.fastBind || (nativeBind && isPartial))) {
+ if (isPartial) {
+ var args = [thisArg];
+ push.apply(args, partialArgs);
+ }
+ var bound = isPartial
+ ? nativeBind.apply(func, args)
+ : nativeBind.call(func, thisArg);
+ }
+ else {
+ bound = function() {
+ // `Function#bind` spec
+ // http://es5.github.io/#x15.3.4.5
+ var args = arguments,
+ thisBinding = isBind ? thisArg : this;
+
+ if (isCurry || isPartial || isPartialRight) {
+ args = nativeSlice.call(args);
+ if (isPartial) {
+ unshift.apply(args, partialArgs);
+ }
+ if (isPartialRight) {
+ push.apply(args, partialRightArgs);
+ }
+ if (isCurry && args.length < arity) {
+ bitmask |= 16 & ~32;
+ return createBound(func, (isCurryBound ? bitmask : bitmask & ~3), args, null, thisArg, arity);
+ }
+ }
+ if (isBindKey) {
+ func = thisBinding[key];
+ }
+ if (this instanceof bound) {
+ // ensure `new bound` is an instance of `func`
+ thisBinding = createObject(func.prototype);
+
+ // mimic the constructor's `return` behavior
+ // http://es5.github.io/#x13.2.2
+ var result = func.apply(thisBinding, args);
+ return isObject(result) ? result : thisBinding;
+ }
+ return func.apply(thisBinding, args);
+ };
+ }
+ setBindData(bound, nativeSlice.call(arguments));
+ return bound;
+ }
+
+ /**
+ * Creates compiled iteration functions.
+ *
+ * @private
+ * @param {...Object} [options] The compile options object(s).
+ * @param {string} [options.array] Code to determine if the iterable is an array or array-like.
+ * @param {boolean} [options.useHas] Specify using `hasOwnProperty` checks in the object loop.
+ * @param {Function} [options.keys] A reference to `_.keys` for use in own property iteration.
+ * @param {string} [options.args] A comma separated string of iteration function arguments.
+ * @param {string} [options.top] Code to execute before the iteration branches.
+ * @param {string} [options.loop] Code to execute in the object loop.
+ * @param {string} [options.bottom] Code to execute after the iteration branches.
+ * @returns {Function} Returns the compiled function.
+ */
+ function createIterator() {
+ var data = getObject();
+
+ // data properties
+ data.shadowedProps = shadowedProps;
+
+ // iterator options
+ data.array = data.bottom = data.loop = data.top = '';
+ data.init = 'iterable';
+ data.useHas = true;
+
+ // merge options into a template data object
+ for (var object, index = 0; object = arguments[index]; index++) {
+ for (var key in object) {
+ data[key] = object[key];
+ }
+ }
+ var args = data.args;
+ data.firstArg = /^[^,]+/.exec(args)[0];
+
+ // create the function factory
+ var factory = Function(
+ 'baseCreateCallback, errorClass, errorProto, hasOwnProperty, ' +
+ 'indicatorObject, isArguments, isArray, isString, keys, objectProto, ' +
+ 'objectTypes, nonEnumProps, stringClass, stringProto, toString',
+ 'return function(' + args + ') {\n' + iteratorTemplate(data) + '\n}'
+ );
+
+ releaseObject(data);
+
+ // return the compiled function
+ return factory(
+ baseCreateCallback, errorClass, errorProto, hasOwnProperty,
+ indicatorObject, isArguments, isArray, isString, data.keys, objectProto,
+ objectTypes, nonEnumProps, stringClass, stringProto, toString
+ );
+ }
+
+ /**
+ * Creates a new object with the specified `prototype`.
+ *
+ * @private
+ * @param {Object} prototype The prototype object.
+ * @returns {Object} Returns the new object.
+ */
+ function createObject(prototype) {
+ return isObject(prototype) ? nativeCreate(prototype) : {};
+ }
+ // fallback for browsers without `Object.create`
+ if (!nativeCreate) {
+ createObject = function(prototype) {
+ if (isObject(prototype)) {
+ noop.prototype = prototype;
+ var result = new noop;
+ noop.prototype = null;
+ }
+ return result || {};
+ };
+ }
+
+ /**
+ * Used by `escape` to convert characters to HTML entities.
+ *
+ * @private
+ * @param {string} match The matched character to escape.
+ * @returns {string} Returns the escaped character.
+ */
+ function escapeHtmlChar(match) {
+ return htmlEscapes[match];
+ }
+
+ /**
+ * Gets the appropriate "indexOf" function. If the `_.indexOf` method is
+ * customized, this method returns the custom method, otherwise it returns
+ * the `baseIndexOf` function.
+ *
+ * @private
+ * @returns {Function} Returns the "indexOf" function.
+ */
+ function getIndexOf() {
+ var result = (result = lodash.indexOf) === indexOf ? baseIndexOf : result;
+ return result;
+ }
+
+ /**
+ * Sets `this` binding data on a given function.
+ *
+ * @private
+ * @param {Function} func The function to set data on.
+ * @param {*} value The value to set.
+ */
+ var setBindData = !defineProperty ? noop : function(func, value) {
+ var descriptor = getObject();
+ descriptor.value = value;
+ defineProperty(func, '__bindData__', descriptor);
+ releaseObject(descriptor);
+ };
+
+ /**
+ * A fallback implementation of `isPlainObject` which checks if a given value
+ * is an object created by the `Object` constructor, assuming objects created
+ * by the `Object` constructor have no inherited enumerable properties and that
+ * there are no `Object.prototype` extensions.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ */
+ function shimIsPlainObject(value) {
+ var ctor,
+ result;
+
+ // avoid non Object objects, `arguments` objects, and DOM elements
+ if (!(value && toString.call(value) == objectClass) ||
+ (ctor = value.constructor, isFunction(ctor) && !(ctor instanceof ctor)) ||
+ (!support.argsClass && isArguments(value)) ||
+ (!support.nodeClass && isNode(value))) {
+ return false;
+ }
+ // IE < 9 iterates inherited properties before own properties. If the first
+ // iterated property is an object's own property then there are no inherited
+ // enumerable properties.
+ if (support.ownLast) {
+ forIn(value, function(value, key, object) {
+ result = hasOwnProperty.call(object, key);
+ return false;
});
return result !== false;
}
@@ -1170,15 +1701,15 @@
forIn(value, function(value, key) {
result = key;
});
- return result === undefined || hasOwnProperty.call(value, result);
+ return typeof result == 'undefined' || hasOwnProperty.call(value, result);
}
/**
* Used by `unescape` to convert HTML entities to characters.
*
* @private
- * @param {String} match The matched character to unescape.
- * @returns {String} Returns the unescaped character.
+ * @param {string} match The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
*/
function unescapeHtmlChar(match) {
return htmlUnescapes[match];
@@ -1192,8 +1723,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is an `arguments` object, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an `arguments` object, else `false`.
* @example
*
* (function() { return _.isArguments(arguments); })(1, 2, 3);
@@ -1203,12 +1734,12 @@
* // => false
*/
function isArguments(value) {
- return toString.call(value) == argsClass;
+ return (value && typeof value == 'object') ? toString.call(value) == argsClass : false;
}
// fallback for browsers that can't detect `arguments` objects by [[Class]]
if (!support.argsClass) {
isArguments = function(value) {
- return value ? hasOwnProperty.call(value, 'callee') : false;
+ return (value && typeof value == 'object') ? hasOwnProperty.call(value, 'callee') : false;
};
}
@@ -1217,9 +1748,10 @@
*
* @static
* @memberOf _
+ * @type Function
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is an array, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an array, else `false`.
* @example
*
* (function() { return _.isArray(arguments); })();
@@ -1229,7 +1761,7 @@
* // => true
*/
var isArray = nativeIsArray || function(value) {
- return value ? (typeof value == 'object' && toString.call(value) == arrayClass) : false;
+ return (value && typeof value == 'object') ? toString.call(value) == arrayClass : false;
};
/**
@@ -1239,7 +1771,7 @@
* @private
* @type Function
* @param {Object} object The object to inspect.
- * @returns {Array} Returns a new array of property names.
+ * @returns {Array} Returns an array of property names.
*/
var shimKeys = createIterator({
'args': 'object',
@@ -1249,17 +1781,17 @@
});
/**
- * Creates an array composed of the own enumerable property names of `object`.
+ * Creates an array composed of the own enumerable property names of an object.
*
* @static
* @memberOf _
* @category Objects
* @param {Object} object The object to inspect.
- * @returns {Array} Returns a new array of property names.
+ * @returns {Array} Returns an array of property names.
* @example
*
* _.keys({ 'one': 1, 'two': 2, 'three': 3 });
- * // => ['one', 'two', 'three'] (order is not guaranteed)
+ * // => ['one', 'two', 'three'] (property order is not guaranteed across environments)
*/
var keys = !nativeKeys ? shimKeys : function(object) {
if (!isObject(object)) {
@@ -1272,21 +1804,35 @@
return nativeKeys(object);
};
- /**
- * 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 {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Array|Object|String} Returns `collection`.
- */
- var basicEach = createIterator(eachIteratorOptions);
+ /** Reusable iterator options shared by `each`, `forIn`, and `forOwn` */
+ var eachIteratorOptions = {
+ 'args': 'collection, callback, thisArg',
+ 'top': "callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3)",
+ 'array': "typeof length == 'number'",
+ 'keys': keys,
+ 'loop': 'if (callback(iterable[index], index, collection) === false) return result'
+ };
+
+ /** Reusable iterator options for `assign` and `defaults` */
+ var defaultsIteratorOptions = {
+ 'args': 'object, source, guard',
+ 'top':
+ 'var args = arguments,\n' +
+ ' argsIndex = 0,\n' +
+ " argsLength = typeof guard == 'number' ? 2 : args.length;\n" +
+ 'while (++argsIndex < argsLength) {\n' +
+ ' iterable = args[argsIndex];\n' +
+ ' if (iterable && objectTypes[typeof iterable]) {',
+ 'keys': keys,
+ 'loop': "if (typeof result[index] == 'undefined') result[index] = iterable[index]",
+ 'bottom': ' }\n}'
+ };
+
+ /** Reusable iterator options for `forIn` and `forOwn` */
+ var forOwnIteratorOptions = {
+ 'top': 'if (!objectTypes[typeof iterable]) return result;\n' + eachIteratorOptions.top,
+ 'array': false
+ };
/**
* Used to convert characters to HTML entities:
@@ -1307,14 +1853,34 @@
/** Used to convert HTML entities to characters */
var htmlUnescapes = invert(htmlEscapes);
+ /** Used to match HTML entities and HTML characters */
+ var reEscapedHtml = RegExp('(' + keys(htmlUnescapes).join('|') + ')', 'g'),
+ reUnescapedHtml = RegExp('[' + keys(htmlEscapes).join('') + ']', 'g');
+
+ /**
+ * 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);
+
/*--------------------------------------------------------------------------*/
/**
* Assigns own enumerable properties of source object(s) to the destination
* object. Subsequent sources will overwrite property assignments of previous
- * sources. If a `callback` function is passed, it will be executed to produce
- * the assigned values. The `callback` is bound to `thisArg` and invoked with
- * two arguments; (objectValue, sourceValue).
+ * sources. If a callback is provided it will be executed to produce the
+ * assigned values. The callback is bound to `thisArg` and invoked with two
+ * arguments; (objectValue, sourceValue).
*
* @static
* @memberOf _
@@ -1322,9 +1888,9 @@
* @alias extend
* @category Objects
* @param {Object} object The destination object.
- * @param {Object} [source1, source2, ...] The source objects.
+ * @param {...Object} [source] The source objects.
* @param {Function} [callback] The function to customize assigning values.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Object} Returns the destination object.
* @example
*
@@ -1344,7 +1910,7 @@
defaultsIteratorOptions.top.replace(';',
';\n' +
"if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {\n" +
- ' var callback = lodash.createCallback(args[--argsLength - 1], args[argsLength--], 2);\n' +
+ ' var callback = baseCreateCallback(args[--argsLength - 1], args[argsLength--], 2);\n' +
"} else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {\n" +
' callback = args[--argsLength];\n' +
'}'
@@ -1353,22 +1919,20 @@
});
/**
- * Creates a clone of `value`. If `deep` is `true`, nested objects will also
- * be cloned, otherwise they will be assigned by reference. If a `callback`
- * function is passed, it will be executed to produce the cloned values. If
- * `callback` returns `undefined`, cloning will be handled by the method instead.
- * The `callback` is bound to `thisArg` and invoked with one argument; (value).
+ * Creates a clone of `value`. If `deep` is `true` nested objects will also
+ * be cloned, otherwise they will be assigned by reference. If a callback
+ * is provided it will be executed to produce the cloned values. If the
+ * callback returns `undefined` cloning will be handled by the method instead.
+ * The callback is bound to `thisArg` and invoked with one argument; (value).
*
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to clone.
- * @param {Boolean} [deep=false] A flag to indicate a deep clone.
+ * @param {*} value The value to clone.
+ * @param {boolean} [deep=false] A flag to indicate a deep clone.
* @param {Function} [callback] The function to customize cloning values.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @param- {Array} [stackA=[]] Tracks traversed source objects.
- * @param- {Array} [stackB=[]] Associates clones with source counterparts.
- * @returns {Mixed} Returns the cloned `value`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the cloned `value`.
* @example
*
* var stooges = [
@@ -1385,109 +1949,31 @@
* // => false
*
* _.mixin({
- * 'clone': _.partialRight(_.clone, function(value) {
- * return _.isElement(value) ? value.cloneNode(false) : undefined;
- * })
- * });
- *
- * var clone = _.clone(document.body);
- * clone.childNodes.length;
- * // => 0
- */
- function clone(value, deep, callback, thisArg, stackA, stackB) {
- var result = value;
-
- // allows working with "Collections" methods without using their `callback`
- // argument, `index|key`, for this method's `callback`
- if (typeof deep != 'boolean' && deep != null) {
- thisArg = callback;
- callback = deep;
- deep = false;
- }
- if (typeof callback == 'function') {
- callback = (typeof thisArg == 'undefined')
- ? callback
- : lodash.createCallback(callback, thisArg, 1);
-
- result = callback(result);
- if (typeof result != 'undefined') {
- return result;
- }
- result = value;
- }
- // inspect [[Class]]
- var isObj = isObject(result);
- if (isObj) {
- var className = toString.call(result);
- if (!cloneableClasses[className] || (!support.nodeClass && isNode(result))) {
- return result;
- }
- var isArr = isArray(result);
- }
- // shallow clone
- if (!isObj || !deep) {
- return isObj
- ? (isArr ? slice(result) : assign({}, result))
- : result;
- }
- var ctor = ctorByClass[className];
- switch (className) {
- case boolClass:
- case dateClass:
- return new ctor(+result);
-
- case numberClass:
- case stringClass:
- return new ctor(result);
-
- case regexpClass:
- return ctor(result.source, reFlags.exec(result));
- }
- // 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];
- }
- }
- // init cloned object
- result = isArr ? ctor(result.length) : {};
-
- // 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;
- }
- }
- // 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 ? basicEach : forOwn)(value, function(objValue, key) {
- result[key] = clone(objValue, deep, callback, undefined, stackA, stackB);
- });
-
- if (initedStack) {
- releaseArray(stackA);
- releaseArray(stackB);
+ * 'clone': _.partialRight(_.clone, function(value) {
+ * return _.isElement(value) ? value.cloneNode(false) : undefined;
+ * })
+ * });
+ *
+ * var clone = _.clone(document.body);
+ * clone.childNodes.length;
+ * // => 0
+ */
+ function clone(value, deep, callback, thisArg) {
+ // allows working with "Collections" methods without using their `index`
+ // and `collection` arguments for `deep` and `callback`
+ if (typeof deep != 'boolean' && deep != null) {
+ thisArg = callback;
+ callback = deep;
+ deep = false;
}
- return result;
+ return baseClone(value, deep, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
}
/**
- * Creates a deep clone of `value`. If a `callback` function is passed,
- * it will be executed to produce the cloned values. If `callback` returns
- * `undefined`, cloning will be handled by the method instead. The `callback`
- * is bound to `thisArg` and invoked with one argument; (value).
+ * Creates a deep clone of `value`. If a callback is provided it will be
+ * executed to produce the cloned values. If the callback returns `undefined`
+ * cloning will be handled by the method instead. The callback is bound to
+ * `thisArg` and invoked with one argument; (value).
*
* Note: This method is loosely based on the structured clone algorithm. Functions
* and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
@@ -1497,10 +1983,10 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to deep clone.
+ * @param {*} value The value to deep clone.
* @param {Function} [callback] The function to customize cloning values.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the deep cloned `value`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the deep cloned `value`.
* @example
*
* var stooges = [
@@ -1525,7 +2011,7 @@
* // => false
*/
function cloneDeep(value, callback, thisArg) {
- return clone(value, true, callback, thisArg);
+ return baseClone(value, true, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 1));
}
/**
@@ -1538,9 +2024,9 @@
* @type Function
* @category Objects
* @param {Object} object The destination object.
- * @param {Object} [source1, source2, ...] The source objects.
+ * @param {...Object} [source] The source objects.
* @param- {Object} [guard] Allows working with `_.reduce` without using its
- * callback's `key` and `object` arguments as sources.
+ * `key` and `object` arguments as sources.
* @returns {Object} Returns the destination object.
* @example
*
@@ -1551,28 +2037,28 @@
var defaults = createIterator(defaultsIteratorOptions);
/**
- * This method is similar to `_.find`, except that it returns the key of the
- * element that passes the callback check, instead of the element itself.
+ * This method is like `_.findIndex` except that it returns the key of the
+ * first element that passes the callback check, instead of the element itself.
*
* @static
* @memberOf _
* @category Objects
* @param {Object} object The object to search.
- * @param {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the key of the found element, else `undefined`.
+ * @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 {string|undefined} Returns the key of the found element, else `undefined`.
* @example
*
* _.findKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function(num) {
* return num % 2 == 0;
* });
- * // => 'b'
+ * // => 'b' (property order is not guaranteed across environments)
*/
function findKey(object, callback, thisArg) {
var result;
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
forOwn(object, function(value, key, object) {
if (callback(value, key, object)) {
result = key;
@@ -1583,10 +2069,42 @@
}
/**
- * Iterates over `object`'s own and inherited enumerable properties, executing
- * the `callback` for each property. The `callback` is bound to `thisArg` and
- * invoked with three arguments; (value, key, object). Callbacks may exit iteration
- * early by explicitly returning `false`.
+ * This method is like `_.findKey` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to search.
+ * @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 {string|undefined} Returns the key of the found element, else `undefined`.
+ * @example
+ *
+ * _.findLastKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function(num) {
+ * return num % 2 == 1;
+ * });
+ * // => returns `c`, assuming `_.findKey` returns `a`
+ */
+ function findLastKey(object, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forOwnRight(object, function(value, key, object) {
+ if (callback(value, key, object)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over own and inherited enumerable properties of an object,
+ * executing the callback for each property. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, key, object). Callbacks may exit
+ * iteration early by explicitly returning `false`.
*
* @static
* @memberOf _
@@ -1594,7 +2112,7 @@
* @category Objects
* @param {Object} object The object to iterate over.
* @param {Function} [callback=identity] The function called per iteration.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Object} Returns `object`.
* @example
*
@@ -1603,23 +2121,66 @@
* }
*
* Dog.prototype.bark = function() {
- * alert('Woof, woof!');
+ * console.log('Woof, woof!');
* };
*
* _.forIn(new Dog('Dagny'), function(value, key) {
- * alert(key);
+ * console.log(key);
* });
- * // => alerts 'name' and 'bark' (order is not guaranteed)
+ * // => logs 'bark' and 'name' (property order is not guaranteed across environments)
*/
var forIn = createIterator(eachIteratorOptions, forOwnIteratorOptions, {
'useHas': false
});
/**
- * Iterates over an object's own enumerable properties, executing the `callback`
- * for each property. The `callback` is bound to `thisArg` and invoked with three
- * arguments; (value, key, object). Callbacks may exit iteration early by explicitly
- * returning `false`.
+ * This method is like `_.forIn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * function Dog(name) {
+ * this.name = name;
+ * }
+ *
+ * Dog.prototype.bark = function() {
+ * console.log('Woof, woof!');
+ * };
+ *
+ * _.forInRight(new Dog('Dagny'), function(value, key) {
+ * console.log(key);
+ * });
+ * // => logs 'name' and 'bark' assuming `_.forIn ` logs 'bark' and 'name'
+ */
+ function forInRight(object, callback, thisArg) {
+ var pairs = [];
+
+ forIn(object, function(value, key) {
+ pairs.push(key, value);
+ });
+
+ var length = pairs.length;
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(pairs[length--], pairs[length], object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Iterates over own enumerable properties of an object, executing the callback
+ * for each property. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, key, object). Callbacks may exit iteration early by
+ * explicitly returning `false`.
*
* @static
* @memberOf _
@@ -1627,27 +2188,59 @@
* @category Objects
* @param {Object} object The object to iterate over.
* @param {Function} [callback=identity] The function called per iteration.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Object} Returns `object`.
* @example
*
* _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
- * alert(key);
+ * console.log(key);
* });
- * // => alerts '0', '1', and 'length' (order is not guaranteed)
+ * // => logs '0', '1', and 'length' (property order is not guaranteed across environments)
*/
var forOwn = createIterator(eachIteratorOptions, forOwnIteratorOptions);
/**
- * Creates a sorted array of all enumerable properties, own and inherited,
- * of `object` that have function values.
+ * This method is like `_.forOwn` except that it iterates over elements
+ * of a `collection` in the opposite order.
+ *
+ * @static
+ * @memberOf _
+ * @category Objects
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [callback=identity] The function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * _.forOwnRight({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+ * console.log(key);
+ * });
+ * // => logs 'length', '1', and '0' assuming `_.forOwn` logs '0', '1', and 'length'
+ */
+ function forOwnRight(object, callback, thisArg) {
+ var props = keys(object),
+ length = props.length;
+
+ callback = baseCreateCallback(callback, thisArg, 3);
+ while (length--) {
+ var key = props[length];
+ if (callback(object[key], key, object) === false) {
+ break;
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Creates a sorted array of property names of all enumerable properties,
+ * own and inherited, of `object` that have function values.
*
* @static
* @memberOf _
* @alias methods
* @category Objects
* @param {Object} object The object to inspect.
- * @returns {Array} Returns a new array of property names that have function values.
+ * @returns {Array} Returns an array of property names that have function values.
* @example
*
* _.functions(_);
@@ -1671,8 +2264,8 @@
* @memberOf _
* @category Objects
* @param {Object} object The object to check.
- * @param {String} property The property to check for.
- * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
+ * @param {string} property The property to check for.
+ * @returns {boolean} Returns `true` if key is a direct property, else `false`.
* @example
*
* _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
@@ -1683,7 +2276,7 @@
}
/**
- * Creates an object composed of the inverted keys and values of the given `object`.
+ * Creates an object composed of the inverted keys and values of the given object.
*
* @static
* @memberOf _
@@ -1714,8 +2307,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a boolean value, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a boolean value, else `false`.
* @example
*
* _.isBoolean(null);
@@ -1731,8 +2324,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a date, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a date, else `false`.
* @example
*
* _.isDate(new Date);
@@ -1748,8 +2341,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a DOM element, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a DOM element, else `false`.
* @example
*
* _.isElement(document.body);
@@ -1767,8 +2360,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Array|Object|String} value The value to inspect.
- * @returns {Boolean} Returns `true`, if the `value` is empty, else `false`.
+ * @param {Array|Object|string} value The value to inspect.
+ * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
* @example
*
* _.isEmpty([1, 2, 3]);
@@ -1801,21 +2394,19 @@
/**
* Performs a deep comparison between two values to determine if they are
- * equivalent to each other. If `callback` is passed, it will be executed to
- * compare values. If `callback` returns `undefined`, comparisons will be handled
- * by the method instead. The `callback` is bound to `thisArg` and invoked with
- * two arguments; (a, b).
+ * equivalent to each other. If a callback is provided it will be executed
+ * to compare values. If the callback returns `undefined` comparisons will
+ * be handled by the method instead. The callback is bound to `thisArg` and
+ * invoked with two arguments; (a, b).
*
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} a The value to compare.
- * @param {Mixed} b The other value to compare.
+ * @param {*} a The value to compare.
+ * @param {*} b The other value to compare.
* @param {Function} [callback] The function to customize comparing values.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @param- {Array} [stackA=[]] Tracks traversed `a` objects.
- * @param- {Array} [stackB=[]] Tracks traversed `b` objects.
- * @returns {Boolean} Returns `true`, if the values are equivalent, else `false`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* var moe = { 'name': 'moe', 'age': 40 };
@@ -1839,175 +2430,21 @@
* });
* // => true
*/
- function isEqual(a, b, callback, thisArg, stackA, stackB) {
- // used to indicate that when comparing objects, `a` has at least the properties of `b`
- var whereIndicator = callback === indicatorObject;
- if (typeof callback == 'function' && !whereIndicator) {
- callback = lodash.createCallback(callback, thisArg, 2);
- var result = callback(a, b);
- if (typeof result != 'undefined') {
- return !!result;
- }
- }
- // exit early for identical values
- if (a === b) {
- // treat `+0` vs. `-0` as not equal
- return a !== 0 || (1 / a == 1 / b);
- }
- var type = typeof a,
- otherType = typeof b;
-
- // exit early for unlike primitive values
- if (a === a &&
- (!a || (type != 'function' && type != 'object')) &&
- (!b || (otherType != 'function' && otherType != 'object'))) {
- return false;
- }
- // exit early for `null` and `undefined`, avoiding ES3's Function#call behavior
- // http://es5.github.com/#x15.3.4.4
- if (a == null || b == null) {
- return a === b;
- }
- // compare [[Class]] names
- var className = toString.call(a),
- otherClass = toString.call(b);
-
- if (className == argsClass) {
- className = objectClass;
- }
- if (otherClass == argsClass) {
- otherClass = objectClass;
- }
- if (className != otherClass) {
- return false;
- }
- switch (className) {
- case boolClass:
- case dateClass:
- // coerce dates and booleans to numbers, dates to milliseconds and booleans
- // to `1` or `0`, treating invalid dates coerced to `NaN` as not equal
- return +a == +b;
-
- case numberClass:
- // treat `NaN` vs. `NaN` as equal
- return (a != +a)
- ? b != +b
- // but treat `+0` vs. `-0` as not equal
- : (a == 0 ? (1 / a == 1 / b) : a == +b);
-
- case regexpClass:
- case stringClass:
- // coerce regexes to strings (http://es5.github.com/#x15.10.6.4)
- // treat string primitives and their corresponding object instances as equal
- return a == String(b);
- }
- var isArr = className == arrayClass;
- if (!isArr) {
- // unwrap any `lodash` wrapped values
- if (hasOwnProperty.call(a, '__wrapped__ ') || hasOwnProperty.call(b, '__wrapped__')) {
- return isEqual(a.__wrapped__ || a, b.__wrapped__ || b, callback, thisArg, stackA, stackB);
- }
- // exit for functions and DOM nodes
- if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) {
- return false;
- }
- // in older versions of Opera, `arguments` objects have `Array` constructors
- var ctorA = !support.argsObject && isArguments(a) ? Object : a.constructor,
- ctorB = !support.argsObject && isArguments(b) ? Object : b.constructor;
-
- // non `Object` object instances with different constructors are not equal
- if (ctorA != ctorB && !(
- isFunction(ctorA) && ctorA instanceof ctorA &&
- isFunction(ctorB) && ctorB instanceof ctorB
- )) {
- return false;
- }
- }
- // assume cyclic structures are equal
- // the algorithm for detecting cyclic structures is adapted from ES 5.1
- // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3)
- var initedStack = !stackA;
- stackA || (stackA = getArray());
- stackB || (stackB = getArray());
-
- var length = stackA.length;
- while (length--) {
- if (stackA[length] == a) {
- return stackB[length] == b;
- }
- }
- var size = 0;
- result = true;
-
- // add `a` and `b` to the stack of traversed objects
- stackA.push(a);
- stackB.push(b);
-
- // recursively compare objects and arrays (susceptible to call stack limits)
- if (isArr) {
- length = a.length;
- size = b.length;
-
- // compare lengths to determine if a deep comparison is necessary
- result = size == a.length;
- if (!result && !whereIndicator) {
- return result;
- }
- // deep compare the contents, ignoring non-numeric properties
- while (size--) {
- var index = length,
- value = b[size];
-
- if (whereIndicator) {
- while (index--) {
- if ((result = isEqual(a[index], value, callback, thisArg, stackA, stackB))) {
- break;
- }
- }
- } else if (!(result = isEqual(a[size], value, callback, thisArg, stackA, stackB))) {
- break;
- }
- }
- return result;
- }
- // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
- // which, in this case, is more costly
- forIn(b, function(value, key, b) {
- if (hasOwnProperty.call(b, key)) {
- // count the number of properties.
- size++;
- // deep compare each property value.
- return (result = hasOwnProperty.call(a, key) && isEqual(a[key], value, callback, thisArg, stackA, stackB));
- }
- });
-
- if (result && !whereIndicator) {
- // ensure both objects have the same number of properties
- forIn(a, function(value, key, a) {
- if (hasOwnProperty.call(a, key)) {
- // `size` will be `-1` if `a` has more properties than `b`
- return (result = --size > -1);
- }
- });
- }
- if (initedStack) {
- releaseArray(stackA);
- releaseArray(stackB);
- }
- return result;
+ function isEqual(a, b, callback, thisArg) {
+ return baseIsEqual(a, b, typeof callback == 'function' && baseCreateCallback(callback, thisArg, 2));
}
/**
* Checks if `value` is, or can be coerced to, a finite number.
*
- * Note: This is not the same as native `isFinite`, which will return true for
- * booleans and empty strings. See http://es5.github.com/#x15.1.2.5.
+ * Note: This is not the same as native `isFinite` which will return true for
+ * booleans and empty strings. See http://es5.github.io/#x15.1.2.5.
*
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is finite, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is finite, else `false`.
* @example
*
* _.isFinite(-101);
@@ -2035,8 +2472,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a function, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a function, else `false`.
* @example
*
* _.isFunction(_);
@@ -2059,8 +2496,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is an object, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is an object, else `false`.
* @example
*
* _.isObject({});
@@ -2074,7 +2511,7 @@
*/
function isObject(value) {
// check if the value is the ECMAScript language type of Object
- // http://es5.github.com/#x8
+ // http://es5.github.io/#x8
// and avoid a V8 bug
// http://code.google.com/p/v8/issues/detail?id=2291
return !!(value && objectTypes[typeof value]);
@@ -2083,14 +2520,14 @@
/**
* Checks if `value` is `NaN`.
*
- * Note: This is not the same as native `isNaN`, which will return `true` for
- * `undefined` and other values. See http://es5.github.com/#x15.1.2.4.
+ * Note: This is not the same as native `isNaN` which will return `true` for
+ * `undefined` and other non-numeric values. See http://es5.github.io/#x15.1.2.4.
*
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is `NaN`, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `NaN`, else `false`.
* @example
*
* _.isNaN(NaN);
@@ -2108,7 +2545,7 @@
function isNaN(value) {
// `NaN` as a primitive is the only value that is not equal to itself
// (perform the [[Class]] check first to avoid errors with some host objects in IE)
- return isNumber(value) && value != +value
+ return isNumber(value) && value != +value;
}
/**
@@ -2117,8 +2554,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is `null`, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `null`, else `false`.
* @example
*
* _.isNull(null);
@@ -2134,11 +2571,13 @@
/**
* Checks if `value` is a number.
*
+ * Note: `NaN` is considered a number. See http://es5.github.io/#x8.5.
+ *
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a number, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a number, else `false`.
* @example
*
* _.isNumber(8.4 * 5);
@@ -2149,13 +2588,13 @@
}
/**
- * Checks if a given `value` is an object created by the `Object` constructor.
+ * Checks if `value` is an object created by the `Object` constructor.
*
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
* @example
*
* function Stooge(name, age) {
@@ -2190,15 +2629,15 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a regular expression, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a regular expression, else `false`.
* @example
*
* _.isRegExp(/moe/);
* // => true
*/
function isRegExp(value) {
- return !!(value && objectTypes[typeof value]) && toString.call(value) == regexpClass;
+ return (value && objectTypes[typeof value]) ? toString.call(value) == regexpClass : false;
}
/**
@@ -2207,8 +2646,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is a string, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is a string, else `false`.
* @example
*
* _.isString('moe');
@@ -2224,8 +2663,8 @@
* @static
* @memberOf _
* @category Objects
- * @param {Mixed} value The value to check.
- * @returns {Boolean} Returns `true`, if the `value` is `undefined`, else `false`.
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if the `value` is `undefined`, else `false`.
* @example
*
* _.isUndefined(void 0);
@@ -2237,24 +2676,20 @@
/**
* Recursively merges own enumerable properties of the source object(s), that
- * don't resolve to `undefined`, into the destination object. Subsequent sources
- * will overwrite property assignments of previous sources. If a `callback` function
- * is passed, it will be executed to produce the merged values of the destination
- * and source properties. If `callback` returns `undefined`, merging will be
- * handled by the method instead. The `callback` is bound to `thisArg` and
+ * don't resolve to `undefined` into the destination object. Subsequent sources
+ * will overwrite property assignments of previous sources. If a callback is
+ * provided it will be executed to produce the merged values of the destination
+ * and source properties. If the callback returns `undefined` merging will
+ * be handled by the method instead. The callback is bound to `thisArg` and
* invoked with two arguments; (objectValue, sourceValue).
*
* @static
* @memberOf _
* @category Objects
* @param {Object} object The destination object.
- * @param {Object} [source1, source2, ...] The source objects.
+ * @param {...Object} [source] The source objects.
* @param {Function} [callback] The function to customize merging properties.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @param- {Object} [deepIndicator] Indicates that `stackA` and `stackB` are
- * arrays of traversed objects, instead of source objects.
- * @param- {Array} [stackA=[]] Tracks traversed source objects.
- * @param- {Array} [stackB=[]] Associates values with source counterparts.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Object} Returns the destination object.
* @example
*
@@ -2284,116 +2719,57 @@
* 'fruits': ['banana'],
* 'vegetables': ['carrot']
* };
- *
- * _.merge(food, otherFood, function(a, b) {
- * return _.isArray(a) ? a.concat(b) : undefined;
- * });
- * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
- */
- function merge(object, source, deepIndicator) {
- var args = arguments,
- index = 0,
- length = 2;
-
- if (!isObject(object)) {
- return object;
- }
- if (deepIndicator === indicatorObject) {
- var callback = args[3],
- stackA = args[4],
- stackB = args[5];
- } else {
- var initedStack = true;
- stackA = getArray();
- stackB = getArray();
-
- // allows working with `_.reduce` and `_.reduceRight` without
- // using their `callback` arguments, `index|key` and `collection`
- if (typeof deepIndicator != 'number') {
- length = args.length;
- }
- if (length > 3 && typeof args[length - 2] == 'function') {
- callback = lodash.createCallback(args[--length - 1], args[length--], 2);
- } else if (length > 2 && typeof args[length - 1] == 'function') {
- callback = args[--length];
- }
- }
- while (++index < length) {
- (isArray(args[index]) ? forEach : forOwn)(args[index], function(source, key) {
- var found,
- isArr,
- result = source,
- value = object[key];
-
- if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
- // avoid merging previously merged cyclic sources
- var stackLength = stackA.length;
- while (stackLength--) {
- if ((found = stackA[stackLength] == source)) {
- value = stackB[stackLength];
- break;
- }
- }
- if (!found) {
- var isShallow;
- if (callback) {
- result = callback(value, source);
- if ((isShallow = typeof result != 'undefined')) {
- value = result;
- }
- }
- if (!isShallow) {
- value = isArr
- ? (isArray(value) ? value : [])
- : (isPlainObject(value) ? value : {});
- }
- // add `source` and associated `value` to the stack of traversed objects
- stackA.push(source);
- stackB.push(value);
-
- // recursively merge objects and arrays (susceptible to call stack limits)
- if (!isShallow) {
- value = merge(value, source, indicatorObject, callback, stackA, stackB);
- }
- }
- }
- else {
- if (callback) {
- result = callback(value, source);
- if (typeof result == 'undefined') {
- result = source;
- }
- }
- if (typeof result != 'undefined') {
- value = result;
- }
- }
- object[key] = value;
- });
+ *
+ * _.merge(food, otherFood, function(a, b) {
+ * return _.isArray(a) ? a.concat(b) : undefined;
+ * });
+ * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
+ */
+ function merge(object) {
+ var args = arguments,
+ length = 2;
+
+ if (!isObject(object)) {
+ return object;
+ }
+ // allows working with `_.reduce` and `_.reduceRight` without using
+ // their `index` and `collection` arguments
+ if (typeof args[2] != 'number') {
+ length = args.length;
}
+ if (length > 3 && typeof args[length - 2] == 'function') {
+ var callback = baseCreateCallback(args[--length - 1], args[length--], 2);
+ } else if (length > 2 && typeof args[length - 1] == 'function') {
+ callback = args[--length];
+ }
+ var sources = nativeSlice.call(arguments, 1, length),
+ index = -1,
+ stackA = getArray(),
+ stackB = getArray();
- if (initedStack) {
- releaseArray(stackA);
- releaseArray(stackB);
+ while (++index < length) {
+ baseMerge(object, sources[index], callback, stackA, stackB);
}
+ releaseArray(stackA);
+ releaseArray(stackB);
return object;
}
/**
* Creates a shallow clone of `object` excluding the specified properties.
* Property names may be specified as individual arguments or as arrays of
- * property names. If a `callback` function is passed, it will be executed
- * for each property in the `object`, omitting the properties `callback`
- * returns truthy for. The `callback` is bound to `thisArg` and invoked
- * with three arguments; (value, key, object).
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` omitting the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
*
* @static
* @memberOf _
* @category Objects
* @param {Object} object The source object.
- * @param {Function|String} callback|[prop1, prop2, ...] The properties to omit
- * or the function called per iteration.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {Function|...string|string[]} [callback] The properties to omit or the
+ * function called per iteration.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Object} Returns an object without the omitted properties.
* @example
*
@@ -2411,9 +2787,9 @@
result = {};
if (isFunc) {
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
} else {
- var props = concat.apply(arrayRef, nativeSlice.call(arguments, 1));
+ var props = baseFlatten(arguments, true, false, 1);
}
forIn(object, function(value, key, object) {
if (isFunc
@@ -2427,7 +2803,7 @@
}
/**
- * Creates a two dimensional array of the given object's key-value pairs,
+ * Creates a two dimensional array of an object's key-value pairs,
* i.e. `[[key1, value1], [key2, value2]]`.
*
* @static
@@ -2438,7 +2814,7 @@
* @example
*
* _.pairs({ 'moe': 30, 'larry': 40 });
- * // => [['moe', 30], ['larry', 40]] (order is not guaranteed)
+ * // => [['moe', 30], ['larry', 40]] (property order is not guaranteed across environments)
*/
function pairs(object) {
var index = -1,
@@ -2455,18 +2831,20 @@
/**
* Creates a shallow clone of `object` composed of the specified properties.
- * Property names may be specified as individual arguments or as arrays of property
- * names. If `callback` is passed, it will be executed for each property in the
- * `object`, picking the properties `callback` returns truthy for. The `callback`
- * is bound to `thisArg` and invoked with three arguments; (value, key, object).
+ * Property names may be specified as individual arguments or as arrays of
+ * property names. If a callback is provided it will be executed for each
+ * property of `object` picking the properties the callback returns truey
+ * for. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, key, object).
*
* @static
* @memberOf _
* @category Objects
* @param {Object} object The source object.
- * @param {Array|Function|String} callback|[prop1, prop2, ...] The function called
- * per iteration or properties to pick, either as individual arguments or arrays.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {Function|...string|string[]} [callback] The function called per
+ * iteration or property names to pick, specified as individual property
+ * names or arrays of property names.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Object} Returns an object composed of the picked properties.
* @example
*
@@ -2482,7 +2860,7 @@
var result = {};
if (typeof callback != 'function') {
var index = -1,
- props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
+ props = baseFlatten(arguments, true, false, 1),
length = isObject(object) ? props.length : 0;
while (++index < length) {
@@ -2492,7 +2870,7 @@
}
}
} else {
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
forIn(object, function(value, key, object) {
if (callback(value, key, object)) {
result[key] = value;
@@ -2503,10 +2881,10 @@
}
/**
- * An alternative to `_.reduce`, this method transforms an `object` to a new
+ * An alternative to `_.reduce` this method transforms `object` to a new
* `accumulator` object which is the result of running each of its elements
- * through the `callback`, with each `callback` execution potentially mutating
- * the `accumulator` object. The `callback` is bound to `thisArg` and invoked
+ * through a callback, with each callback execution potentially mutating
+ * the `accumulator` object. The callback is bound to `thisArg` and invoked
* with four arguments; (accumulator, value, key, object). Callbacks may exit
* iteration early by explicitly returning `false`.
*
@@ -2515,9 +2893,9 @@
* @category Objects
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [callback=identity] The function called per iteration.
- * @param {Mixed} [accumulator] The custom accumulator value.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the accumulated value.
+ * @param {*} [accumulator] The custom accumulator value.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
* @example
*
* var squares = _.transform([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(result, num) {
@@ -2535,7 +2913,7 @@
*/
function transform(object, callback, accumulator, thisArg) {
var isArr = isArray(object);
- callback = lodash.createCallback(callback, thisArg, 4);
+ callback = baseCreateCallback(callback, thisArg, 4);
if (accumulator == null) {
if (isArr) {
@@ -2547,7 +2925,7 @@
accumulator = createObject(proto);
}
}
- (isArr ? basicEach : forOwn)(object, function(value, index, object) {
+ (isArr ? baseEach : forOwn)(object, function(value, index, object) {
return callback(accumulator, value, index, object);
});
return accumulator;
@@ -2560,11 +2938,11 @@
* @memberOf _
* @category Objects
* @param {Object} object The object to inspect.
- * @returns {Array} Returns a new array of property values.
+ * @returns {Array} Returns an array of property values.
* @example
*
* _.values({ 'one': 1, 'two': 2, 'three': 3 });
- * // => [1, 2, 3] (order is not guaranteed)
+ * // => [1, 2, 3] (property order is not guaranteed across environments)
*/
function values(object) {
var index = -1,
@@ -2588,9 +2966,9 @@
* @static
* @memberOf _
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
- * @param {Array|Number|String} [index1, index2, ...] The indexes of
- * `collection` to retrieve, either as individual arguments or arrays.
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {...(number|number[]|string|string[])} [index] The indexes of `collection`
+ * to retrieve, specified as individual indexes or arrays of indexes.
* @returns {Array} Returns a new array of elements corresponding to the
* provided indexes.
* @example
@@ -2602,9 +2980,10 @@
* // => ['moe', 'curly']
*/
function at(collection) {
- var index = -1,
- props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
- length = props.length,
+ var args = arguments,
+ index = -1,
+ props = baseFlatten(args, true, false, 1),
+ length = (args[2] && args[2][args[1]] === collection) ? 1 : props.length,
result = Array(length);
if (support.unindexedChars && isString(collection)) {
@@ -2617,18 +2996,18 @@
}
/**
- * Checks if a given `target` element is present in a `collection` using strict
- * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
- * as the offset from the end of the collection.
+ * Checks if a given value is present in a collection using strict equality
+ * for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the
+ * offset from the end of the collection.
*
* @static
* @memberOf _
* @alias include
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
- * @param {Mixed} target The value to check for.
- * @param {Number} [fromIndex=0] The index to search from.
- * @returns {Boolean} Returns `true` if the `target` element is found, else `false`.
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {*} target The value to check for.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {boolean} Returns `true` if the `target` element is found, else `false`.
* @example
*
* _.contains([1, 2, 3], 1);
@@ -2650,13 +3029,12 @@
result = false;
fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
- if (length && typeof length == 'number') {
- result = (isString(collection)
- ? collection.indexOf(target, fromIndex)
- : indexOf(collection, target, fromIndex)
- ) > -1;
+ if (isArray(collection)) {
+ result = indexOf(collection, target, fromIndex) > -1;
+ } else if (typeof length == 'number') {
+ result = (isString(collection) ? collection.indexOf(target, fromIndex) : indexOf(collection, target, fromIndex)) > -1;
} else {
- basicEach(collection, function(value) {
+ baseEach(collection, function(value) {
if (++index >= fromIndex) {
return !(result = value === target);
}
@@ -2666,26 +3044,27 @@
}
/**
- * Creates an object composed of keys returned from running each element of the
- * `collection` through the given `callback`. The corresponding value of each key
- * is the number of times the key was returned by the `callback`. The `callback`
- * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` through the callback. The corresponding value
+ * of each key is the number of times the key was returned by the callback.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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 {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @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 {Object} Returns the composed aggregate object.
* @example
*
@@ -2698,26 +3077,19 @@
* _.countBy(['one', 'two', 'three'], 'length');
* // => { '3': 2, '5': 1 }
*/
- function countBy(collection, callback, thisArg) {
- var result = {};
- callback = lodash.createCallback(callback, thisArg);
-
- forEach(collection, function(value, key, collection) {
- key = String(callback(value, key, collection));
- (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
- });
- return result;
- }
+ var countBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+ });
/**
- * Checks if the `callback` returns a truthy value for **all** elements of a
- * `collection`. The `callback` is bound to `thisArg` and invoked with three
+ * Checks if the given callback returns truey value for **all** elements of
+ * a collection. The callback is bound to `thisArg` and invoked with three
* arguments; (value, index|key, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -2725,12 +3097,12 @@
* @memberOf _
* @alias all
* @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 passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Boolean} Returns `true` if all elements pass the callback check,
+ * @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 all elements passed the callback check,
* else `false`.
* @example
*
@@ -2752,7 +3124,7 @@
*/
function every(collection, callback, thisArg) {
var result = true;
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
if (isArray(collection)) {
var index = -1,
@@ -2764,7 +3136,7 @@
}
}
} else {
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
return (result = !!callback(value, index, collection));
});
}
@@ -2772,14 +3144,14 @@
}
/**
- * Examines each element in a `collection`, returning an array of all elements
- * the `callback` returns truthy for. The `callback` is bound to `thisArg` and
+ * Iterates over elements of a collection, returning an array of all elements
+ * the callback returns truey for. The callback is bound to `thisArg` and
* invoked with three arguments; (value, index|key, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -2787,11 +3159,11 @@
* @memberOf _
* @alias select
* @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 passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @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 {Array} Returns a new array of elements that passed the callback check.
* @example
*
@@ -2813,7 +3185,7 @@
*/
function filter(collection, callback, thisArg) {
var result = [];
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
if (isArray(collection)) {
var index = -1,
@@ -2826,7 +3198,7 @@
}
}
} else {
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
if (callback(value, index, collection)) {
result.push(value);
}
@@ -2836,14 +3208,14 @@
}
/**
- * Examines each element in a `collection`, returning the first that the `callback`
- * returns truthy for. The `callback` is bound to `thisArg` and invoked with three
- * arguments; (value, index|key, collection).
+ * Iterates over elements of a collection, returning the first element that
+ * the callback returns truey for. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index|key, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -2851,12 +3223,12 @@
* @memberOf _
* @alias detect, findWhere
* @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 passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the found element, else `undefined`.
+ * @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 {*} Returns the found element, else `undefined`.
* @example
*
* _.find([1, 2, 3, 4], function(num) {
@@ -2879,7 +3251,7 @@
* // => { 'name': 'banana', 'organic': true, 'type': 'fruit' }
*/
function find(collection, callback, thisArg) {
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
if (isArray(collection)) {
var index = -1,
@@ -2893,7 +3265,7 @@
}
} else {
var result;
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
if (callback(value, index, collection)) {
result = value;
return false;
@@ -2904,26 +3276,58 @@
}
/**
- * Iterates over a `collection`, 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`.
+ * This method is like `_.find` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @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 {*} Returns the found element, else `undefined`.
+ * @example
+ *
+ * _.findLast([1, 2, 3, 4], function(num) {
+ * return num % 2 == 1;
+ * });
+ * // => 3
+ */
+ function findLast(collection, callback, thisArg) {
+ var result;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ forEachRight(collection, function(value, index, collection) {
+ if (callback(value, index, collection)) {
+ result = value;
+ return false;
+ }
+ });
+ return result;
+ }
+
+ /**
+ * Iterates over elements of a collection, executing the callback for each
+ * element. The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection). Callbacks may exit iteration early by
+ * explicitly returning `false`.
*
* @static
* @memberOf _
* @alias each
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Array|Object|string} collection The collection to iterate over.
* @param {Function} [callback=identity] The function called per iteration.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Array|Object|String} Returns `collection`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {Array|Object|string} Returns `collection`.
* @example
*
- * _([1, 2, 3]).forEach(alert).join(',');
- * // => alerts each number and returns '1,2,3'
+ * _([1, 2, 3]).forEach(function(num) { console.log(num); }).join(',');
+ * // => logs each number and returns '1,2,3'
*
- * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert);
- * // => alerts each number value (order is not guaranteed)
+ * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { console.log(num); });
+ * // => logs each number and returns the object (property order is not guaranteed across environments)
*/
function forEach(collection, callback, thisArg) {
if (callback && typeof thisArg == 'undefined' && isArray(collection)) {
@@ -2936,32 +3340,76 @@
}
}
} else {
- basicEach(collection, callback, thisArg);
+ baseEach(collection, callback, thisArg);
+ }
+ return collection;
+ }
+
+ /**
+ * This method is like `_.forEach` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @alias eachRight
+ * @category Collections
+ * @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`.
+ * @example
+ *
+ * _([1, 2, 3]).forEachRight(function(num) { console.log(num); }).join(',');
+ * // => logs each number from right to left and returns '3,2,1'
+ */
+ function forEachRight(collection, callback, thisArg) {
+ var iterable = collection,
+ length = collection ? collection.length : 0;
+
+ callback = callback && typeof thisArg == 'undefined' ? callback : baseCreateCallback(callback, thisArg, 3);
+ if (isArray(collection)) {
+ while (length--) {
+ if (callback(collection[length], length, collection) === false) {
+ break;
+ }
+ }
+ } else {
+ if (typeof length != 'number') {
+ var props = keys(collection);
+ length = props.length;
+ } else if (support.unindexedChars && isString(collection)) {
+ iterable = collection.split('');
+ }
+ baseEach(collection, function(value, key, collection) {
+ key = props ? props[--length] : --length;
+ return callback(iterable[key], key, collection);
+ });
}
return collection;
}
/**
- * Creates an object composed of keys returned from running each element of the
- * `collection` through the `callback`. The corresponding value of each key is
- * an array of elements passed to `callback` that returned the key. The `callback`
- * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+ * Creates an object composed of keys generated from the results of running
+ * each element of a collection through the callback. The corresponding value
+ * of each key is an array of the elements responsible for generating the key.
+ * The callback is bound to `thisArg` and invoked with three arguments;
+ * (value, index|key, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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 {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @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 {Object} Returns the composed aggregate object.
* @example
*
@@ -2975,30 +3423,66 @@
* _.groupBy(['one', 'two', 'three'], 'length');
* // => { '3': ['one', 'two'], '5': ['three'] }
*/
- function groupBy(collection, callback, thisArg) {
- var result = {};
- callback = lodash.createCallback(callback, thisArg);
+ var groupBy = createAggregator(function(result, value, key) {
+ (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+ });
- forEach(collection, function(value, key, collection) {
- key = String(callback(value, key, collection));
- (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
- });
- return result;
- }
+ /**
+ * Creates an object composed of keys generated from the results of running
+ * each element of the collection through the given callback. The corresponding
+ * value of each key is the last element responsible for generating the key.
+ * 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 _
+ * @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 {Object} Returns the composed aggregate object.
+ * @example
+ *
+ * var keys = [
+ * { 'dir': 'left', 'code': 97 },
+ * { 'dir': 'right', 'code': 100 }
+ * ];
+ *
+ * _.indexBy(keys, 'dir');
+ * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(keys, function(key) { return String.fromCharCode(key.code); });
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ *
+ * _.indexBy(stooges, function(key) { this.fromCharCode(key.code); }, String);
+ * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
+ */
+ var indexBy = createAggregator(function(result, value, key) {
+ result[key] = value;
+ });
/**
- * Invokes the method named by `methodName` on each element in the `collection`,
+ * Invokes the method named by `methodName` on each element in the `collection`
* returning an array of the results of each invoked method. Additional arguments
- * will be passed to each invoked method. If `methodName` is a function, it will
- * be invoked for, and `this` bound to, each element in the `collection`.
+ * will be provided to each invoked method. If `methodName` is a function it
+ * will be invoked for, and `this` bound to, each element in the `collection`.
*
* @static
* @memberOf _
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
- * @param {Function|String} methodName The name of the method to invoke or
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {Function|string} methodName The name of the method to invoke or
* the function invoked per iteration.
- * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
+ * @param {...*} [arg] Arguments to invoke the method with.
* @returns {Array} Returns a new array of the results of each invoked method.
* @example
*
@@ -3022,14 +3506,14 @@
}
/**
- * Creates an array of values by running each element in the `collection`
- * through the `callback`. The `callback` is bound to `thisArg` and invoked with
+ * Creates an array of values by running each element in the collection
+ * through the callback. The callback is bound to `thisArg` and invoked with
* three arguments; (value, index|key, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -3037,11 +3521,11 @@
* @memberOf _
* @alias collect
* @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 passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @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 {Array} Returns a new array of the results of each `callback` execution.
* @example
*
@@ -3049,7 +3533,7 @@
* // => [3, 6, 9]
*
* _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
- * // => [3, 6, 9] (order is not guaranteed)
+ * // => [3, 6, 9] (property order is not guaranteed across environments)
*
* var stooges = [
* { 'name': 'moe', 'age': 40 },
@@ -3065,13 +3549,13 @@
length = collection ? collection.length : 0,
result = Array(typeof length == 'number' ? length : 0);
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
if (isArray(collection)) {
while (++index < length) {
result[index] = callback(collection[index], index, collection);
}
} else {
- basicEach(collection, function(value, key, collection) {
+ baseEach(collection, function(value, key, collection) {
result[++index] = callback(value, key, collection);
});
}
@@ -3079,27 +3563,27 @@
}
/**
- * Retrieves the maximum value of an `array`. If `callback` is passed,
- * it will be executed for each value in the `array` to generate the
- * criterion by which the value is ranked. The `callback` is bound to
- * `thisArg` and invoked with three arguments; (value, index, collection).
+ * Retrieves the maximum value of an array. If a callback is provided it
+ * will be executed for each value in the array to generate the criterion by
+ * which the value is ranked. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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 {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the maximum value.
+ * @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 {*} Returns the maximum value.
* @example
*
* _.max([4, 2, 8, 6]);
@@ -3134,9 +3618,9 @@
} else {
callback = (!callback && isString(collection))
? charAtCallback
- : lodash.createCallback(callback, thisArg);
+ : lodash.createCallback(callback, thisArg, 3);
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
var current = callback(value, index, collection);
if (current > computed) {
computed = current;
@@ -3148,27 +3632,27 @@
}
/**
- * Retrieves the minimum value of an `array`. If `callback` is passed,
- * it will be executed for each value in the `array` to generate the
- * criterion by which the value is ranked. The `callback` is bound to `thisArg`
- * and invoked with three arguments; (value, index, collection).
+ * Retrieves the minimum value of an array. If a callback is provided it
+ * will be executed for each value in the array to generate the criterion by
+ * which the value is ranked. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, collection).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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 {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the minimum value.
+ * @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 {*} Returns the minimum value.
* @example
*
* _.min([4, 2, 8, 6]);
@@ -3203,9 +3687,9 @@
} else {
callback = (!callback && isString(collection))
? charAtCallback
- : lodash.createCallback(callback, thisArg);
+ : lodash.createCallback(callback, thisArg, 3);
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
var current = callback(value, index, collection);
if (current < computed) {
computed = current;
@@ -3223,8 +3707,8 @@
* @memberOf _
* @type Function
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
- * @param {String} property The property to pluck.
+ * @param {Array|Object|string} collection The collection to iterate over.
+ * @param {string} property The property to pluck.
* @returns {Array} Returns a new array of property values.
* @example
*
@@ -3239,22 +3723,22 @@
var pluck = map;
/**
- * Reduces a `collection` to a value which is the accumulated result of running
- * each element in the `collection` through the `callback`, where each successive
- * `callback` execution consumes the return value of the previous execution.
- * If `accumulator` is not passed, the first element of the `collection` will be
- * used as the initial `accumulator` value. The `callback` is bound to `thisArg`
+ * Reduces a collection to a value which is the accumulated result of running
+ * each element in the collection through the callback, where each successive
+ * callback execution consumes the return value of the previous execution. If
+ * `accumulator` is not provided the first element of the collection will be
+ * used as the initial `accumulator` value. The callback is bound to `thisArg`
* and invoked with four arguments; (accumulator, value, index|key, collection).
*
* @static
* @memberOf _
* @alias foldl, inject
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Array|Object|string} collection The collection to iterate over.
* @param {Function} [callback=identity] The function called per iteration.
- * @param {Mixed} [accumulator] Initial value of the accumulator.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the accumulated value.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
* @example
*
* var sum = _.reduce([1, 2, 3], function(sum, num) {
@@ -3270,7 +3754,7 @@
*/
function reduce(collection, callback, accumulator, thisArg) {
var noaccum = arguments.length < 3;
- callback = lodash.createCallback(callback, thisArg, 4);
+ callback = baseCreateCallback(callback, thisArg, 4);
if (isArray(collection)) {
var index = -1,
@@ -3283,7 +3767,7 @@
accumulator = callback(accumulator, collection[index], index, collection);
}
} else {
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
accumulator = noaccum
? (noaccum = false, value)
: callback(accumulator, value, index, collection)
@@ -3293,18 +3777,18 @@
}
/**
- * This method is similar to `_.reduce`, except that it iterates over a
- * `collection` from right to left.
+ * This method is like `_.reduce` except that it iterates over elements
+ * of a `collection` from right to left.
*
* @static
* @memberOf _
* @alias foldr
* @category Collections
- * @param {Array|Object|String} collection The collection to iterate over.
+ * @param {Array|Object|string} collection The collection to iterate over.
* @param {Function} [callback=identity] The function called per iteration.
- * @param {Mixed} [accumulator] Initial value of the accumulator.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the accumulated value.
+ * @param {*} [accumulator] Initial value of the accumulator.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the accumulated value.
* @example
*
* var list = [[0, 1], [2, 3], [4, 5]];
@@ -3312,47 +3796,36 @@
* // => [4, 5, 2, 3, 0, 1]
*/
function reduceRight(collection, callback, accumulator, thisArg) {
- var iterable = collection,
- length = collection ? collection.length : 0,
- noaccum = arguments.length < 3;
-
- if (typeof length != 'number') {
- var props = keys(collection);
- length = props.length;
- } else if (support.unindexedChars && isString(collection)) {
- iterable = collection.split('');
- }
- callback = lodash.createCallback(callback, thisArg, 4);
- forEach(collection, function(value, index, collection) {
- index = props ? props[--length] : --length;
+ var noaccum = arguments.length < 3;
+ callback = baseCreateCallback(callback, thisArg, 4);
+ forEachRight(collection, function(value, index, collection) {
accumulator = noaccum
- ? (noaccum = false, iterable[index])
- : callback(accumulator, iterable[index], index, collection);
+ ? (noaccum = false, value)
+ : callback(accumulator, value, index, collection);
});
return accumulator;
}
/**
- * The opposite of `_.filter`, this method returns the elements of a
- * `collection` that `callback` does **not** return truthy for.
+ * The opposite of `_.filter` this method returns the elements of a
+ * collection that the callback does **not** return truey for.
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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 {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Array} Returns a new array of elements that did **not** pass the
- * callback check.
+ * @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 {Array} Returns a new array of elements that failed the callback check.
* @example
*
* var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
@@ -3372,20 +3845,54 @@
* // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]
*/
function reject(collection, callback, thisArg) {
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
return filter(collection, function(value, index, collection) {
return !callback(value, index, collection);
});
}
/**
- * Creates an array of shuffled `array` values, using a version of the
- * Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+ * Retrieves a random element or `n` random elements from a collection.
+ *
+ * @static
+ * @memberOf _
+ * @category Collections
+ * @param {Array|Object|string} collection The collection to sample.
+ * @param {number} [n] The number of elements to sample.
+ * @param- {Object} [guard] Allows working with functions, like `_.map`,
+ * without using their `key` and `object` arguments as sources.
+ * @returns {Array} Returns the random sample(s) of `collection`.
+ * @example
+ *
+ * _.sample([1, 2, 3, 4]);
+ * // => 2
+ *
+ * _.sample([1, 2, 3, 4], 2);
+ * // => [3, 1]
+ */
+ function sample(collection, n, guard) {
+ var length = collection ? collection.length : 0;
+ if (typeof length != 'number') {
+ collection = values(collection);
+ } else if (support.unindexedChars && isString(collection)) {
+ collection = collection.split('');
+ }
+ if (n == null || guard) {
+ return collection ? collection[random(length - 1)] : undefined;
+ }
+ var result = shuffle(collection);
+ result.length = nativeMin(nativeMax(0, n), result.length);
+ return result;
+ }
+
+ /**
+ * 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.
+ * @param {Array|Object|string} collection The collection to shuffle.
* @returns {Array} Returns a new shuffled collection.
* @example
*
@@ -3398,7 +3905,7 @@
result = Array(typeof length == 'number' ? length : 0);
forEach(collection, function(value) {
- var rand = floor(nativeRandom() * (++index + 1));
+ var rand = random(++index);
result[index] = result[rand];
result[rand] = value;
});
@@ -3412,8 +3919,8 @@
* @static
* @memberOf _
* @category Collections
- * @param {Array|Object|String} collection The collection to inspect.
- * @returns {Number} Returns `collection.length` or number of own enumerable properties.
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns `collection.length` or number of own enumerable properties.
* @example
*
* _.size([1, 2]);
@@ -3431,15 +3938,15 @@
}
/**
- * Checks if the `callback` returns a truthy value for **any** element of a
- * `collection`. The function returns as soon as it finds passing value, and
- * does not iterate over the entire `collection`. The `callback` is bound to
+ * 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 passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -3447,12 +3954,12 @@
* @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 passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Boolean} Returns `true` if any element passes the callback check,
+ * @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
*
@@ -3474,7 +3981,7 @@
*/
function some(collection, callback, thisArg) {
var result;
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
if (isArray(collection)) {
var index = -1,
@@ -3486,7 +3993,7 @@
}
}
} else {
- basicEach(collection, function(value, index, collection) {
+ baseEach(collection, function(value, index, collection) {
return !(result = callback(value, index, collection));
});
}
@@ -3495,26 +4002,26 @@
/**
* Creates an array of elements, sorted in ascending order by the results of
- * running each element in the `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).
+ * 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 passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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 {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @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 {Array} Returns a new array of sorted elements.
* @example
*
@@ -3533,7 +4040,7 @@
length = collection ? collection.length : 0,
result = Array(typeof length == 'number' ? length : 0);
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
forEach(collection, function(value, key, collection) {
var object = result[++index] = getObject();
object.criteria = callback(value, key, collection);
@@ -3557,7 +4064,7 @@
* @static
* @memberOf _
* @category Collections
- * @param {Array|Object|String} collection The collection to convert.
+ * @param {Array|Object|string} collection The collection to convert.
* @returns {Array} Returns the new converted array.
* @example
*
@@ -3574,41 +4081,43 @@
}
/**
- * Examines each element in a `collection`, returning an array of all elements
- * that have the given `properties`. When checking `properties`, this method
- * performs a deep comparison between values to determine if they are equivalent
- * to each other.
+ * 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 {Array|Object|string} collection The collection to iterate over.
* @param {Object} properties The object of property values to filter by.
* @returns {Array} Returns a new array of elements that have the given `properties`.
* @example
*
* var stooges = [
- * { 'name': 'moe', 'age': 40 },
- * { 'name': 'larry', 'age': 50 }
+ * { 'name': 'curly', 'age': 30, 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
+ * { 'name': 'moe', 'age': '40', 'quotes': ['Spread out!', 'You knucklehead!'] }
* ];
*
* _.where(stooges, { 'age': 40 });
- * // => [{ 'name': 'moe', 'age': 40 }]
+ * // => [{ 'name': 'moe', 'age': '40', 'quotes': ['Spread out!', 'You knucklehead!'] }]
+ *
+ * _.where(stooges, { 'quotes': ['Poifect!'] });
+ * // => [{ 'name': 'curly', 'age': 30, 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] }]
*/
var where = filter;
/*--------------------------------------------------------------------------*/
/**
- * Creates an array with all falsey values of `array` removed. The values
- * `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey.
+ * Creates an array with all falsey values removed. The values `false`, `null`,
+ * `0`, `""`, `undefined`, and `NaN` are all falsey.
*
* @static
* @memberOf _
* @category Arrays
* @param {Array} array The array to compact.
- * @returns {Array} Returns a new filtered array.
+ * @returns {Array} Returns a new array of filtered values.
* @example
*
* _.compact([0, 1, false, 2, '', 3]);
@@ -3629,16 +4138,15 @@
}
/**
- * Creates an array of `array` elements not present in the other arrays
- * using strict equality for comparisons, i.e. `===`.
+ * Creates an array excluding all values of the provided arrays using strict
+ * equality for comparisons, i.e. `===`.
*
* @static
* @memberOf _
* @category Arrays
* @param {Array} array The array to process.
- * @param {Array} [array1, array2, ...] Arrays to check.
- * @returns {Array} Returns a new array of `array` elements not present in the
- * other arrays.
+ * @param {...Array} [array] The arrays of values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
* @example
*
* _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
@@ -3648,10 +4156,10 @@
var index = -1,
indexOf = getIndexOf(),
length = array ? array.length : 0,
- seen = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
+ seen = baseFlatten(arguments, true, true, 1),
result = [];
- var isLarge = length >= largeArraySize && indexOf === basicIndexOf;
+ var isLarge = length >= largeArraySize && indexOf === baseIndexOf;
if (isLarge) {
var cache = createCache(seen);
@@ -3675,18 +4183,18 @@
}
/**
- * This method is similar to `_.find`, except that it returns the index of
- * the element that passes the callback check, instead of the element itself.
+ * This method is like `_.find` except that it returns the index of the first
+ * element that passes the callback check, instead of the element itself.
*
* @static
* @memberOf _
* @category Arrays
* @param {Array} array The array to search.
- * @param {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the index of the found element, else `-1`.
+ * @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 {number} Returns the index of the found element, else `-1`.
* @example
*
* _.findIndex(['apple', 'banana', 'beet'], function(food) {
@@ -3698,7 +4206,7 @@
var index = -1,
length = array ? array.length : 0;
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
while (++index < length) {
if (callback(array[index], index, array)) {
return index;
@@ -3708,16 +4216,46 @@
}
/**
- * Gets the first element of the `array`. If a number `n` is passed, the first
- * `n` elements of the `array` are returned. If a `callback` function is passed,
- * elements at the beginning of the array are returned as long as the `callback`
- * returns truthy. The `callback` is bound to `thisArg` and invoked with three
- * arguments; (value, index, array).
+ * This method is like `_.findIndex` except that it iterates over elements
+ * of a `collection` from right to left.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to search.
+ * @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 {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * _.findLastIndex(['apple', 'banana', 'beet'], function(food) {
+ * return /^b/.test(food);
+ * });
+ * // => 2
+ */
+ function findLastIndex(array, callback, thisArg) {
+ var length = array ? array.length : 0;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (length--) {
+ if (callback(array[length], length, array)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Gets the first element or first `n` elements of an array. If a callback
+ * is provided elements at the beginning of the array are returned as long
+ * as the callback returns truey. The callback is bound to `thisArg` and
+ * invoked with three arguments; (value, index, array).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -3726,12 +4264,12 @@
* @alias head, take
* @category Arrays
* @param {Array} array The array to query.
- * @param {Function|Object|Number|String} [callback|n] The function called
+ * @param {Function|Object|number|string} [callback] The function called
* per element or the number of elements to return. If a property name or
- * object is passed, it will be used to create a "_.pluck" or "_.where"
+ * object is provided it will be used to create a "_.pluck" or "_.where"
* style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the first element(s) of `array`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the first element(s) of `array`.
* @example
*
* _.first([1, 2, 3]);
@@ -3765,37 +4303,35 @@
* // => [{ 'name': 'apple', 'type': 'fruit' }, { 'name': 'banana', 'type': 'fruit' }]
*/
function first(array, callback, thisArg) {
- if (array) {
- var n = 0,
- length = array.length;
+ var n = 0,
+ length = array ? array.length : 0;
- if (typeof callback != 'number' && callback != null) {
- var index = -1;
- callback = lodash.createCallback(callback, thisArg);
- while (++index < length && callback(array[index], index, array)) {
- n++;
- }
- } else {
- n = callback;
- if (n == null || thisArg) {
- return array[0];
- }
+ if (typeof callback != 'number' && callback != null) {
+ var index = -1;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (++index < length && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[0] : undefined;
}
- return slice(array, 0, nativeMin(nativeMax(0, n), length));
}
+ return slice(array, 0, nativeMin(nativeMax(0, n), length));
}
/**
* Flattens a nested array (the nesting can be to any depth). If `isShallow`
- * is truthy, `array` will only be flattened a single level. If `callback`
- * is passed, each element of `array` is passed through a `callback` before
- * flattening. The `callback` is bound to `thisArg` and invoked with three
+ * is truey, the array will only be flattened a single level. If a callback
+ * is provided each element of the array is passed through the callback before
+ * flattening. The callback is bound to `thisArg` and invoked with three
* arguments; (value, index, array).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -3803,11 +4339,11 @@
* @memberOf _
* @category Arrays
* @param {Array} array The array to flatten.
- * @param {Boolean} [isShallow=false] A flag to indicate only flattening a single level.
- * @param {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {boolean} [isShallow=false] A flag to restrict flattening to a single level.
+ * @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 {Array} Returns a new flattened array.
* @example
*
@@ -3826,39 +4362,32 @@
* _.flatten(stooges, 'quotes');
* // => ['Oh, a wise guy, eh?', 'Poifect!', 'Spread out!', 'You knucklehead!']
*/
- var flatten = overloadWrapper(function flatten(array, isShallow, callback) {
- var index = -1,
- length = array ? array.length : 0,
- result = [];
-
- while (++index < length) {
- var value = array[index];
- if (callback) {
- value = callback(value, index, array);
- }
- // recursively flatten arrays (susceptible to call stack limits)
- if (isArray(value)) {
- push.apply(result, isShallow ? value : flatten(value));
- } else {
- result.push(value);
- }
+ function flatten(array, isShallow, callback, thisArg) {
+ // juggle arguments
+ if (typeof isShallow != 'boolean' && isShallow != null) {
+ thisArg = callback;
+ callback = !(thisArg && thisArg[isShallow] === array) ? isShallow : null;
+ isShallow = false;
}
- return result;
- });
+ if (callback != null) {
+ array = map(array, callback, thisArg);
+ }
+ return baseFlatten(array, isShallow);
+ }
/**
* Gets the index at which the first occurrence of `value` is found using
- * strict equality for comparisons, i.e. `===`. If the `array` is already
- * sorted, passing `true` for `fromIndex` will run a faster binary search.
+ * strict equality for comparisons, i.e. `===`. If the array is already sorted
+ * providing `true` for `fromIndex` will run a faster binary search.
*
* @static
* @memberOf _
* @category Arrays
* @param {Array} array The array to search.
- * @param {Mixed} value The value to search for.
- * @param {Boolean|Number} [fromIndex=0] The index to search from or `true` to
- * perform a binary search on a sorted `array`.
- * @returns {Number} Returns the index of the matched value or `-1`.
+ * @param {*} value The value to search for.
+ * @param {boolean|number} [fromIndex=0] The index to search from or `true`
+ * to perform a binary search on a sorted array.
+ * @returns {number} Returns the index of the matched value or `-1`.
* @example
*
* _.indexOf([1, 2, 3, 1, 2, 3], 2);
@@ -3878,20 +4407,19 @@
var index = sortedIndex(array, value);
return array[index] === value ? index : -1;
}
- return array ? basicIndexOf(array, value, fromIndex) : -1;
+ return baseIndexOf(array, value, fromIndex);
}
/**
- * Gets all but the last element of `array`. If a number `n` is passed, the
- * last `n` elements are excluded from the result. If a `callback` function
- * is passed, elements at the end of the array are excluded from the result
- * as long as the `callback` returns truthy. The `callback` is bound to
- * `thisArg` and invoked with three arguments; (value, index, array).
+ * Gets all but the last element or last `n` elements of an array. If a
+ * callback is provided elements at the end of the array are excluded from
+ * the result as long as the callback returns truey. The callback is bound
+ * to `thisArg` and invoked with three arguments; (value, index, array).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -3899,11 +4427,11 @@
* @memberOf _
* @category Arrays
* @param {Array} array The array to query.
- * @param {Function|Object|Number|String} [callback|n=1] The function called
+ * @param {Function|Object|number|string} [callback=1] The function called
* per element or the number of elements to exclude. If a property name or
- * object is passed, it will be used to create a "_.pluck" or "_.where"
+ * object is provided it will be used to create a "_.pluck" or "_.where"
* style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Array} Returns a slice of `array`.
* @example
*
@@ -3938,15 +4466,12 @@
* // => [{ 'name': 'banana', 'type': 'fruit' }]
*/
function initial(array, callback, thisArg) {
- if (!array) {
- return [];
- }
var n = 0,
- length = array.length;
+ length = array ? array.length : 0;
if (typeof callback != 'number' && callback != null) {
var index = length;
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
while (index-- && callback(array[index], index, array)) {
n++;
}
@@ -3957,15 +4482,14 @@
}
/**
- * Computes the intersection of all the passed-in arrays using strict equality
- * for comparisons, i.e. `===`.
+ * Creates an array of unique values present in all provided arrays using
+ * strict equality for comparisons, i.e. `===`.
*
* @static
* @memberOf _
* @category Arrays
- * @param {Array} [array1, array2, ...] Arrays to process.
- * @returns {Array} Returns a new array of unique elements that are present
- * in **all** of the arrays.
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of composite values.
* @example
*
* _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
@@ -3984,7 +4508,7 @@
while (++argsIndex < argsLength) {
var value = args[argsIndex];
- caches[argsIndex] = indexOf === basicIndexOf &&
+ caches[argsIndex] = indexOf === baseIndexOf &&
(value ? value.length : 0) >= largeArraySize &&
createCache(argsIndex ? args[argsIndex] : seen);
}
@@ -4017,17 +4541,15 @@
}
/**
- * Gets the last element of the `array`. If a number `n` is passed, the
- * last `n` elements of the `array` are returned. If a `callback` function
- * is passed, elements at the end of the array are returned as long as the
- * `callback` returns truthy. The `callback` is bound to `thisArg` and
- * invoked with three arguments;(value, index, array).
+ * Gets the last element or last `n` elements of an array. If a callback is
+ * provided elements at the end of the array are returned as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
*
- *
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -4035,12 +4557,12 @@
* @memberOf _
* @category Arrays
* @param {Array} array The array to query.
- * @param {Function|Object|Number|String} [callback|n] The function called
+ * @param {Function|Object|number|string} [callback] The function called
* per element or the number of elements to return. If a property name or
- * object is passed, it will be used to create a "_.pluck" or "_.where"
+ * object is provided it will be used to create a "_.pluck" or "_.where"
* style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Mixed} Returns the last element(s) of `array`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
+ * @returns {*} Returns the last element(s) of `array`.
* @example
*
* _.last([1, 2, 3]);
@@ -4074,24 +4596,22 @@
* // => [{ 'name': 'beet', 'type': 'vegetable' }, { 'name': 'carrot', 'type': 'vegetable' }]
*/
function last(array, callback, thisArg) {
- if (array) {
- var n = 0,
- length = array.length;
+ var n = 0,
+ length = array ? array.length : 0;
- if (typeof callback != 'number' && callback != null) {
- var index = length;
- callback = lodash.createCallback(callback, thisArg);
- while (index-- && callback(array[index], index, array)) {
- n++;
- }
- } else {
- n = callback;
- if (n == null || thisArg) {
- return array[length - 1];
- }
+ if (typeof callback != 'number' && callback != null) {
+ var index = length;
+ callback = lodash.createCallback(callback, thisArg, 3);
+ while (index-- && callback(array[index], index, array)) {
+ n++;
+ }
+ } else {
+ n = callback;
+ if (n == null || thisArg) {
+ return array ? array[length - 1] : undefined;
}
- return slice(array, nativeMax(0, length - n));
}
+ return slice(array, nativeMax(0, length - n));
}
/**
@@ -4103,9 +4623,9 @@
* @memberOf _
* @category Arrays
* @param {Array} array The array to search.
- * @param {Mixed} value The value to search for.
- * @param {Number} [fromIndex=array.length-1] The index to search from.
- * @returns {Number} Returns the index of the matched value or `-1`.
+ * @param {*} value The value to search for.
+ * @param {number} [fromIndex=array.length-1] The index to search from.
+ * @returns {number} Returns the index of the matched value or `-1`.
* @example
*
* _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
@@ -4127,16 +4647,53 @@
return -1;
}
+ /**
+ * Removes all provided values from the given array using strict equality for
+ * comparisons, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @param {...*} [value] The values to remove.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3, 1, 2, 3];
+ * _.pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+ function pull(array) {
+ var args = arguments,
+ argsIndex = 0,
+ argsLength = args.length,
+ length = array ? array.length : 0;
+
+ while (++argsIndex < argsLength) {
+ var index = -1,
+ value = args[argsIndex];
+ while (++index < length) {
+ if (array[index] === value) {
+ splice.call(array, index--, 1);
+ length--;
+ }
+ }
+ }
+ return array;
+ }
+
/**
* Creates an array of numbers (positive and/or negative) progressing from
- * `start` up to but not including `end`.
+ * `start` up to but not including `end`. If `start` is less than `stop` a
+ * zero-length range is created unless a negative `step` is specified.
*
* @static
* @memberOf _
* @category Arrays
- * @param {Number} [start=0] The start of the range.
- * @param {Number} end The end of the range.
- * @param {Number} [step=1] The value to increment or decrement by.
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
* @returns {Array} Returns a new range array.
* @example
*
@@ -4149,45 +4706,96 @@
* _.range(0, 30, 5);
* // => [0, 5, 10, 15, 20, 25]
*
- * _.range(0, -10, -1);
- * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+ * _.range(0, -10, -1);
+ * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+ *
+ * _.range(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.range(0);
+ * // => []
+ */
+ function range(start, end, step) {
+ start = +start || 0;
+ step = typeof step == 'number' ? step : (+step || 1);
+
+ if (end == null) {
+ end = start;
+ start = 0;
+ }
+ // use `Array(length)` so engines, like Chakra and V8, avoid slower modes
+ // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+ var index = -1,
+ length = nativeMax(0, ceil((end - start) / (step || 1))),
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = start;
+ start += step;
+ }
+ return result;
+ }
+
+ /**
+ * Removes all elements from an array that the callback returns truey for
+ * and returns an array of removed elements. The callback is bound to `thisArg`
+ * and invoked with three arguments; (value, index, array).
+ *
+ * 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 _
+ * @category Arrays
+ * @param {Array} array The array to modify.
+ * @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 {Array} Returns a new array of removed elements.
+ * @example
+ *
+ * var array = [1, 2, 3, 4, 5, 6];
+ * var evens = _.remove(array, function(num) { return num % 2 == 0; });
+ *
+ * console.log(array);
+ * // => [1, 3, 5]
*
- * _.range(0);
- * // => []
+ * console.log(evens);
+ * // => [2, 4, 6]
*/
- function range(start, end, step) {
- start = +start || 0;
- step = +step || 1;
-
- if (end == null) {
- end = start;
- start = 0;
- }
- // use `Array(length)` so V8 will avoid the slower "dictionary" mode
- // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+ function remove(array, callback, thisArg) {
var index = -1,
- length = nativeMax(0, ceil((end - start) / step)),
- result = Array(length);
+ length = array ? array.length : 0,
+ result = [];
+ callback = lodash.createCallback(callback, thisArg, 3);
while (++index < length) {
- result[index] = start;
- start += step;
+ var value = array[index];
+ if (callback(value, index, array)) {
+ result.push(value);
+ splice.call(array, index--, 1);
+ length--;
+ }
}
return result;
}
/**
- * The opposite of `_.initial`, this method gets all but the first value of
- * `array`. If a number `n` is passed, the first `n` values are excluded from
- * the result. If a `callback` function is passed, elements at the beginning
- * of the array are excluded from the result as long as the `callback` returns
- * truthy. The `callback` is bound to `thisArg` and invoked with three
- * arguments; (value, index, array).
+ * The opposite of `_.initial` this method gets all but the first element or
+ * first `n` elements of an array. If a callback function is provided elements
+ * at the beginning of the array are excluded from the result as long as the
+ * callback returns truey. The callback is bound to `thisArg` and invoked
+ * with three arguments; (value, index, array).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -4196,11 +4804,11 @@
* @alias drop, tail
* @category Arrays
* @param {Array} array The array to query.
- * @param {Function|Object|Number|String} [callback|n=1] The function called
+ * @param {Function|Object|number|string} [callback=1] The function called
* per element or the number of elements to exclude. If a property name or
- * object is passed, it will be used to create a "_.pluck" or "_.where"
+ * object is provided it will be used to create a "_.pluck" or "_.where"
* style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {*} [thisArg] The `this` binding of `callback`.
* @returns {Array} Returns a slice of `array`.
* @example
*
@@ -4240,7 +4848,7 @@
index = -1,
length = array ? array.length : 0;
- callback = lodash.createCallback(callback, thisArg);
+ callback = lodash.createCallback(callback, thisArg, 3);
while (++index < length && callback(array[index], index, array)) {
n++;
}
@@ -4251,16 +4859,16 @@
}
/**
- * Uses a binary search to determine the smallest index at which the `value`
- * should be inserted into `array` in order to maintain the sort order of the
- * sorted `array`. If `callback` is passed, it will be executed for `value` and
- * each element in `array` to compute their sort ranking. The `callback` is
- * bound to `thisArg` and invoked with one argument; (value).
+ * Uses a binary search to determine the smallest index at which a value
+ * should be inserted into a given sorted array in order to maintain the sort
+ * order of the array. If a callback is provided it will be executed for
+ * `value` and each element of `array` to compute their sort ranking. The
+ * callback is bound to `thisArg` and invoked with one argument; (value).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -4268,12 +4876,12 @@
* @memberOf _
* @category Arrays
* @param {Array} array The array to inspect.
- * @param {Mixed} value The value to evaluate.
- * @param {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
- * @returns {Number} Returns the index at which the value should be inserted
+ * @param {*} value The value to evaluate.
+ * @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 {number} Returns the index at which `value` should be inserted
* into `array`.
* @example
*
@@ -4316,38 +4924,35 @@
}
/**
- * Computes the union of the passed-in arrays using strict equality for
- * comparisons, i.e. `===`.
+ * Creates an array of unique values, in order, of the provided arrays using
+ * strict equality for comparisons, i.e. `===`.
*
* @static
* @memberOf _
* @category Arrays
- * @param {Array} [array1, array2, ...] Arrays to process.
- * @returns {Array} Returns a new array of unique values, in order, that are
- * present in one or more of the arrays.
+ * @param {...Array} [array] The arrays to inspect.
+ * @returns {Array} Returns an array of composite values.
* @example
*
* _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
* // => [1, 2, 3, 101, 10]
*/
function union(array) {
- if (!isArray(array)) {
- arguments[0] = array ? nativeSlice.call(array) : arrayRef;
- }
- return uniq(concat.apply(arrayRef, arguments));
+ return baseUniq(baseFlatten(arguments, true, true));
}
/**
- * Creates a duplicate-value-free version of the `array` using strict equality
- * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true`
- * for `isSorted` will run a faster algorithm. If `callback` is passed, each
- * element of `array` is passed through the `callback` before uniqueness is computed.
- * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array).
+ * Creates a duplicate-value-free version of an array using strict equality
+ * for comparisons, i.e. `===`. If the array is sorted, providing
+ * `true` for `isSorted` will use a faster algorithm. If a callback is provided
+ * each element of `array` is passed through the callback before uniqueness
+ * is computed. The callback is bound to `thisArg` and invoked with three
+ * arguments; (value, index, array).
*
- * If a property name is passed for `callback`, the created "_.pluck" style
+ * 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 passed for `callback`, the created "_.where" style callback
+ * 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`.
*
@@ -4356,11 +4961,11 @@
* @alias unique
* @category Arrays
* @param {Array} array The array to process.
- * @param {Boolean} [isSorted=false] A flag to indicate that the `array` is already sorted.
- * @param {Function|Object|String} [callback=identity] The function called per
- * iteration. If a property name or object is passed, it will be used to create
- * a "_.pluck" or "_.where" style callback, respectively.
- * @param {Mixed} [thisArg] The `this` binding of `callback`.
+ * @param {boolean} [isSorted=false] A flag to indicate that `array` is sorted.
+ * @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 {Array} Returns a duplicate-value-free array.
* @example
*
@@ -4380,83 +4985,29 @@
* _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 1 }, { 'x': 2 }]
*/
- var uniq = overloadWrapper(function(array, isSorted, callback) {
- var index = -1,
- indexOf = getIndexOf(),
- length = array ? array.length : 0,
- result = [];
-
- var isLarge = !isSorted && length >= largeArraySize && indexOf === basicIndexOf,
- seen = (callback || isLarge) ? getArray() : result;
-
- if (isLarge) {
- var cache = createCache(seen);
- if (cache) {
- indexOf = cacheIndexOf;
- seen = cache;
- } else {
- isLarge = false;
- seen = callback ? seen : (releaseArray(seen), result);
- }
- }
- while (++index < length) {
- var value = array[index],
- computed = callback ? callback(value, index, array) : value;
-
- if (isSorted
- ? !index || seen[seen.length - 1] !== computed
- : indexOf(seen, computed) < 0
- ) {
- if (callback || isLarge) {
- seen.push(computed);
- }
- result.push(value);
- }
- }
- if (isLarge) {
- releaseArray(seen.array);
- releaseObject(seen);
- } else if (callback) {
- releaseArray(seen);
+ function uniq(array, isSorted, callback, thisArg) {
+ // juggle arguments
+ if (typeof isSorted != 'boolean' && isSorted != null) {
+ thisArg = callback;
+ callback = !(thisArg && thisArg[isSorted] === array) ? isSorted : null;
+ isSorted = false;
}
- return result;
- });
-
- /**
- * The inverse of `_.zip`, this method splits groups of elements into arrays
- * composed of elements from each group at their corresponding indexes.
- *
- * @static
- * @memberOf _
- * @category Arrays
- * @param {Array} array The array to process.
- * @returns {Array} Returns a new array of the composed arrays.
- * @example
- *
- * _.unzip([['moe', 30, true], ['larry', 40, false]]);
- * // => [['moe', 'larry'], [30, 40], [true, false]];
- */
- function unzip(array) {
- var index = -1,
- length = array ? max(pluck(array, 'length')) : 0,
- result = Array(length < 0 ? 0 : length);
-
- while (++index < length) {
- result[index] = pluck(array, index);
+ if (callback != null) {
+ callback = lodash.createCallback(callback, thisArg, 3);
}
- return result;
+ return baseUniq(array, isSorted, callback);
}
/**
- * Creates an array with all occurrences of the passed values removed using
- * strict equality for comparisons, i.e. `===`.
+ * Creates an array excluding all provided values using strict equality for
+ * comparisons, i.e. `===`.
*
* @static
* @memberOf _
* @category Arrays
* @param {Array} array The array to filter.
- * @param {Mixed} [value1, value2, ...] Values to remove.
- * @returns {Array} Returns a new filtered array.
+ * @param {...*} [value] The values to exclude.
+ * @returns {Array} Returns a new array of filtered values.
* @example
*
* _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
@@ -4467,29 +5018,37 @@
}
/**
- * Groups the elements of each array at their corresponding indexes. Useful for
- * separate data sources that are coordinated through matching array indexes.
- * For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix
- * in a similar fashion.
+ * Creates an array of grouped elements, the first of which contains the first
+ * elements of the given arrays, the second of which contains the second
+ * elements of the given arrays, and so on.
*
* @static
* @memberOf _
+ * @alias unzip
* @category Arrays
- * @param {Array} [array1, array2, ...] Arrays to process.
+ * @param {...Array} [array] Arrays to process.
* @returns {Array} Returns a new array of grouped elements.
* @example
*
* _.zip(['moe', 'larry'], [30, 40], [true, false]);
* // => [['moe', 30, true], ['larry', 40, false]]
*/
- function zip(array) {
- return array ? unzip(arguments) : [];
+ function zip() {
+ var array = arguments.length > 1 ? arguments : arguments[0],
+ index = -1,
+ length = array ? max(pluck(array, 'length')) : 0,
+ result = Array(length < 0 ? 0 : length);
+
+ while (++index < length) {
+ result[index] = pluck(array, index);
+ }
+ return result;
}
/**
- * Creates an object composed from arrays of `keys` and `values`. Pass either
- * a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or
- * two arrays, one of `keys` and one of corresponding `values`.
+ * Creates an object composed from arrays of `keys` and `values`. Provide
+ * either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`
+ * or two arrays, one of `keys` and one of corresponding `values`.
*
* @static
* @memberOf _
@@ -4513,7 +5072,7 @@
var key = keys[index];
if (values) {
result[key] = values[index];
- } else {
+ } else if (key) {
result[key[0]] = key[1];
}
}
@@ -4523,30 +5082,32 @@
/*--------------------------------------------------------------------------*/
/**
- * If `n` is greater than `0`, a function is created that is restricted to
- * executing `func`, with the `this` binding and arguments of the created
- * function, only after it is called `n` times. If `n` is less than `1`,
- * `func` is executed immediately, without a `this` binding or additional
- * arguments, and its result is returned.
+ * 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
- * it is executed.
+ * @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 renderNotes = _.after(notes.length, render);
- * _.forEach(notes, function(note) {
- * note.asyncSave({ 'success': renderNotes });
+ * var saves = ['profile', 'settings'];
+ *
+ * var done = _.after(saves.length, function() {
+ * console.log('Done saving!');
* });
- * // `renderNotes` is run once, after all notes have saved
+ *
+ * _.forEach(saves, function(type) {
+ * asyncSave({ 'type': type, 'complete': done });
+ * });
+ * // => logs 'Done saving!', after all saves have completed
*/
function after(n, func) {
- if (n < 1) {
- return func();
+ if (!isFunction(func)) {
+ throw new TypeError;
}
return function() {
if (--n < 1) {
@@ -4558,14 +5119,14 @@
/**
* Creates a function that, when called, invokes `func` with the `this`
* binding of `thisArg` and prepends any additional `bind` arguments to those
- * passed to the bound function.
+ * provided to the bound function.
*
* @static
* @memberOf _
* @category Functions
* @param {Function} func The function to bind.
- * @param {Mixed} [thisArg] The `this` binding of `func`.
- * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @param {*} [thisArg] The `this` binding of `func`.
+ * @param {...*} [arg] Arguments to be partially applied.
* @returns {Function} Returns the new bound function.
* @example
*
@@ -4578,51 +5139,50 @@
* // => 'hi moe'
*/
function bind(func, thisArg) {
- // use `Function#bind` if it exists and is fast
- // (in V8 `Function#bind` is slower except when partially applied)
- return support.fastBind || (nativeBind && arguments.length > 2)
- ? nativeBind.call.apply(nativeBind, arguments)
- : createBound(func, thisArg, nativeSlice.call(arguments, 2));
+ return arguments.length > 2
+ ? createBound(func, 17, nativeSlice.call(arguments, 2), null, thisArg)
+ : createBound(func, 1, null, null, thisArg);
}
/**
- * Binds methods on `object` to `object`, 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.
+ * 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} [methodName1, methodName2, ...] Method names on the object to bind.
+ * @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() { alert('clicked ' + this.label); }
+ * 'onClick': function() { console.log('clicked ' + this.label); }
* };
*
* _.bindAll(view);
* jQuery('#docs').on('click', view.onClick);
- * // => alerts 'clicked docs', when the button is clicked
+ * // => logs 'clicked docs', when the button is clicked
*/
function bindAll(object) {
- var funcs = arguments.length > 1 ? concat.apply(arrayRef, nativeSlice.call(arguments, 1)) : functions(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] = bind(object[key], object);
+ object[key] = createBound(object[key], 1, null, null, object);
}
return object;
}
/**
* Creates a function that, when called, invokes the method at `object[key]`
- * and prepends any additional `bindKey` arguments to those passed to the bound
+ * 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.
@@ -4631,8 +5191,8 @@
* @memberOf _
* @category Functions
* @param {Object} object The object the method belongs to.
- * @param {String} key The key of the method.
- * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @param {string} key The key of the method.
+ * @param {...*} [arg] Arguments to be partially applied.
* @returns {Function} Returns the new bound function.
* @example
*
@@ -4655,11 +5215,13 @@
* // => 'hi, moe!'
*/
function bindKey(object, key) {
- return createBound(object, key, nativeSlice.call(arguments, 2), indicatorObject);
+ return arguments.length > 2
+ ? createBound(key, 19, nativeSlice.call(arguments, 2), null, object)
+ : createBound(key, 3, null, null, object);
}
/**
- * Creates a function that is the composition of the passed functions,
+ * 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.
@@ -4667,18 +5229,36 @@
* @static
* @memberOf _
* @category Functions
- * @param {Function} [func1, func2, ...] Functions to compose.
+ * @param {...Function} [func] Functions to compose.
* @returns {Function} Returns the new composed function.
* @example
*
- * var greet = function(name) { return 'hi ' + name; };
- * var exclaim = function(statement) { return statement + '!'; };
- * var welcome = _.compose(exclaim, greet);
- * welcome('moe');
- * // => 'hi moe!'
+ * var realNameMap = {
+ * 'curly': 'jerome'
+ * };
+ *
+ * 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('curly');
+ * // => 'Hiya Jerome!'
*/
function compose() {
- var funcs = arguments;
+ var funcs = arguments,
+ length = funcs.length || 1;
+
+ while (length--) {
+ if (!isFunction(funcs[length])) {
+ throw new TypeError;
+ }
+ }
return function() {
var args = arguments,
length = funcs.length;
@@ -4692,18 +5272,16 @@
/**
* 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
+ * 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`.
*
- * Note: All Lo-Dash methods, that accept a `callback` argument, use `_.createCallback`.
- *
* @static
* @memberOf _
* @category Functions
- * @param {Mixed} [func=identity] The value to convert to a callback.
- * @param {Mixed} [thisArg] The `this` binding of the created callback.
- * @param {Number} [argCount=3] The number of arguments the callback accepts.
+ * @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
*
@@ -4722,74 +5300,85 @@
*
* _.filter(stooges, 'age__gt45');
* // => [{ 'name': 'larry', 'age': 50 }]
- *
- * // create mixins with support for "_.pluck" and "_.where" callback shorthands
- * _.mixin({
- * 'toLookup': function(collection, callback, thisArg) {
- * callback = _.createCallback(callback, thisArg);
- * return _.reduce(collection, function(result, value, index, collection) {
- * return (result[callback(value, index, collection)] = value, result);
- * }, {});
- * }
- * });
- *
- * _.toLookup(stooges, 'name');
- * // => { 'moe': { 'name': 'moe', 'age': 40 }, 'larry': { 'name': 'larry', 'age': 50 } }
*/
function createCallback(func, thisArg, argCount) {
- if (func == null) {
- return identity;
- }
var type = typeof func;
- if (type != 'function') {
- if (type != 'object') {
- return function(object) {
- return object[func];
- };
- }
- var props = keys(func);
- return function(object) {
- var length = props.length,
- result = false;
- while (length--) {
- if (!(result = isEqual(object[props[length]], func[props[length]], indicatorObject))) {
- break;
- }
- }
- return result;
- };
- }
- if (typeof thisArg == 'undefined' || (reThis && !reThis.test(fnToString.call(func)))) {
- return func;
- }
- if (argCount === 1) {
- return function(value) {
- return func.call(thisArg, value);
- };
+ if (func == null || type == 'function') {
+ return baseCreateCallback(func, thisArg, argCount);
}
- if (argCount === 2) {
- return function(a, b) {
- return func.call(thisArg, a, b);
+ // handle "_.pluck" style callback shorthands
+ if (type != 'object') {
+ return function(object) {
+ return object[func];
};
}
- if (argCount === 4) {
- return function(accumulator, value, index, collection) {
- return func.call(thisArg, accumulator, value, index, collection);
+ 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(value, index, collection) {
- return func.call(thisArg, value, index, collection);
+ 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;
};
}
+ /**
+ * 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 createBound(func, 4, null, null, null, arity);
+ }
+
/**
* Creates a function that will delay the execution of `func` until after
- * `wait` milliseconds have elapsed since the last time it was invoked. Pass
- * 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.
+ * `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
+ * 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.
*
@@ -4797,139 +5386,159 @@
* @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.
- * [leading=false] A boolean to specify execution on the leading edge of the timeout.
- * [maxWait] The maximum time `func` is allowed to be delayed before it's called.
- * [trailing=true] A boolean to specify execution on the trailing edge of the timeout.
+ * @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
*
- * var lazyLayout = _.debounce(calculateLayout, 300);
+ * // avoid costly calculations while the window size is in flux
+ * var lazyLayout = _.debounce(calculateLayout, 150);
* jQuery(window).on('resize', lazyLayout);
*
- * jQuery('#postbox').on('click', _.debounce(sendMail, 200, {
+ * // 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,
- callCount = 0,
+ timeoutId,
+ trailingCall,
lastCalled = 0,
maxWait = false,
- maxTimeoutId = null,
- timeoutId = null,
trailing = true;
- function clear() {
- clearTimeout(maxTimeoutId);
- clearTimeout(timeoutId);
- callCount = 0;
- maxTimeoutId = timeoutId = null;
+ if (!isFunction(func)) {
+ throw new TypeError;
}
-
- function delayed() {
- var isCalled = trailing && (!leading || callCount > 1);
- clear();
- if (isCalled) {
- if (maxWait !== false) {
- lastCalled = new Date;
- }
- result = func.apply(thisArg, args);
- }
- }
-
- function maxDelayed() {
- clear();
- if (trailing || (maxWait !== wait)) {
- lastCalled = new Date;
- result = func.apply(thisArg, args);
- }
- }
-
- wait = nativeMax(0, wait || 0);
+ 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);
+ maxWait = 'maxWait' in options && (nativeMax(wait, options.maxWait) || 0);
trailing = 'trailing' in options ? options.trailing : trailing;
}
+ var delayed = function() {
+ var remaining = wait - (new Date - stamp);
+ if (remaining <= 0) {
+ if (maxTimeoutId) {
+ clearTimeout(maxTimeoutId);
+ }
+ var isCalled = trailingCall;
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (isCalled) {
+ lastCalled = +new Date;
+ result = func.apply(thisArg, args);
+ }
+ } else {
+ timeoutId = setTimeout(delayed, remaining);
+ }
+ };
+
+ var maxDelayed = function() {
+ if (timeoutId) {
+ clearTimeout(timeoutId);
+ }
+ maxTimeoutId = timeoutId = trailingCall = undefined;
+ if (trailing || (maxWait !== wait)) {
+ lastCalled = +new Date;
+ result = func.apply(thisArg, args);
+ }
+ };
+
return function() {
args = arguments;
+ stamp = +new Date;
thisArg = this;
- callCount++;
-
- // avoid issues with Titanium and `undefined` timeout ids
- // https://github.com/appcelerator/titanium_mobile/blob/3_1_0_GA/android/titanium/src/java/ti/modules/titanium/TitaniumModule.java#L185-L192
- clearTimeout(timeoutId);
+ trailingCall = trailing && (timeoutId || !leading);
if (maxWait === false) {
- if (leading && callCount < 2) {
- result = func.apply(thisArg, args);
- }
+ var leadingCall = leading && !timeoutId;
} else {
- var now = new Date;
if (!maxTimeoutId && !leading) {
- lastCalled = now;
+ lastCalled = stamp;
}
- var remaining = maxWait - (now - lastCalled);
+ var remaining = maxWait - (stamp - lastCalled);
if (remaining <= 0) {
- clearTimeout(maxTimeoutId);
- maxTimeoutId = null;
- lastCalled = now;
+ if (maxTimeoutId) {
+ maxTimeoutId = clearTimeout(maxTimeoutId);
+ }
+ lastCalled = stamp;
result = func.apply(thisArg, args);
}
else if (!maxTimeoutId) {
maxTimeoutId = setTimeout(maxDelayed, remaining);
}
}
- if (wait !== maxWait) {
+ if (!timeoutId && wait !== maxWait) {
timeoutId = setTimeout(delayed, wait);
}
+ if (leadingCall) {
+ result = func.apply(thisArg, args);
+ }
return result;
};
}
/**
* Defers executing the `func` function until the current call stack has cleared.
- * Additional arguments will be passed to `func` when it is invoked.
+ * Additional arguments will be provided to `func` when it is invoked.
*
* @static
* @memberOf _
* @category Functions
* @param {Function} func The function to defer.
- * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
- * @returns {Number} Returns the timer id.
+ * @param {...*} [arg] Arguments to invoke the function with.
+ * @returns {number} Returns the timer id.
* @example
*
- * _.defer(function() { alert('deferred'); });
- * // returns from the function before `alert` is called
+ * _.defer(function() { console.log('deferred'); });
+ * // returns from the function before 'deferred' is logged
*/
function defer(func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
var args = nativeSlice.call(arguments, 1);
return setTimeout(function() { func.apply(undefined, args); }, 1);
}
- // use `setImmediate` if it's available in Node.js
+ // use `setImmediate` if available in Node.js
if (isV8 && freeModule && typeof setImmediate == 'function') {
- defer = bind(setImmediate, context);
+ defer = function(func) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ return setImmediate.apply(context, arguments);
+ };
}
/**
* Executes the `func` function after `wait` milliseconds. Additional arguments
- * will be passed to `func` when it is invoked.
+ * 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 {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
- * @returns {Number} Returns the timer id.
+ * @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
*
* var log = _.bind(console.log, console);
@@ -4937,17 +5546,20 @@
* // => 'logged later' (Appears after one second.)
*/
function delay(func, wait) {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
var args = nativeSlice.call(arguments, 2);
return setTimeout(function() { func.apply(undefined, args); }, wait);
}
/**
* Creates a function that memoizes the result of `func`. If `resolver` is
- * passed, it will be used to determine the cache key for storing the result
- * based on the arguments passed to the memoized function. By default, the first
- * argument passed 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.
+ * 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 _
@@ -4960,11 +5572,28 @@
* var fibonacci = _.memoize(function(n) {
* return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
* });
+ *
+ * var data = {
+ * 'moe': { 'name': 'moe', 'age': 40 },
+ * 'curly': { 'name': 'curly', 'age': 60 }
+ * };
+ *
+ * // modifying the result cache
+ * var stooge = _.memoize(function(name) { return data[name]; }, _.identity);
+ * stooge('curly');
+ * // => { 'name': 'curly', 'age': 60 }
+ *
+ * stooge.cache.curly.name = 'jerome';
+ * stooge('curly');
+ * // => { 'name': 'jerome', 'age': 60 }
*/
function memoize(func, resolver) {
- function memoized() {
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
+ var memoized = function() {
var cache = memoized.cache,
- key = keyPrefix + (resolver ? resolver.apply(this, arguments) : arguments[0]);
+ key = resolver ? resolver.apply(this, arguments) : keyPrefix + arguments[0];
return hasOwnProperty.call(cache, key)
? cache[key]
@@ -4995,6 +5624,9 @@
var ran,
result;
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
return function() {
if (ran) {
return result;
@@ -5010,14 +5642,14 @@
/**
* Creates a function that, when called, invokes `func` with any additional
- * `partial` arguments prepended to those passed to the new function. This
- * method is similar to `_.bind`, except it does **not** alter the `this` binding.
+ * `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 {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @param {...*} [arg] Arguments to be partially applied.
* @returns {Function} Returns the new partially applied function.
* @example
*
@@ -5027,18 +5659,18 @@
* // => 'hi moe'
*/
function partial(func) {
- return createBound(func, nativeSlice.call(arguments, 1));
+ return createBound(func, 16, nativeSlice.call(arguments, 1));
}
/**
- * This method is similar to `_.partial`, except that `partial` arguments are
- * appended to those passed to the new function.
+ * 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 {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+ * @param {...*} [arg] Arguments to be partially applied.
* @returns {Function} Returns the new partially applied function.
* @example
*
@@ -5058,17 +5690,17 @@
* // => { '_': _, 'jq': $ }
*/
function partialRight(func) {
- return createBound(func, nativeSlice.call(arguments, 1), null, indicatorObject);
+ return createBound(func, 32, null, nativeSlice.call(arguments, 1));
}
/**
* Creates a function that, when executed, will only call the `func` function
- * at most once per every `wait` milliseconds. Pass an `options` object to
+ * 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
+ * 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.
*
@@ -5076,16 +5708,18 @@
* @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.
- * [leading=true] A boolean to specify execution on the leading edge of the timeout.
- * [trailing=true] A boolean to specify execution on the trailing edge of the timeout.
+ * @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
* }));
@@ -5094,6 +5728,9 @@
var leading = true,
trailing = true;
+ if (!isFunction(func)) {
+ throw new TypeError;
+ }
if (options === false) {
leading = false;
} else if (isObject(options)) {
@@ -5111,15 +5748,15 @@
}
/**
- * Creates a function that passes `value` to the `wrapper` function as its
- * first argument. Additional arguments passed to the function are appended
- * to those passed to the `wrapper` function. The `wrapper` is executed with
+ * 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 {Mixed} value The value to wrap.
+ * @param {*} value The value to wrap.
* @param {Function} wrapper The wrapper function.
* @returns {Function} Returns the new function.
* @example
@@ -5132,6 +5769,9 @@
* // => 'before, hello moe, after'
*/
function wrap(value, wrapper) {
+ if (!isFunction(wrapper)) {
+ throw new TypeError;
+ }
return function() {
var args = [value];
push.apply(args, arguments);
@@ -5148,8 +5788,8 @@
* @static
* @memberOf _
* @category Utilities
- * @param {String} string The string to escape.
- * @returns {String} Returns the escaped string.
+ * @param {string} string The string to escape.
+ * @returns {string} Returns the escaped string.
* @example
*
* _.escape('Moe, Larry & Curly');
@@ -5160,13 +5800,13 @@
}
/**
- * This method returns the first argument passed to it.
+ * This method returns the first argument provided to it.
*
* @static
* @memberOf _
* @category Utilities
- * @param {Mixed} value Any value.
- * @returns {Mixed} Returns `value`.
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
* @example
*
* var moe = { 'name': 'moe' };
@@ -5178,13 +5818,14 @@
}
/**
- * Adds functions properties of `object` to the `lodash` function and chainable
- * wrapper.
+ * Adds function properties of a source object to the `lodash` function and
+ * chainable wrapper.
*
* @static
* @memberOf _
* @category Utilities
* @param {Object} object The object of function properties to add to `lodash`.
+ * @param {Object} object The object of function properties to add to `lodash`.
* @example
*
* _.mixin({
@@ -5199,20 +5840,29 @@
* _('moe').capitalize();
* // => 'Moe'
*/
- function mixin(object) {
- forEach(functions(object), function(methodName) {
- var func = lodash[methodName] = object[methodName];
-
- lodash.prototype[methodName] = function() {
- var value = this.__wrapped__,
- args = [value];
-
- push.apply(args, arguments);
- var result = func.apply(lodash, args);
- return (value && typeof value == 'object' && value === result)
- ? this
- : new lodashWrapper(result);
- };
+ function mixin(object, source) {
+ var ctor = object,
+ isFunc = !source || isFunction(ctor);
+
+ if (!source) {
+ ctor = lodashWrapper;
+ source = object;
+ object = lodash;
+ }
+ forEach(functions(source), function(methodName) {
+ var func = object[methodName] = source[methodName];
+ if (isFunc) {
+ ctor.prototype[methodName] = function() {
+ var value = this.__wrapped__,
+ args = [value];
+
+ push.apply(args, arguments);
+ var result = func.apply(object, args);
+ return (value && typeof value == 'object' && value === result)
+ ? this
+ : new ctor(result);
+ };
+ }
});
}
@@ -5235,18 +5885,18 @@
/**
* Converts the given `value` into an integer of the specified `radix`.
- * If `radix` is `undefined` or `0`, a `radix` of `10` is used unless the
+ * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the
* `value` is a hexadecimal, in which case a `radix` of `16` is used.
*
* Note: This method avoids differences in native ES3 and ES5 `parseInt`
- * implementations. See http://es5.github.com/#E.
+ * implementations. See http://es5.github.io/#E.
*
* @static
* @memberOf _
* @category Utilities
- * @param {String} value The value to parse.
- * @param {Number} [radix] The radix used to interpret the value to parse.
- * @returns {Number} Returns the new integer value.
+ * @param {string} value The value to parse.
+ * @param {number} [radix] The radix used to interpret the value to parse.
+ * @returns {number} Returns the new integer value.
* @example
*
* _.parseInt('08');
@@ -5259,14 +5909,15 @@
/**
* Produces a random number between `min` and `max` (inclusive). If only one
- * argument is passed, a number between `0` and the given number will be returned.
+ * argument is provided a number between `0` and the given number will be
+ * returned.
*
* @static
* @memberOf _
* @category Utilities
- * @param {Number} [min=0] The minimum possible value.
- * @param {Number} [max=1] The maximum possible value.
- * @returns {Number} Returns a random number.
+ * @param {number} [min=0] The minimum possible value.
+ * @param {number} [max=1] The maximum possible value.
+ * @returns {number} Returns a random number.
* @example
*
* _.random(0, 5);
@@ -5293,17 +5944,17 @@
}
/**
- * Resolves the value of `property` on `object`. If `property` is a function,
+ * Resolves the value of `property` on `object`. If `property` is a function
* it will be invoked with the `this` binding of `object` and its result returned,
- * else the property value is returned. If `object` is falsey, then `undefined`
+ * else the property value is returned. If `object` is falsey then `undefined`
* is returned.
*
* @static
* @memberOf _
* @category Utilities
* @param {Object} object The object to inspect.
- * @param {String} property The property to get the value of.
- * @returns {Mixed} Returns the resolved value.
+ * @param {string} property The property to get the value of.
+ * @returns {*} Returns the resolved value.
* @example
*
* var object = {
@@ -5320,8 +5971,10 @@
* // => 'nonsense'
*/
function result(object, property) {
- var value = object ? object[property] : undefined;
- return isFunction(value) ? object[property]() : value;
+ if (object) {
+ var value = object[property];
+ return isFunction(value) ? object[property]() : value;
+ }
}
/**
@@ -5340,40 +5993,42 @@
* @static
* @memberOf _
* @category Utilities
- * @param {String} text The template text.
+ * @param {string} text The template text.
* @param {Object} data The data object used to populate the text.
- * @param {Object} options The options object.
- * escape - The "escape" delimiter regexp.
- * evaluate - The "evaluate" delimiter regexp.
- * interpolate - The "interpolate" delimiter regexp.
- * sourceURL - The sourceURL of the template's compiled source.
- * variable - The data object variable name.
- * @returns {Function|String} Returns a compiled function when no `data` object
+ * @param {Object} [options] The options object.
+ * @param {RegExp} [options.escape] The "escape" delimiter.
+ * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
+ * @param {Object} [options.imports] An object to import into the template as local variables.
+ * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
+ * @param {string} [sourceURL] The sourceURL of the template's compiled source.
+ * @param {string} [variable] The data object variable name.
+ * @returns {Function|string} Returns a compiled function when no `data` object
* is given, else it returns the interpolated text.
* @example
*
- * // using a compiled template
+ * // using the "interpolate" delimiter to create a compiled template
* var compiled = _.template('hello <%= name %>');
* compiled({ 'name': 'moe' });
* // => 'hello moe'
*
- * var list = '<% _.forEach(people, function(name) { %><%= name %><% }); %>';
- * _.template(list, { 'people': ['moe', 'larry'] });
- * // => 'moelarry'
- *
* // using the "escape" delimiter to escape HTML in data property values
* _.template('<%- value %>', { 'value': '
+
@@ -26,12 +26,12 @@ Test
diff --git a/test/index.html b/test/index.html
index d813aa57f9..1059917c26 100644
--- a/test/index.html
+++ b/test/index.html
@@ -22,64 +22,103 @@
Object.keys = function() { return []; };
// load Lo-Dash and expose it to the bad `Object.keys` shim
- document.write('
diff --git a/test/run-test.sh b/test/run-test.sh
index 4f81a65146..70a41bc87c 100644
--- a/test/run-test.sh
+++ b/test/run-test.sh
@@ -9,10 +9,6 @@ done
echo "Testing in node..."
node test.js ../dist/lodash.js && node test.js ../dist/lodash.min.js
-echo ""
-echo "Testing build..."
-node test-build.js
-
echo ""
echo "Testing in a browser..."
open index.html
diff --git a/test/template/a.jst b/test/template/a.jst
deleted file mode 100644
index cca541d8f7..0000000000
--- a/test/template/a.jst
+++ /dev/null
@@ -1,3 +0,0 @@
-